test/fibo.go - go - Git at Google

 // 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)
 		}
 	}
 }
	// 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)
	}
	}
	}