qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-09-30 14:18:32 -06:00
Code Releases Activity

math/big: rename (*Float).Format to (*Float).Text

Browse Source 
This paves the way for a fmt-compatible (*Float).Format method.
A better name then Text is still desirable (suggestions welcome).

This is partly fixing issue #10938.

Change-Id: I59c20a8cee11f5dba059fe0f38b414fe75f2ab13
Reviewed-on: https://go-review.googlesource.com/10493
Reviewed-by: Alan Donovan <adonovan@google.com>
This commit is contained in:
Robert Griesemer 2015-05-28 15:25:06 -07:00
parent c413c45e6d
commit 9b3d9230aa
6 changed files with 40 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/math/big/bits_test.go
View File

@ -217,7 +217,7 @@ func TestFromBits(t *testing.T) {
{append(Bits{2, 1, 0} /* 7 */, Bits{3, 1} /* 10 */ ...), "0x.88p+5" /* 17 */}, {append(Bits{2, 1, 0} /* 7 */, Bits{3, 1} /* 10 */ ...), "0x.88p+5" /* 17 */},
} { } {
f := test.bits.Float() f := test.bits.Float()
if got := f.Format('p', 0); got != test.want { if got := f.Text('p', 0); got != test.want {
t.Errorf("setBits(%v) = %s; want %s", test.bits, got, test.want) t.Errorf("setBits(%v) = %s; want %s", test.bits, got, test.want)
} }
} }

2
src/math/big/float.go
View File

