qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-24 15:20:03 -07:00
Code Releases Activity

strconv: add AtofN, FtoaN

Browse Source 
R=r
CC=golang-dev
https://golang.org/cl/1700043
This commit is contained in:
Russ Cox 2010-06-18 22:43:37 -07:00
parent 34cc011276
commit 2d3e47ca10
4 changed files with 47 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/pkg/strconv/atof.go
View File

@ -367,3 +367,16 @@ func Atof(s string) (f float, err os.Error) {
f1, err1 := Atof64(s)
return float(f1), err1
}
// AtofN converts the string s to a 64-bit floating-point number,
// but it rounds the result assuming that it will be stored in a value
// of n bits (32 or 64).
func AtofN(s string, n int) (f float64, err os.Error) {
if n == 32 {
f1, err1 := Atof32(s)
return float64(f1), err1
}
f1, err1 := Atof64(s)
return f1, err1
}

15
src/pkg/strconv/atof_test.go
View File

@ -114,6 +114,13 @@ func testAtof(t *testing.T, opt bool) {
test.in, out, err, test.out, test.err)
}
out, err = AtofN(test.in, 64)
outs = FtoaN(out, 'g', -1, 64)
if outs != test.out || !reflect.DeepEqual(err, test.err) {
t.Errorf("AtofN(%v, 64) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err)
}
if float64(float32(out)) == out {
out32, err := Atof32(test.in)
outs := Ftoa32(out32, 'g', -1)
@ -121,6 +128,14 @@ func testAtof(t *testing.T, opt bool) {
t.Errorf("Atof32(%v) = %v, %v want %v, %v # %v\n",
test.in, out32, err, test.out, test.err, out)
}
out, err := AtofN(test.in, 32)
out32 = float32(out)
outs = FtoaN(float64(out32), 'g', -1, 32)
if outs != test.out || !reflect.DeepEqual(err, test.err) {
t.Errorf("AtofN(%v, 32) = %v, %v want %v, %v # %v\n",
test.in, out32, err, test.out, test.err, out)
}
}
if FloatSize == 64 || float64(float32(out)) == out {

11
src/pkg/strconv/ftoa.go
View File

@ -64,6 +64,17 @@ func Ftoa64(f float64, fmt byte, prec int) string {
return genericFtoa(math.Float64bits(f), fmt, prec, &float64info)
}
// FtoaN converts the 64-bit floating-point number f to a string,
// according to the format fmt and precision prec, but it rounds the
// result assuming that it was obtained from a floating-point value
// of n bits (32 or 64).
func FtoaN(f float64, fmt byte, prec int, n int) string {
if n == 32 {
return Ftoa32(float32(f), fmt, prec)
}
return Ftoa64(f, fmt, prec)
}
// Ftoa behaves as Ftoa32 or Ftoa64, depending on the size of the float type.
func Ftoa(f float, fmt byte, prec int) string {
if FloatSize == 32 {

8
src/pkg/strconv/ftoa_test.go
View File

@ -110,11 +110,19 @@ func TestFtoa(t *testing.T) {
if s != test.s {
t.Error("test", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
}
s = FtoaN(test.f, test.fmt, test.prec, 64)
if s != test.s {
t.Error("testN=64", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
}
if float64(float32(test.f)) == test.f && test.fmt != 'b' {
s := Ftoa32(float32(test.f), test.fmt, test.prec)
if s != test.s {
t.Error("test32", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
}
s = FtoaN(test.f, test.fmt, test.prec, 32)
if s != test.s {
t.Error("testN=32", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
}
}
}
}