func TestSqrt(t *testing.T) {
tests := []struct {
prec uint
in float64
}{
{16, 0},
{16, 1},
{16, 4},
{16, 10000},
{16, 2},
{64, 2},
{256, 2},
{1024, 1.5},
}
for _, test := range tests {
x := new(big.Float).SetPrec(test.prec)
x.SetFloat64(test.in)
var got, got2, diff big.Float
pslq := New(test.prec)
pslq.Sqrt(x, &got)
got2.SetPrec(test.prec).Mul(&got, &got)
diff.Sub(&got2, x)
if diff.MinPrec() > 1 {
t.Errorf("sqrt(%f) prec %d wrong got %.20f square %.20f expecting %f diff %g minprec %d", test.in, test.prec, &got, &got2, x, &diff, diff.MinPrec())
}
}
}
func (sed StringEncoderDecoder) Decode(r io.Reader, n *big.Float) error {
n.SetFloat64(0)
n.SetPrec(ENCODER_DECODER_PREC)
buf := make([]byte, 256)
if _, err := r.Read(buf); err != nil {
return err
}
_, _, err := n.Parse(string(buf), 10)
return err
}
func ExampleFloat_Add() {
// Operating on numbers of different precision.
var x, y, z big.Float
x.SetInt64(1000) // x is automatically set to 64bit precision
y.SetFloat64(2.718281828) // y is automatically set to 53bit precision
z.SetPrec(32)
z.Add(&x, &y)
fmt.Printf("x = %s (%s, prec = %d, acc = %s)\n", &x, x.Format('p', 0), x.Prec(), x.Acc())
fmt.Printf("y = %s (%s, prec = %d, acc = %s)\n", &y, y.Format('p', 0), y.Prec(), y.Acc())
fmt.Printf("z = %s (%s, prec = %d, acc = %s)\n", &z, z.Format('p', 0), z.Prec(), z.Acc())
// Output:
// x = 1000 (0x.fap10, prec = 64, acc = Exact)
// y = 2.718281828 (0x.adf85458248cd8p2, prec = 53, acc = Exact)
// z = 1002.718282 (0x.faadf854p10, prec = 32, acc = Below)
}
func (p *exporter) float(x constant.Value) {
if x.Kind() != constant.Float {
log.Fatalf("gcimporter: unexpected constant %v, want float", x)
}
// extract sign (there is no -0)
sign := constant.Sign(x)
if sign == 0 {
// x == 0
p.int(0)
return
}
// x != 0
var f big.Float
if v, exact := constant.Float64Val(x); exact {
// float64
f.SetFloat64(v)
} else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
// TODO(gri): add big.Rat accessor to constant.Value.
r := valueToRat(num)
f.SetRat(r.Quo(r, valueToRat(denom)))
} else {
// Value too large to represent as a fraction => inaccessible.
// TODO(gri): add big.Float accessor to constant.Value.
f.SetFloat64(math.MaxFloat64) // FIXME
}
// extract exponent such that 0.5 <= m < 1.0
var m big.Float
exp := f.MantExp(&m)
// extract mantissa as *big.Int
// - set exponent large enough so mant satisfies mant.IsInt()
// - get *big.Int from mant
m.SetMantExp(&m, int(m.MinPrec()))
mant, acc := m.Int(nil)
if acc != big.Exact {
log.Fatalf("gcimporter: internal error")
}
p.int(sign)
p.int(exp)
p.string(string(mant.Bytes()))
}
// Exp returns a big.Float representation of exp(z). Precision is
// the same as the one of the argument. The function returns +Inf
// when z = +Inf, and 0 when z = -Inf.
func Exp(z *big.Float) *big.Float {
// exp(0) == 1
if z.Sign() == 0 {
return big.NewFloat(1).SetPrec(z.Prec())
}
// Exp(+Inf) = +Inf
if z.IsInf() && z.Sign() > 0 {
return big.NewFloat(math.Inf(+1)).SetPrec(z.Prec())
}
// Exp(-Inf) = 0
if z.IsInf() && z.Sign() < 0 {
return big.NewFloat(0).SetPrec(z.Prec())
}
guess := new(big.Float)
// try to get initial estimate using IEEE-754 math
zf, _ := z.Float64()
if zfs := math.Exp(zf); zfs == math.Inf(+1) || zfs == 0 {
// too big or too small for IEEE-754 math,
// perform argument reduction using
// e^{2z} = (e^z)²
halfZ := new(big.Float).Mul(z, big.NewFloat(0.5))
halfExp := Exp(halfZ.SetPrec(z.Prec() + 64))
return new(big.Float).Mul(halfExp, halfExp).SetPrec(z.Prec())
} else {
// we got a nice IEEE-754 estimate
guess.SetFloat64(zfs)
}
// f(t)/f'(t) = t*(log(t) - z)
f := func(t *big.Float) *big.Float {
x := new(big.Float)
x.Sub(Log(t), z)
return x.Mul(x, t)
}
x := newton(f, guess, z.Prec())
return x
}
func main() {
i1, i2, i3 := 12, 45, 68
intSum := i1 + i2 + i3
fmt.Println("Integer Sum:", intSum)
f1, f2, f3 := 23.5, 65.1, 76.3
floatSum := f1 + f2 + f3
fmt.Println("Float Sum:", floatSum)
var b1, b2, b3, bigSum big.Float
b1.SetFloat64(23.5)
b2.SetFloat64(65.1)
b3.SetFloat64(76.3)
bigSum.Add(&b1, &b2).Add(&bigSum, &b3)
fmt.Printf("BigSum = %.10g\n", &bigSum)
circleRadius := 15.5
circumference := 2 * circleRadius * math.Pi
fmt.Printf("Circumference: %.2f\n", circumference)
}
