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