How to use Sum method of example Package

...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}...

...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}...

...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}...

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}