How to use Sum method of example Package

Best Got code snippet using example.Sum

acc_test.go

Source:acc_test.go Github

copy

Full Screen

...13	fmt.Println("-1 negative:    ", math.Signbit(-1))14	fmt.Println("AccSignBit 0:   ", accsum.AccSignBit([]float64{0}))15	fmt.Println("AccSignBit -1:  ", accsum.AccSignBit([]float64{-1}))16	p := []float64{1e20, -1, -1e20}17	fmt.Println("Signbit(Sum(p)):", math.Signbit(accsum.Sum(p)))18	p = []float64{1e20, -1, -1e20}19	fmt.Println("AccSignBit(p):  ", accsum.AccSignBit(p))20	fmt.Println("p after AccSignBit:", p)21	// Output:22	// 0  negative:     false23	// -1 negative:     true24	// AccSignBit 0:    false25	// AccSignBit -1:   true26	// Signbit(Sum(p)): false27	// AccSignBit(p):   true28}29*/30func ExampleAccSum() {31	n := 5432132	p := make([]float64, n+1)33	for i := range p {34		p[i] = float64(i)35	}36	p[0] = 1e2037	fmt.Printf("Simple:   %.16e\n", accsum.Sum(p))38	fmt.Printf("AccSum:   %.16e\n", accsum.AccSum(p))39	fmt.Println("Triangle:            ", n*(n+1)/2)40	// Output:41	// Simple:   1.0000000000146203e+2042	// AccSum:   1.0000000000147541e+2043	// Triangle:             147541268144}45func ExampleAccSumHuge() {46	n := 5432147	p := make([]float64, n+1)48	for i := range p {49		p[i] = float64(i)50	}51	p[0] = 1e2052	fmt.Printf("Simple:     %.16e\n", accsum.Sum(p))53	fmt.Printf("AccSumHuge: %.16e\n", accsum.AccSumHuge(p))54	fmt.Println("Triangle:              ", n*(n+1)/2)55	// Output:56	// Simple:     1.0000000000146203e+2057	// AccSumHuge: 1.0000000000147541e+2058	// Triangle:               147541268159}60func ExampleAccSumK() {61	p := []float64{1e20, 1, 1, 1e20}62	r := accsum.AccSumK(p, 2)63	fmt.Println(r[0], "+", r[1])64	// Output:65	// 2e+20 + 266}67func ExampleDot2() {68	n := 432169	x := make([]float64, n+1)70	for i := range x {71		x[i] = float64(i)72	}73	x[0] = 1e1174	fmt.Printf("Simple:   %.16e\n", accsum.Dot(x, x))75	fmt.Printf("Dot2:     %.16e\n", accsum.Dot2(x, x))76	fmt.Println("Square triangle:      ", n*(n+1)*(2*n+1)/6)77	// Output:78	// Simple:   1.0000000000026734e+2279	// Dot2:     1.0000000000026902e+2280	// Square triangle:       2690185896181}82func ExampleDot2Err() {83	n := 432184	x := make([]float64, n+1)85	for i := range x {86		x[i] = float64(i)87	}88	x[0] = 1e1189	fmt.Printf("Simple:   %.16e\n", accsum.Dot(x, x))90	dot, err := accsum.Dot2Err(x, x)91	fmt.Printf("Dot2:     %.16e\n", dot)92	fmt.Printf("Square triangle:   %15d\n", n*(n+1)*(2*n+1)/6)93	fmt.Printf("Dot2Err:           %15.0f\n", err)94	// Output:95	// Simple:   1.0000000000026734e+2296	// Dot2:     1.0000000000026902e+2297	// Square triangle:       2690185896198	// Dot2Err:                   111022399}100func ExampleDotK() {101	n := 4321102	x := make([]float64, n+1)103	for i := range x {104		x[i] = float64(i)105	}106	x[0] = 1e11107	fmt.Printf("Simple:    %.16e\n", accsum.Dot(x, x))108	fmt.Printf("DotK(K=3): %.16e\n", accsum.DotK(x, x, 2))109	fmt.Println("Square triangle:       ", n*(n+1)*(2*n+1)/6)110	// Output:111	// Simple:    1.0000000000026734e+22112	// DotK(K=3): 1.0000000000026902e+22113	// Square triangle:        26901858961114}115func ExampleDownSum() {116	n := 12345117	p := make([]float64, n+1)118	for i := range p {119		p[i] = float64(i)120	}121	p[0] = 1e19122	u := accsum.DownSum(p)123	fmt.Println("Triangle:               ", n*(n+1)/2)124	fmt.Printf("DownSum:    %.16e\n", u)125	fmt.Printf("Next above: %.16e\n\n", math.Nextafter(u, math.Inf(1)))126	n = 54321127	p = make([]float64, n+1)128	for i := range p {129		p[i] = float64(i)130	}131	p[0] = 1e20132	u = accsum.DownSum(p)133	fmt.Println("Triangle:              ", n*(n+1)/2)134	fmt.Printf("DownSum:    %.16e\n", u)135	fmt.Printf("Next above: %.16e\n", math.Nextafter(u, math.Inf(1)))136	// Output:137	// Triangle:                76205685138	// DownSum:    1.0000000000076204e+19139	// Next above: 1.0000000000076206e+19140	//141	// Triangle:               1475412681142	// DownSum:    1.0000000000147541e+20143	// Next above: 1.0000000000147543e+20144}145func ExampleFastTwoSum() {146	a, b := .2, .1147	x, y := accsum.FastTwoSum(a, b)148	fmt.Printf("a: % .20f\n", a)149	fmt.Printf("b: % .20f\n", b)150	fmt.Printf("x: % .20f\n", x)151	fmt.Printf("y: % .20f\n", y)152	// Output:153	// a:  0.20000000000000001110154	// b:  0.10000000000000000555155	// x:  0.30000000000000004441156	// y: -0.00000000000000002776157}158func ExampleGenDot() {159	rand.Seed(42)160	x, y, d, c := accsum.GenDot(6, 1e31)161	fmt.Println("+x          y")162	for i, xi := range x {163		fmt.Printf("%+.2e  %+.2e\n", xi, y[i])164	}165	fmt.Println()166	fmt.Printf("condition:  %.2e\n", c)167	fmt.Printf("dot exact: % .6f\n", d)168	fmt.Printf("Dot2(x,y): % .6f\n", accsum.Dot2(x, y))169	fmt.Printf("Dot(x,y):  % .2e\n", accsum.Dot(x, y))170	// Output:171	// +x          y172	// -3.91e+15  +9.38e+14173	// -5.20e+14  -7.04e+15174	// -5.64e-01  +5.61e+07175	// -3.05e+05  -4.78e+05176	// -2.34e-01  +6.26e-01177	// +1.96e+07  +4.90e+07178	//179	// condition:  5.30e+31180	// dot exact: -0.276634181	// Dot2(x,y): -0.250000182	// Dot(x,y):   3.99e+14183}184func ExampleNearSum() {185	n := 12345186	p := make([]float64, n+1)187	for i := range p {188		p[i] = float64(i)189	}190	p[0] = 1e19191	u := accsum.NearSum(p)192	fmt.Println("Triangle:               ", n*(n+1)/2)193	fmt.Printf("NearSum:    %.16e\n\n", u)194	n = 54321195	p = make([]float64, n+1)196	for i := range p {197		p[i] = float64(i)198	}199	p[0] = 1e20200	u = accsum.NearSum(p)201	fmt.Println("Triangle:              ", n*(n+1)/2)202	fmt.Printf("NearSum:    %.16e\n", u)203	// Output:204	// Triangle:                76205685205	// NearSum:    1.0000000000076206e+19206	//207	// Triangle:               1475412681208	// NearSum:    1.0000000000147541e+20209}210func ExamplePrecSum() {211	n := 54321212	p := make([]float64, n+1)213	for i := range p {214		p[i] = float64(i)215	}216	p[0] = 1e20217	s := 0.218	for _, x := range p {219		s += x220	}221	fmt.Printf("Simple:   %.16e\n", s)222	fmt.Printf("PrecSum:  %.16e\n", accsum.PrecSum(p, 2))223	fmt.Println("Triangle:            ", n*(n+1)/2)224	// Output:225	// Simple:   1.0000000000146203e+20226	// PrecSum:  1.0000000000147541e+20227	// Triangle:             1475412681228}229func ExampleSum2() {230	n := 54321231	p := make([]float64, n+1)232	for i := range p {233		p[i] = float64(i)234	}235	p[0] = 1e20236	fmt.Printf("Simple:   %.16e\n", accsum.Sum(p))237	fmt.Printf("Sum2:     %.16e\n", accsum.Sum2(p))238	fmt.Println("Triangle:            ", n*(n+1)/2)239	// Output:240	// Simple:   1.0000000000146203e+20241	// Sum2:     1.0000000000147541e+20242	// Triangle:             1475412681243}244func ExampleSumK() {245	n := 54321246	p := make([]float64, n+1)247	for i := range p {248		p[i] = float64(i)249	}250	p[0] = 1e20251	fmt.Printf("Simple:   %.16e\n", accsum.Sum(p))252	fmt.Printf("SumK:     %.16e\n", accsum.SumK(p, 2))253	fmt.Println("Triangle:            ", n*(n+1)/2)254	// Output:255	// Simple:   1.0000000000146203e+20256	// SumK:     1.0000000000147541e+20257	// Triangle:             1475412681258}259func ExampleSumKVert() {260	n := 54321261	p := make([]float64, n+1)262	for i := range p {263		p[i] = float64(i)264	}265	p[0] = 1e20266	fmt.Printf("Simple:   %.16e\n", accsum.Sum(p))267	fmt.Printf("SumKVert: %.16e\n", accsum.SumKVert(p, 2))268	fmt.Println("Triangle:            ", n*(n+1)/2)269	// Output:270	// Simple:   1.0000000000146203e+20271	// SumKVert: 1.0000000000147541e+20272	// Triangle:             1475412681273}274func ExampleTwoProduct() {275	a := 1e10 + 1276	b := 1e6 + 1277	fmt.Println(accsum.TwoProduct(a, b))278	// Output: 1.0000010001e+16 1279}280func ExampleTwoSum() {281	a, b := .1, .2282	x, y := accsum.TwoSum(a, b)283	fmt.Printf("a: % .20f\n", a)284	fmt.Printf("b: % .20f\n", b)285	fmt.Printf("x: % .20f\n", x)286	fmt.Printf("y: % .20f\n", y)287	// Output:288	// a:  0.10000000000000000555289	// b:  0.20000000000000001110290	// x:  0.30000000000000004441291	// y: -0.00000000000000002776292}293func ExampleUpSum() {294	n := 12345295	p := make([]float64, n+1)296	for i := range p {297		p[i] = float64(i)298	}299	p[0] = 1e19300	u := accsum.UpSum(p)301	fmt.Println("Triangle:               ", n*(n+1)/2)302	fmt.Printf("UpSum:      %.16e\n", u)303	fmt.Printf("Next lower: %.16e\n\n", math.Nextafter(u, math.Inf(-1)))304	n = 54321305	p = make([]float64, n+1)306	for i := range p {307		p[i] = float64(i)308	}309	p[0] = 1e20310	u = accsum.UpSum(p)311	fmt.Println("Triangle:              ", n*(n+1)/2)312	fmt.Printf("UpSum:      %.16e\n", u)313	fmt.Printf("Next lower: %.16e\n", math.Nextafter(u, math.Inf(-1)))314	// Output:315	// Triangle:                76205685316	// UpSum:      1.0000000000076206e+19317	// Next lower: 1.0000000000076204e+19318	//319	// Triangle:               1475412681320	// UpSum:      1.0000000000147543e+20321	// Next lower: 1.0000000000147541e+20322}...

