func (me *StatisticalAccumulator) PutInt64(x int64) { xx := new(big.Rat) xx.SetInt64(x) me.PutRat(xx) }
func String(v xdr.Int64) string { var f, o, r big.Rat f.SetInt64(int64(v)) o.SetInt64(One) r.Quo(&f, &o) return r.FloatString(7) }
func b(n int) *big.Rat { var f big.Rat a := make([]big.Rat, n+1) for m := range a { a[m].SetFrac64(1, int64(m+1)) for j := m; j >= 1; j-- { d := &a[j-1] d.Mul(f.SetInt64(int64(j)), d.Sub(d, &a[j])) } } return f.Set(&a[0]) }
func (l *Ledger) ToString() string { balance := make(map[string]*big.Rat) for _, t := range l.Transactions { err := t.CheckBalance() check(err) for _, a := range t.Accounts { if b, ok := balance[a.Name]; ok { if a.Debit { b.Add(b, a.Amount) } else { b.Sub(b, a.Amount) } } else { if a.Debit { balance[a.Name] = a.Amount } else { neg := new(big.Rat) neg.SetInt64(-1) balance[a.Name] = a.Amount.Mul(a.Amount, neg) } } } } keys := make([]string, len(balance)) i := 0 for k := range balance { keys[i] = k i++ } sort.Strings(keys) padLength := 20 for _, key := range keys { if len(key) > padLength { padLength = len(key) + 2 } } boom := "" for _, key := range keys { extra := "" if balance[key].Sign() == 1 { extra = "+" } boom += fmt.Sprintf("%s%s%s\n", padRight(key, " ", padLength), extra, balance[key].FloatString(2)) } return boom }
func mandelbrotRat(a, b *big.Rat) color.Color { var x, y, nx, ny, x2, y2, f2, f4, r2, tmp big.Rat f2.SetInt64(2) f4.SetInt64(4) x.SetInt64(0) y.SetInt64(0) defer func() { recover() }() for n := uint8(0); n < iterations; n++ { // Not update x2 and y2 // because they are already updated in the previous loop nx.Sub(&x2, &y2) nx.Add(&nx, a) tmp.Mul(&x, &y) ny.Mul(&f2, &tmp) ny.Add(&ny, b) x.Set(&nx) y.Set(&ny) x2.Mul(&x, &x) y2.Mul(&y, &y) r2.Add(&x2, &y2) if r2.Cmp(&f4) > 0 { return color.Gray{255 - contrast*n} } } return color.Black }
func main() { ln2, _ := new(big.Rat).SetString("0.6931471805599453094172") h := big.NewRat(1, 2) h.Quo(h, ln2) var f big.Rat var w big.Int for i := int64(1); i <= 17; i++ { h.Quo(h.Mul(h, f.SetInt64(i)), ln2) w.Quo(h.Num(), h.Denom()) f.Sub(h, f.SetInt(&w)) y, _ := f.Float64() d := fmt.Sprintf("%.3f", y) fmt.Printf("n: %2d h: %18d%s Nearly integer: %t\n", i, &w, d[1:], d[2] == '0' || d[2] == '9') } }
func TestIssue35(t *testing.T) { var bigInt big.Int var bigRat big.Rat bigInt.SetInt64(42) bigRat.SetInt64(24) db, err := OpenMem() if err != nil { t.Fatal(err) } ctx := NewRWCtx() _, _, err = db.Run(ctx, ` BEGIN TRANSACTION; CREATE TABLE t (i bigint, r bigrat); INSERT INTO t VALUES ($1, $2); COMMIT; `, bigInt, bigRat) if err != nil { t.Fatal(err) } bigInt.SetInt64(420) bigRat.SetInt64(240) rs, _, err := db.Run(nil, "SELECT * FROM t;") if err != nil { t.Fatal(err) } n := 0 if err := rs[0].Do(false, func(rec []interface{}) (bool, error) { switch n { case 0: n++ if g, e := fmt.Sprint(rec), "[42 24/1]"; g != e { t.Fatal(g, e) } return true, nil default: t.Fatal(n) panic("unreachable") } }); err != nil { t.Fatal(err) } }
func Parse(v string) (xdr.Int64, error) { var f, o, r big.Rat _, ok := f.SetString(v) if !ok { return xdr.Int64(0), fmt.Errorf("cannot parse amount: %s", v) } o.SetInt64(One) r.Mul(&f, &o) is := r.FloatString(0) i, err := strconv.ParseInt(is, 10, 64) if err != nil { return xdr.Int64(0), err } return xdr.Int64(i), nil }
// Use the classic continued fraction for e // e = [1; 0, 1, 1, 2, 1, 1, ... 2n, 1, 1, ...] // i.e., for the nth term, use // 1 if n mod 3 != 1 // (n-1)/3 * 2 if n mod 3 == 1 func recur(n, lim int64) *big.Rat { term := new(big.Rat) if n%3 != 1 { term.SetInt64(1) } else { term.SetInt64((n - 1) / 3 * 2) } if n > lim { return term } // Directly initialize frac as the fractional // inverse of the result of recur. frac := new(big.Rat).Inv(recur(n+1, lim)) return term.Add(term, frac) }
func New() *StatisticalAccumulator { n := new(big.Rat) n.SetInt64(0) sigmaXI := new(big.Rat) sigmaXI.SetInt64(0) sigmaXISquared := new(big.Rat) sigmaXISquared.SetInt64(0) one := new(big.Rat) one.SetInt64(1) me := StatisticalAccumulator{ n: n, sigmaXI: sigmaXI, sigmaXISquared: sigmaXISquared, one: one, } return &me }
func IntToRat(v int64) *big.Rat { rat := new(big.Rat) rat.SetInt64(v) return rat }
func renderRat(img *image.RGBA) { var yminR, ymaxMinR, heightR big.Rat yminR.SetInt64(ymin) ymaxMinR.SetInt64(ymax - ymin) heightR.SetInt64(height) var xminR, xmaxMinR, widthR big.Rat xminR.SetInt64(xmin) xmaxMinR.SetInt64(xmax - xmin) widthR.SetInt64(width) var y, x big.Rat for py := int64(0); py < height; py++ { // y := float64(py)/height*(ymax-ymin) + ymin y.SetInt64(py) y.Quo(&y, &heightR) y.Mul(&y, &ymaxMinR) y.Add(&y, &yminR) for px := int64(0); px < width; px++ { // x := float64(px)/width*(xmax-xmin) + xmin x.SetInt64(px) x.Quo(&x, &widthR) x.Mul(&x, &xmaxMinR) x.Add(&x, &xminR) c := mandelbrotRat(&x, &y) if c == nil { c = color.Black } img.Set(int(px), int(py), c) } } }