@ -363,7 +363,7 @@ func (x *Float) validate() {
} }
const msb = 1 << (_W - 1) const msb = 1 << (_W - 1)
if x.mant[m-1]&msb == 0 { if x.mant[m-1]&msb == 0 {
panic(fmt.Sprintf("msb not set in last word %#x of %s", x.mant[m-1], x.Format('p', 0))) panic(fmt.Sprintf("msb not set in last word %#x of %s", x.mant[m-1], x.Text('p', 0)))
} }
if x.prec == 0 { if x.prec == 0 {
panic("zero precision finite number") panic("zero precision finite number")

50
src/math/big/float_test.go
View File

@ -18,7 +18,7 @@ var _ error = ErrNaN{}
func (x *Float) uint64() uint64 { func (x *Float) uint64() uint64 {
u, acc := x.Uint64() u, acc := x.Uint64()
if acc != Exact { if acc != Exact {
panic(fmt.Sprintf("%s is not a uint64", x.Format('g', 10))) panic(fmt.Sprintf("%s is not a uint64", x.Text('g', 10)))
} }
return u return u
} }
@ -26,7 +26,7 @@ func (x *Float) uint64() uint64 {
func (x *Float) int64() int64 { func (x *Float) int64() int64 {
i, acc := x.Int64() i, acc := x.Int64()
if acc != Exact { if acc != Exact {
panic(fmt.Sprintf("%s is not an int64", x.Format('g', 10))) panic(fmt.Sprintf("%s is not an int64", x.Text('g', 10)))
} }
return i return i
} }
@ -34,7 +34,7 @@ func (x *Float) int64() int64 {
func TestFloatZeroValue(t *testing.T) { func TestFloatZeroValue(t *testing.T) {
// zero (uninitialized) value is a ready-to-use 0.0 // zero (uninitialized) value is a ready-to-use 0.0
var x Float var x Float
if s := x.Format('f', 1); s != "0.0" { if s := x.Text('f', 1); s != "0.0" {
t.Errorf("zero value = %s; want 0.0", s) t.Errorf("zero value = %s; want 0.0", s)
} }
@ -236,7 +236,7 @@ func TestFloatMantExp(t *testing.T) {
m := new(Float) m := new(Float)
e := x.MantExp(m) e := x.MantExp(m)
if !alike(m, mant) || e != test.exp { if !alike(m, mant) || e != test.exp {
t.Errorf("%s.MantExp() = %s, %d; want %s, %d", test.x, m.Format('g', 10), e, test.mant, test.exp) t.Errorf("%s.MantExp() = %s, %d; want %s, %d", test.x, m.Text('g', 10), e, test.mant, test.exp)
} }
} }
} }
@ -247,7 +247,7 @@ func TestFloatMantExpAliasing(t *testing.T) {
t.Fatalf("Float.MantExp aliasing error: got %d; want 10", e) t.Fatalf("Float.MantExp aliasing error: got %d; want 10", e)
} }
if want := makeFloat("0.5"); !alike(x, want) { if want := makeFloat("0.5"); !alike(x, want) {
t.Fatalf("Float.MantExp aliasing error: got %s; want %s", x.Format('g', 10), want.Format('g', 10)) t.Fatalf("Float.MantExp aliasing error: got %s; want %s", x.Text('g', 10), want.Text('g', 10))
} }
} }
@ -279,12 +279,12 @@ func TestFloatSetMantExp(t *testing.T) {
var z Float var z Float
z.SetMantExp(frac, test.exp) z.SetMantExp(frac, test.exp)
if !alike(&z, want) { if !alike(&z, want) {
t.Errorf("SetMantExp(%s, %d) = %s; want %s", test.frac, test.exp, z.Format('g', 10), test.z) t.Errorf("SetMantExp(%s, %d) = %s; want %s", test.frac, test.exp, z.Text('g', 10), test.z)
} }
// test inverse property // test inverse property
mant := new(Float) mant := new(Float)
if z.SetMantExp(mant, want.MantExp(mant)).Cmp(want) != 0 { if z.SetMantExp(mant, want.MantExp(mant)).Cmp(want) != 0 {
t.Errorf("Inverse property not satisfied: got %s; want %s", z.Format('g', 10), test.z) t.Errorf("Inverse property not satisfied: got %s; want %s", z.Text('g', 10), test.z)
} }
} }
} }
@ -562,7 +562,7 @@ func TestFloatSetUint64(t *testing.T) {
var f Float var f Float
f.SetUint64(want) f.SetUint64(want)
if got := f.uint64(); got != want { if got := f.uint64(); got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Format('p', 0), want) t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
} }
} }
@ -573,7 +573,7 @@ func TestFloatSetUint64(t *testing.T) {
got := f.uint64() got := f.uint64()
want := x &^ (1<<(64-prec) - 1) // cut off (round to zero) low 64-prec bits want := x &^ (1<<(64-prec) - 1) // cut off (round to zero) low 64-prec bits
if got != want { if got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Format('p', 0), want) t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
} }
} }
} }
@ -596,7 +596,7 @@ func TestFloatSetInt64(t *testing.T) {
var f Float var f Float
f.SetInt64(want) f.SetInt64(want)
if got := f.int64(); got != want { if got := f.int64(); got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Format('p', 0), want) t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
} }
} }
} }
@ -608,7 +608,7 @@ func TestFloatSetInt64(t *testing.T) {
got := f.int64() got := f.int64()
want := x &^ (1<<(63-prec) - 1) // cut off (round to zero) low 63-prec bits want := x &^ (1<<(63-prec) - 1) // cut off (round to zero) low 63-prec bits
if got != want { if got != want {
t.Errorf("got %#x (%s); want %#x", got, f.Format('p', 0), want) t.Errorf("got %#x (%s); want %#x", got, f.Text('p', 0), want)
} }
} }
} }
@ -639,7 +639,7 @@ func TestFloatSetFloat64(t *testing.T) {
var f Float var f Float
f.SetFloat64(want) f.SetFloat64(want)
if got, acc := f.Float64(); got != want || acc != Exact { if got, acc := f.Float64(); got != want || acc != Exact {
t.Errorf("got %g (%s, %s); want %g (Exact)", got, f.Format('p', 0), acc, want) t.Errorf("got %g (%s, %s); want %g (Exact)", got, f.Text('p', 0), acc, want)
} }
} }
} }
@ -651,7 +651,7 @@ func TestFloatSetFloat64(t *testing.T) {
got, _ := f.Float64() got, _ := f.Float64()
want := float64(x &^ (1<<(52-prec) - 1)) // cut off (round to zero) low 53-prec bits want := float64(x &^ (1<<(52-prec) - 1)) // cut off (round to zero) low 53-prec bits
if got != want { if got != want {
t.Errorf("got %g (%s); want %g", got, f.Format('p', 0), want) t.Errorf("got %g (%s); want %g", got, f.Text('p', 0), want)
} }
} }
@ -664,7 +664,7 @@ func TestFloatSetFloat64(t *testing.T) {
var f Float var f Float
f.SetFloat64(math.NaN()) f.SetFloat64(math.NaN())
// should not reach here // should not reach here
t.Errorf("got %s; want ErrNaN panic", f.Format('p', 0)) t.Errorf("got %s; want ErrNaN panic", f.Text('p', 0))
} }
func TestFloatSetInt(t *testing.T) { func TestFloatSetInt(t *testing.T) {
@ -696,9 +696,9 @@ func TestFloatSetInt(t *testing.T) {
} }
// check value // check value
got := f.Format('g', 100) got := f.Text('g', 100)
if got != want { if got != want {
t.Errorf("got %s (%s); want %s", got, f.Format('p', 0), want) t.Errorf("got %s (%s); want %s", got, f.Text('p', 0), want)
} }
} }
@ -738,9 +738,9 @@ func TestFloatSetRat(t *testing.T) {
t.Errorf("got prec = %d; want %d", prec, n) t.Errorf("got prec = %d; want %d", prec, n)
} }
got := f2.Format('g', 100) got := f2.Text('g', 100)
if got != want { if got != want {
t.Errorf("got %s (%s); want %s", got, f2.Format('p', 0), want) t.Errorf("got %s (%s); want %s", got, f2.Text('p', 0), want)
} }
} }
} }
@ -1096,13 +1096,13 @@ func TestFloatAbs(t *testing.T) {
p := makeFloat(test) p := makeFloat(test)
a := new(Float).Abs(p) a := new(Float).Abs(p)
if !alike(a, p) { if !alike(a, p) {
t.Errorf("%s: got %s; want %s", test, a.Format('g', 10), test) t.Errorf("%s: got %s; want %s", test, a.Text('g', 10), test)
} }
n := makeFloat("-" + test) n := makeFloat("-" + test)
a.Abs(n) a.Abs(n)
if !alike(a, p) { if !alike(a, p) {
t.Errorf("-%s: got %s; want %s", test, a.Format('g', 10), test) t.Errorf("-%s: got %s; want %s", test, a.Text('g', 10), test)
} }
} }
} }
@ -1122,10 +1122,10 @@ func TestFloatNeg(t *testing.T) {
n2 := new(Float).Neg(p1) n2 := new(Float).Neg(p1)
p2 := new(Float).Neg(n2) p2 := new(Float).Neg(n2)
if !alike(n2, n1) { if !alike(n2, n1) {
t.Errorf("%s: got %s; want %s", test, n2.Format('g', 10), n1.Format('g', 10)) t.Errorf("%s: got %s; want %s", test, n2.Text('g', 10), n1.Text('g', 10))
} }
if !alike(p2, p1) { if !alike(p2, p1) {
t.Errorf("%s: got %s; want %s", test, p2.Format('g', 10), p1.Format('g', 10)) t.Errorf("%s: got %s; want %s", test, p2.Text('g', 10), p1.Text('g', 10))
} }
} }
} }
@ -1467,7 +1467,7 @@ func TestFloatQuoSmoke(t *testing.T) {
cc, acc := C.Float64() cc, acc := C.Float64()
if cc != c { if cc != c {
t.Errorf("%g/%g = %s; want %.5g\n", a, b, C.Format('g', 5), c) t.Errorf("%g/%g = %s; want %.5g\n", a, b, C.Text('g', 5), c)
continue continue
} }
if acc != Exact { if acc != Exact {
@ -1608,10 +1608,10 @@ func TestFloatArithmeticOverflow(t *testing.T) {
default: default:
panic("unreachable") panic("unreachable")
} }
if got := z.Format('p', 0); got != test.want || z.Acc() != test.acc { if got := z.Text('p', 0); got != test.want || z.Acc() != test.acc {
t.Errorf( t.Errorf(
"prec = %d (%s): %s %c %s = %s (%s); want %s (%s)", "prec = %d (%s): %s %c %s = %s (%s); want %s (%s)",
test.prec, test.mode, x.Format('p', 0), test.op, y.Format('p', 0), got, z.Acc(), test.want, test.acc, test.prec, test.mode, x.Text('p', 0), test.op, y.Text('p', 0), got, z.Acc(), test.want, test.acc,
) )
} }
} }

8
src/math/big/floatconv_test.go
View File

@ -113,7 +113,7 @@ const (
above1e23 = 100000000000000008388608 above1e23 = 100000000000000008388608
) )
func TestFloat64Format(t *testing.T) { func TestFloat64Text(t *testing.T) {
for _, test := range []struct { for _, test := range []struct {
x float64 x float64
format byte format byte
@ -257,7 +257,7 @@ func TestFloat64Format(t *testing.T) {
// {383260575764816448, 'g', -1, "3.8326057576481645e+17"}, // {383260575764816448, 'g', -1, "3.8326057576481645e+17"},
} { } {
f := new(Float).SetFloat64(test.x) f := new(Float).SetFloat64(test.x)
got := f.Format(test.format, test.prec) got := f.Text(test.format, test.prec)
if got != test.want { if got != test.want {
t.Errorf("%v: got %s; want %s", test, got, test.want) t.Errorf("%v: got %s; want %s", test, got, test.want)
} }
@ -277,7 +277,7 @@ func TestFloat64Format(t *testing.T) {
} }
} }
func TestFloatFormat(t *testing.T) { func TestFloatText(t *testing.T) {
for _, test := range []struct { for _, test := range []struct {
x string x string
prec uint prec uint
@ -378,7 +378,7 @@ func TestFloatFormat(t *testing.T) {
continue continue
} }
got := f.Format(test.format, test.digits) got := f.Text(test.format, test.digits)
if got != test.want { if got != test.want {
t.Errorf("%v: got %s; want %s", test, got, test.want) t.Errorf("%v: got %s; want %s", test, got, test.want)
} }

6
src/math/big/floatexample_test.go
View File

@ -17,9 +17,9 @@ func ExampleFloat_Add() {
y.SetFloat64(2.718281828) // y is automatically set to 53bit precision y.SetFloat64(2.718281828) // y is automatically set to 53bit precision
z.SetPrec(32) z.SetPrec(32)
z.Add(&x, &y) 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("x = %s (%s, prec = %d, acc = %s)\n", &x, x.Text('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("y = %s (%s, prec = %d, acc = %s)\n", &y, y.Text('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()) fmt.Printf("z = %s (%s, prec = %d, acc = %s)\n", &z, z.Text('p', 0), z.Prec(), z.Acc())
// Output: // Output:
// x = 1000 (0x.fap+10, prec = 64, acc = Exact) // x = 1000 (0x.fap+10, prec = 64, acc = Exact)
// y = 2.718281828 (0x.adf85458248cd8p+2, prec = 53, acc = Exact) // y = 2.718281828 (0x.adf85458248cd8p+2, prec = 53, acc = Exact)

14
src/math/big/ftoa.go
View File

@ -13,8 +13,8 @@ import (
"strings" "strings"
) )
// Format converts the floating-point number x to a string according // Text converts the floating-point number x to a string according
// to the given format and precision prec. The format is one of: // to the given format and precision prec. The format must be one of:
// //
// 'e' -d.dddde±dd, decimal exponent, at least two (possibly 0) exponent digits // 'e' -d.dddde±dd, decimal exponent, at least two (possibly 0) exponent digits
// 'E' -d.ddddE±dd, decimal exponent, at least two (possibly 0) exponent digits // 'E' -d.ddddE±dd, decimal exponent, at least two (possibly 0) exponent digits
@ -37,20 +37,18 @@ import (
// The prec value is ignored for the 'b' or 'p' format. // The prec value is ignored for the 'b' or 'p' format.
// //
// BUG(gri) Float.Format does not accept negative precisions. // BUG(gri) Float.Format does not accept negative precisions.
// BUG(gri) The Float.Format signature conflicts with Format(f fmt.State, c rune). func (x *Float) Text(format byte, prec int) string {
// (https://github.com/golang/go/issues/10938)
func (x *Float) Format(format byte, prec int) string {
const extra = 10 // TODO(gri) determine a good/better value here const extra = 10 // TODO(gri) determine a good/better value here
return string(x.Append(make([]byte, 0, prec+extra), format, prec)) return string(x.Append(make([]byte, 0, prec+extra), format, prec))
} }
// String formats x like x.Format('g', 10). // String formats x like x.Text('g', 10).
func (x *Float) String() string { func (x *Float) String() string {
return x.Format('g', 10) return x.Text('g', 10)
} }
// Append appends to buf the string form of the floating-point number x, // Append appends to buf the string form of the floating-point number x,
// as generated by x.Format, and returns the extended buffer. // as generated by x.Text, and returns the extended buffer.
func (x *Float) Append(buf []byte, fmt byte, prec int) []byte { func (x *Float) Append(buf []byte, fmt byte, prec int) []byte {
// sign // sign
if x.neg { if x.neg {