Full Screen

Full Screen

digest_test.go

Source:digest_test.go Github

copy

Full Screen

...27    </div>28  </body>29</html>30`31	expectedExampleSum   = `[DOCTYPE:html-][:html-[:head-[:title-][:meta-:charset][:meta-:content(text/html; charset=utf-8),:http-equiv(Content-type)][:meta-:content(width=device-width, initial-scale=1),:name(viewport)][:style-:type(text/css)]][:body-[:div-[:h1-][:p-][:p-[:a-:href(/path/to/link-to1)]][:p-[:a-:href(/path/to/link-to2)]]]]]`32	expectedExampleSum32 = 99307048133)34func getSumRawText(rootNode *html.Node) (string, error) {35	buf := &bytes.Buffer{}36	c := &ctx{37		writer:     buf,38		ignoreFunc: nopIgnoreFunc,39	}40	err := c.sum(rootNode)41	if err != nil {42		return "", nil43	}44	return buf.String(), nil45}46func getCrc32Sum(rootNode *html.Node) (uint32, error) {47	h := NewHash(func() hash.Hash {48		return crc32.NewIEEE()49	})50	crcSum, err := h.Sum(rootNode)51	if err != nil {52		return 0, err53	}54	crcSum32 := uint32(crcSum[0])<<24 | uint32(crcSum[1])<<16 | uint32(crcSum[2])<<8 | uint32(crcSum[3])55	return crcSum32, nil56}57func TestRawSum(t *testing.T) {58	t.Run("Simple", func(t *testing.T) {59		rootNode, err := html.Parse(strings.NewReader(exampleHTML))60		if err != nil {61			t.Fatal(err)62		}63		rawSum, err := getSumRawText(rootNode)64		if err != nil {65			t.Fatal(err)66		}67		if rawSum != expectedExampleSum {68			t.Errorf("Unexpected sum: %s", rawSum)69		}70	})71	t.Run("Modified", func(t *testing.T) {72		t.Run("NonBroken", func(t *testing.T) {73			r := strings.NewReplacer(`href=`, `HREF=`, `<h1>`, `<H1 title="hello">`)74			rootNode, err := html.Parse(strings.NewReader(r.Replace(exampleHTML)))75			if err != nil {76				t.Fatal(err)77			}78			rawSum, err := getSumRawText(rootNode)79			if err != nil {80				t.Fatal(err)81			}82			if rawSum != expectedExampleSum {83				t.Errorf("Unexpected sum: %s", rawSum)84			}85		})86		t.Run("Broken", func(t *testing.T) {87			r := strings.NewReplacer(`href="/path/to/link-to2"`, `HREF="/path/to/link-to3"`, `<h1>`, `<H2>`)88			rootNode, err := html.Parse(strings.NewReader(r.Replace(exampleHTML)))89			if err != nil {90				t.Fatal(err)91			}92			rawSum, err := getSumRawText(rootNode)93			if err != nil {94				t.Fatal(err)95			}96			if rawSum == expectedExampleSum {97				t.Errorf("Unexpected sum: %s", rawSum)98			}99			t.Logf("raw: %s", rawSum)100		})101	})102}103func TestDigest(t *testing.T) {104	t.Run("Reverse", func(t *testing.T) {105		rootNode, err := html.Parse(strings.NewReader(exampleHTML))106		if err != nil {107			t.Fatal(err)108		}109		rawSum, err := getSumRawText(rootNode)110		if err != nil {111			t.Fatal(err)112		}113		crcSum32, err := getCrc32Sum(rootNode)114		if err != nil {115			t.Fatal(err)116		}117		if recalced := crc32.ChecksumIEEE([]byte(rawSum)); crcSum32 != recalced {118			t.Errorf("Unexpected sum: %d, expected: %d", crcSum32, recalced)119		}120	})121	t.Run("Simple", func(t *testing.T) {122		rootNode, err := html.Parse(strings.NewReader(exampleHTML))123		if err != nil {124			t.Fatal(err)125		}126		crcSum32, err := getCrc32Sum(rootNode)127		if err != nil {128			t.Fatal(err)129		}130		if crcSum32 != expectedExampleSum32 {131			t.Errorf("Unexpected sum: %d", crcSum32)132		}133	})134	t.Run("Modified", func(t *testing.T) {135		t.Run("NonBroken", func(t *testing.T) {136			r := strings.NewReplacer(`href=`, `HREF=`, `<h1>`, `<H1 title="hello">`)137			rootNode, err := html.Parse(strings.NewReader(r.Replace(exampleHTML)))138			if err != nil {139				t.Fatal(err)140			}141			crcSum32, err := getCrc32Sum(rootNode)142			if err != nil {143				t.Fatal(err)144			}145			if crcSum32 != expectedExampleSum32 {146				t.Errorf("Unexpected sum: %d", crcSum32)147			}148		})149		t.Run("Broken", func(t *testing.T) {150			r := strings.NewReplacer(`href="/path/to/link-to2"`, `HREF="/path/to/link-to3"`, `<h1>`, `<H2>`)151			rootNode, err := html.Parse(strings.NewReader(r.Replace(exampleHTML)))152			if err != nil {153				t.Fatal(err)154			}155			crcSum32, err := getCrc32Sum(rootNode)156			if err != nil {157				t.Fatal(err)158			}159			if crcSum32 == expectedExampleSum32 {160				t.Errorf("Unexpected sum: %d", crcSum32)161			}162			t.Logf("crc32: %d", crcSum32)163		})164	})165}...

Full Screen

Full Screen

examples_test.go

Source:examples_test.go Github

copy

Full Screen

...15	"fmt"16	"os"17	"os/exec"18)19func ExampleWhatIsAGeneric_SumInt() {20	fmt.Println(SumInt(1, 2, 3))21	// Output: 622}23func ExampleWhatIsAGeneric_EmptyInterface() {24	print := func(i interface{}, err error) {25		if err != nil {26			fmt.Println(err)27		} else {28			fmt.Println(i)29		}30	}31	print(SumInterface(int64(1), int64(2), int64(3)))32	print(SumInterface(uint32(1), int(2), uint32(3)))33	print(SumInterface(float64(1), int(2), uint32(3)))34	print(SumInterface(uint32(1), uint32(2), uint32(3)))35	// Output:36	// 637	// int is not supported38	// float64 is not supported39	// 640}41func ExampleWhatIsAGeneric_MultipleFunctions() {42	fmt.Println(SumInt64(1, 2, 3))43	fmt.Println(SumUint32(1, 2, 3))44	// Output:45	// 646	// 647}48func ExampleSyntax() {49	fmt.Println(SumTint(1, 2, 3))50	// Output: 651}52func ExampleConstraints() {53	fmt.Println(SumTintOrint64(1, 2, 3))54	fmt.Println(SumTintOrint64(int64(1), 2, 3))55	// Output:56	// 657	// 658}59func ExampleTheAnyConstraint() {60	cmd := exec.Command(61		"go",62		"build",63		/*64			The `go build` command below uses the flag `-tags invalid`. This65			flag instructs Go to include the file66			`./examples/04-the-any-constraint/main.go` in the compilation.67			Normally the file has a build constraint that prevents it from being68			considered to prevent:69			  * Dev tools (ex. an IDE such as VS Code) from constantly warning70			    this file is in error71			  * a failed `go test ./...` command from the root of this72			    repository73			However, the entire point of this example is to demonstrate that74			failure, so the file needs to be "activated."75		*/76		"-tags", "invalid",77		"./examples/04-the-any-constraint/",78	)79	cmd.Stdout = os.Stdout80	cmd.Stderr = os.Stdout81	fmt.Println(cmd.Run())82	// Output:83	// # go-generics-the-hard-way/03-getting-started/examples/04-the-any-constraint84	// examples/04-the-any-constraint/main.go:30:3: invalid operation: operator + not defined on sum (variable of type T constrained by any)85	// exit status 286}87// SumInt returns the sum of the provided arguments.88func SumInt(args ...int) int {89	var sum int90	for i := 0; i < len(args); i++ {91		sum += args[i]92	}93	return sum94}95// SumInterface returns the sum of the provided arguments.96//97// An error is returned if the arguments are not of a supported98// type or of mixed types.99func SumInterface(args ...interface{}) (interface{}, error) {100	var sum interface{}101	for i := 0; i < len(args); i++ {102		switch a := args[i].(type) {103		case int64:104			if sum == nil {105				sum = int64(0)106			}107			tsum, ok := sum.(int64)108			if !ok {109				return nil, fmt.Errorf("previous arg was not an int64")110			}111			tsum += a112			sum = tsum113		case uint32:114			if sum == nil {115				sum = uint32(0)116			}117			tsum, ok := sum.(uint32)118			if !ok {119				return nil, fmt.Errorf("previous arg was not an uint32")120			}121			tsum += a122			sum = tsum123		default:124			return nil, fmt.Errorf("%T is not supported", args[i])125		}126	}127	return sum, nil128}129// SumInt64 returns the sum of the provided int64 values.130func SumInt64(args ...int64) int64 {131	var sum int64132	for i := 0; i < len(args); i++ {133		sum += args[i]134	}135	return sum136}137// SumUint32 returns the sum of the provided uint32 values.138func SumUint32(args ...uint32) uint32 {139	var sum uint32140	for i := 0; i < len(args); i++ {141		sum += args[i]142	}143	return sum144}145// SumTint returns the sum of the provided arguments.146func SumTint[T int](args ...T) T {147	var sum T148	for i := 0; i < len(args); i++ {149		sum += args[i]150	}151	return sum152}153// SumTintOrint64 returns the sum of the provided arguments.154func SumTintOrint64[T int | int64](args ...T) T {155	var sum T156	for i := 0; i < len(args); i++ {157		sum += args[i]158	}159	return sum160}...

Full Screen

Full Screen

Sum

Using AI Code Generation

copy

Full Screen

1import "fmt"2type Example struct {3}4func (e *Example) Sum() int {5}6func main() {7	e := Example{10, 20}8	fmt.Println(e.Sum())9}

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Got automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

Most used method in

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful