diff options
Diffstat (limited to '')
| -rw-r--r-- | test/fibo.go | 310 |
1 files changed, 310 insertions, 0 deletions
diff --git a/test/fibo.go b/test/fibo.go new file mode 100644 index 0000000..3b816d9 --- /dev/null +++ b/test/fibo.go @@ -0,0 +1,310 @@ +// skip + +// Copyright 2014 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Usage: +// fibo <n> compute fibonacci(n), n must be >= 0 +// fibo -bench benchmark fibonacci computation (takes about 1 min) +// +// Additional flags: +// -half add values using two half-digit additions +// -opt optimize memory allocation through reuse +// -short only print the first 10 digits of very large fibonacci numbers + +// Command fibo is a stand-alone test and benchmark to +// evaluate the performance of bignum arithmetic written +// entirely in Go. +package main + +import ( + "flag" + "fmt" + "math/big" // only used for printing + "os" + "strconv" + "testing" + "text/tabwriter" + "time" +) + +var ( + bench = flag.Bool("bench", false, "run benchmarks") + half = flag.Bool("half", false, "use half-digit addition") + opt = flag.Bool("opt", false, "optimize memory usage") + short = flag.Bool("short", false, "only print first 10 digits of result") +) + +// A large natural number is represented by a nat, each "digit" is +// a big.Word; the value zero corresponds to the empty nat slice. +type nat []big.Word + +const W = 1 << (5 + ^big.Word(0)>>63) // big.Word size in bits + +// The following methods are extracted from math/big to make this a +// stand-alone program that can easily be run without dependencies +// and compiled with different compilers. + +func (z nat) make(n int) nat { + if n <= cap(z) { + return z[:n] // reuse z + } + // Choosing a good value for e has significant performance impact + // because it increases the chance that a value can be reused. + const e = 4 // extra capacity + return make(nat, n, n+e) +} + +// z = x +func (z nat) set(x nat) nat { + z = z.make(len(x)) + copy(z, x) + return z +} + +// z = x + y +// (like add, but operating on half-digits at a time) +func (z nat) halfAdd(x, y nat) nat { + m := len(x) + n := len(y) + + switch { + case m < n: + return z.add(y, x) + case m == 0: + // n == 0 because m >= n; result is 0 + return z.make(0) + case n == 0: + // result is x + return z.set(x) + } + // m >= n > 0 + + const W2 = W / 2 // half-digit size in bits + const M2 = (1 << W2) - 1 // lower half-digit mask + + z = z.make(m + 1) + var c big.Word + for i := 0; i < n; i++ { + // lower half-digit + c += x[i]&M2 + y[i]&M2 + d := c & M2 + c >>= W2 + // upper half-digit + c += x[i]>>W2 + y[i]>>W2 + z[i] = c<<W2 | d + c >>= W2 + } + for i := n; i < m; i++ { + // lower half-digit + c += x[i] & M2 + d := c & M2 + c >>= W2 + // upper half-digit + c += x[i] >> W2 + z[i] = c<<W2 | d + c >>= W2 + } + if c != 0 { + z[m] = c + m++ + } + return z[:m] +} + +// z = x + y +func (z nat) add(x, y nat) nat { + m := len(x) + n := len(y) + + switch { + case m < n: + return z.add(y, x) + case m == 0: + // n == 0 because m >= n; result is 0 + return z.make(0) + case n == 0: + // result is x + return z.set(x) + } + // m >= n > 0 + + z = z.make(m + 1) + var c big.Word + + for i, xi := range x[:n] { + yi := y[i] + zi := xi + yi + c + z[i] = zi + // see "Hacker's Delight", section 2-12 (overflow detection) + c = ((xi & yi) | ((xi | yi) &^ zi)) >> (W - 1) + } + for i, xi := range x[n:] { + zi := xi + c + z[n+i] = zi + c = (xi &^ zi) >> (W - 1) + if c == 0 { + copy(z[n+i+1:], x[i+1:]) + break + } + } + if c != 0 { + z[m] = c + m++ + } + return z[:m] +} + +func bitlen(x big.Word) int { + n := 0 + for x > 0 { + x >>= 1 + n++ + } + return n +} + +func (x nat) bitlen() int { + if i := len(x); i > 0 { + return (i-1)*W + bitlen(x[i-1]) + } + return 0 +} + +func (x nat) String() string { + const shortLen = 10 + s := new(big.Int).SetBits(x).String() + if *short && len(s) > shortLen { + s = s[:shortLen] + "..." + } + return s +} + +func fibo(n int, half, opt bool) nat { + switch n { + case 0: + return nil + case 1: + return nat{1} + } + f0 := nat(nil) + f1 := nat{1} + if half { + if opt { + var f2 nat // reuse f2 + for i := 1; i < n; i++ { + f2 = f2.halfAdd(f1, f0) + f0, f1, f2 = f1, f2, f0 + } + } else { + for i := 1; i < n; i++ { + f2 := nat(nil).halfAdd(f1, f0) // allocate a new f2 each time + f0, f1 = f1, f2 + } + } + } else { + if opt { + var f2 nat // reuse f2 + for i := 1; i < n; i++ { + f2 = f2.add(f1, f0) + f0, f1, f2 = f1, f2, f0 + } + } else { + for i := 1; i < n; i++ { + f2 := nat(nil).add(f1, f0) // allocate a new f2 each time + f0, f1 = f1, f2 + } + } + } + return f1 // was f2 before shuffle +} + +var tests = []struct { + n int + want string +}{ + {0, "0"}, + {1, "1"}, + {2, "1"}, + {3, "2"}, + {4, "3"}, + {5, "5"}, + {6, "8"}, + {7, "13"}, + {8, "21"}, + {9, "34"}, + {10, "55"}, + {100, "354224848179261915075"}, + {1000, "43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875"}, +} + +func test(half, opt bool) { + for _, test := range tests { + got := fibo(test.n, half, opt).String() + if got != test.want { + fmt.Printf("error: got std fibo(%d) = %s; want %s\n", test.n, got, test.want) + os.Exit(1) + } + } +} + +func selfTest() { + if W != 32 && W != 64 { + fmt.Printf("error: unexpected wordsize %d", W) + os.Exit(1) + } + for i := 0; i < 4; i++ { + test(i&2 == 0, i&1 != 0) + } +} + +func doFibo(n int) { + start := time.Now() + f := fibo(n, *half, *opt) + t := time.Since(start) + fmt.Printf("fibo(%d) = %s (%d bits, %s)\n", n, f, f.bitlen(), t) +} + +func benchFibo(b *testing.B, n int, half, opt bool) { + for i := 0; i < b.N; i++ { + fibo(n, half, opt) + } +} + +func doBench(half, opt bool) { + w := tabwriter.NewWriter(os.Stdout, 0, 8, 2, ' ', tabwriter.AlignRight) + fmt.Fprintf(w, "wordsize = %d, half = %v, opt = %v\n", W, half, opt) + fmt.Fprintf(w, "n\talloc count\talloc bytes\tns/op\ttime/op\t\n") + for n := 1; n <= 1e6; n *= 10 { + res := testing.Benchmark(func(b *testing.B) { benchFibo(b, n, half, opt) }) + fmt.Fprintf(w, "%d\t%d\t%d\t%d\t%s\t\n", n, res.AllocsPerOp(), res.AllocedBytesPerOp(), res.NsPerOp(), time.Duration(res.NsPerOp())) + } + fmt.Fprintln(w) + w.Flush() +} + +func main() { + selfTest() + flag.Parse() + + if args := flag.Args(); len(args) > 0 { + // command-line use + fmt.Printf("half = %v, opt = %v, wordsize = %d bits\n", *half, *opt, W) + for _, arg := range args { + n, err := strconv.Atoi(arg) + if err != nil || n < 0 { + fmt.Println("invalid argument", arg) + continue + } + doFibo(n) + } + return + } + + if *bench { + for i := 0; i < 4; i++ { + doBench(i&2 == 0, i&1 != 0) + } + } +} |