// float64
func (f *Fmt) Fmt_e64(a float64) *Fmt {
- return fmtString(f, strconv.ftoa64(a, 'e', Prec(f, 6)));
+ return fmtString(f, strconv.Ftoa64(a, 'e', Prec(f, 6)));
}
func (f *Fmt) Fmt_f64(a float64) *Fmt {
- return fmtString(f, strconv.ftoa64(a, 'f', Prec(f, 6)));
+ return fmtString(f, strconv.Ftoa64(a, 'f', Prec(f, 6)));
}
func (f *Fmt) Fmt_g64(a float64) *Fmt {
- return fmtString(f, strconv.ftoa64(a, 'g', Prec(f, -1)));
+ return fmtString(f, strconv.Ftoa64(a, 'g', Prec(f, -1)));
}
func (f *Fmt) Fmt_fb64(a float64) *Fmt {
- return fmtString(f, strconv.ftoa64(a, 'b', 0));
+ return fmtString(f, strconv.Ftoa64(a, 'b', 0));
}
// float32
// cannot defer to float64 versions
// because it will get rounding wrong in corner cases.
func (f *Fmt) Fmt_e32(a float32) *Fmt {
- return fmtString(f, strconv.ftoa32(a, 'e', Prec(f, 6)));
+ return fmtString(f, strconv.Ftoa32(a, 'e', Prec(f, 6)));
}
func (f *Fmt) Fmt_f32(a float32) *Fmt {
- return fmtString(f, strconv.ftoa32(a, 'f', Prec(f, 6)));
+ return fmtString(f, strconv.Ftoa32(a, 'f', Prec(f, 6)));
}
func (f *Fmt) Fmt_g32(a float32) *Fmt {
- return fmtString(f, strconv.ftoa32(a, 'g', Prec(f, -1)));
+ return fmtString(f, strconv.Ftoa32(a, 'g', Prec(f, -1)));
}
func (f *Fmt) Fmt_fb32(a float32) *Fmt {
- return fmtString(f, strconv.ftoa32(a, 'b', 0));
+ return fmtString(f, strconv.Ftoa32(a, 'b', 0));
}
// float
export func Serve(l net.Listener, f *(*Conn, *Request)) *os.Error {
// TODO: Make this unnecessary
s, e := os.Getenv("GOMAXPROCS");
- if n, ok := strconv.atoi(s); n < 3 {
+ if n, ok := strconv.Atoi(s); n < 3 {
print("Warning: $GOMAXPROCS needs to be at least 3.\n");
}
}
switch j.Kind() {
case ArrayKind:
- indx, err := strconv.atoi(elem);
+ indx, err := strconv.Atoi(elem);
if err != nil {
return null
}
break;
case '1':
// If the number is exactly an integer, use that.
- if i, err := strconv.atoi64(lex.token); err == nil {
+ if i, err := strconv.Atoi64(lex.token); err == nil {
build.Int64(i);
ok = true;
}
- else if i, err := strconv.atoui64(lex.token); err == nil {
+ else if i, err := strconv.Atoui64(lex.token); err == nil {
build.Uint64(i);
ok = true;
}
// Fall back to floating point.
- else if f, err := strconv.atof64(lex.token); err == nil {
+ else if f, err := strconv.Atof64(lex.token); err == nil {
build.Float64(f);
ok = true;
}
return "", e
}
host := IPToString(addr);
- return JoinHostPort(host, strconv.itoa(port)), nil;
+ return JoinHostPort(host, strconv.Itoa(port)), nil;
default:
return "", UnknownSocketFamily
}
if a.Open() {
str = "[]"
} else {
- str = "[" + strconv.itoa64(int64(a.Len())) + "]"
+ str = "[" + strconv.Itoa64(int64(a.Len())) + "]"
}
return str + TypeToString(a.Elem(), false);
case MapKind:
// TODO: want an unsigned one too
func integer(v int64) string {
- return strconv.itoa64(v);
+ return strconv.Itoa64(v);
}
func ValueToString(val Value) string {
return integer(int64(val.(Uint64Value).Get()));
case FloatKind:
if strconv.FloatSize == 32 {
- return strconv.ftoa32(float32(val.(FloatValue).Get()), 'g', -1);
+ return strconv.Ftoa32(float32(val.(FloatValue).Get()), 'g', -1);
} else {
- return strconv.ftoa64(float64(val.(FloatValue).Get()), 'g', -1);
+ return strconv.Ftoa64(float64(val.(FloatValue).Get()), 'g', -1);
}
case Float32Kind:
- return strconv.ftoa32(val.(Float32Value).Get(), 'g', -1);
+ return strconv.Ftoa32(val.(Float32Value).Get(), 'g', -1);
case Float64Kind:
- return strconv.ftoa64(val.(Float64Value).Get(), 'g', -1);
+ return strconv.Ftoa64(val.(Float64Value).Get(), 'g', -1);
case Float80Kind:
return "float80";
case StringKind:
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Decimal to binary floating point conversion.
+// decimal to binary floating point conversion.
// Algorithm:
// 1) Store input in multiprecision decimal.
// 2) Multiply/divide decimal by powers of two until in range [0.5, 1)
"strconv";
)
-package var optimize = true // can change for testing
+var optimize = true // can change for testing
// TODO(rsc): Better truncation handling.
-func StringToDecimal(s string) (neg bool, d *Decimal, trunc bool, ok bool) {
+func stringToDecimal(s string) (neg bool, d *decimal, trunc bool, ok bool) {
i := 0;
// optional sign
}
// digits
- b := new(Decimal);
+ b := new(decimal);
sawdot := false;
sawdigits := false;
for ; i < len(s); i++ {
return;
}
-// Decimal power of ten to binary power of two.
+// decimal power of ten to binary power of two.
var powtab = []int{
1, 3, 6, 9, 13, 16, 19, 23, 26
}
-func DecimalToFloatBits(neg bool, d *Decimal, trunc bool, flt *FloatInfo) (b uint64, overflow bool) {
+func decimalToFloatBits(neg bool, d *decimal, trunc bool, flt *floatInfo) (b uint64, overflow bool) {
var exp int;
var mant uint64;
// Compute exact floating-point integer from d's digits.
// Caller is responsible for avoiding overflow.
-func DecimalToFloat64Int(neg bool, d *Decimal) float64 {
+func decimalAtof64Int(neg bool, d *decimal) float64 {
f := float64(0);
for i := 0; i < d.nd; i++ {
f = f*10 + float64(d.d[i] - '0');
return f;
}
-func DecimalToFloat32Int(neg bool, d *Decimal) float32 {
+func decimalAtof32Int(neg bool, d *decimal) float32 {
f := float32(0);
for i := 0; i < d.nd; i++ {
f = f*10 + float32(d.d[i] - '0');
}
// If possible to convert decimal d to 64-bit float f exactly,
-// entirely in floating-point math, do so, avoiding the expense of DecimalToFloatBits.
+// entirely in floating-point math, do so, avoiding the expense of decimalToFloatBits.
// Three common cases:
// value is exact integer
// value is exact integer * exact power of ten
// value is exact integer / exact power of ten
// These all produce potentially inexact but correctly rounded answers.
-func DecimalToFloat64(neg bool, d *Decimal, trunc bool) (f float64, ok bool) {
+func decimalAtof64(neg bool, d *decimal, trunc bool) (f float64, ok bool) {
// Exact integers are <= 10^15.
// Exact powers of ten are <= 10^22.
if d.nd > 15 {
}
switch {
case d.dp == d.nd: // int
- f := DecimalToFloat64Int(neg, d);
+ f := decimalAtof64Int(neg, d);
return f, true;
case d.dp > d.nd && d.dp <= 15+22: // int * 10^k
- f := DecimalToFloat64Int(neg, d);
+ f := decimalAtof64Int(neg, d);
k := d.dp - d.nd;
// If exponent is big but number of digits is not,
// can move a few zeros into the integer part.
return f*float64pow10[k], true;
case d.dp < d.nd && d.nd - d.dp <= 22: // int / 10^k
- f := DecimalToFloat64Int(neg, d);
+ f := decimalAtof64Int(neg, d);
return f/float64pow10[d.nd - d.dp], true;
}
return;
// If possible to convert decimal d to 32-bit float f exactly,
// entirely in floating-point math, do so, avoiding the machinery above.
-func DecimalToFloat32(neg bool, d *Decimal, trunc bool) (f float32, ok bool) {
+func decimalAtof32(neg bool, d *decimal, trunc bool) (f float32, ok bool) {
// Exact integers are <= 10^7.
// Exact powers of ten are <= 10^10.
if d.nd > 7 {
}
switch {
case d.dp == d.nd: // int
- f := DecimalToFloat32Int(neg, d);
+ f := decimalAtof32Int(neg, d);
return f, true;
case d.dp > d.nd && d.dp <= 7+10: // int * 10^k
- f := DecimalToFloat32Int(neg, d);
+ f := decimalAtof32Int(neg, d);
k := d.dp - d.nd;
// If exponent is big but number of digits is not,
// can move a few zeros into the integer part.
return f*float32pow10[k], true;
case d.dp < d.nd && d.nd - d.dp <= 10: // int / 10^k
- f := DecimalToFloat32Int(neg, d);
+ f := decimalAtof32Int(neg, d);
return f/float32pow10[d.nd - d.dp], true;
}
return;
// If s is syntactically well-formed but is more than 1/2 ULP
// away from the largest floating point number of the given size,
// returns f = ±Inf, err = os.ERANGE.
-export func atof64(s string) (f float64, err *os.Error) {
- neg, d, trunc, ok := StringToDecimal(s);
+export func Atof64(s string) (f float64, err *os.Error) {
+ neg, d, trunc, ok := stringToDecimal(s);
if !ok {
return 0, os.EINVAL;
}
if optimize {
- if f, ok := DecimalToFloat64(neg, d, trunc); ok {
+ if f, ok := decimalAtof64(neg, d, trunc); ok {
return f, nil;
}
}
- b, ovf := DecimalToFloatBits(neg, d, trunc, &float64info);
+ b, ovf := decimalToFloatBits(neg, d, trunc, &float64info);
f = sys.float64frombits(b);
if ovf {
err = os.ERANGE;
return f, err
}
-export func atof32(s string) (f float32, err *os.Error) {
- neg, d, trunc, ok := StringToDecimal(s);
+export func Atof32(s string) (f float32, err *os.Error) {
+ neg, d, trunc, ok := stringToDecimal(s);
if !ok {
return 0, os.EINVAL;
}
if optimize {
- if f, ok := DecimalToFloat32(neg, d, trunc); ok {
+ if f, ok := decimalAtof32(neg, d, trunc); ok {
return f, nil;
}
}
- b, ovf := DecimalToFloatBits(neg, d, trunc, &float32info);
+ b, ovf := decimalToFloatBits(neg, d, trunc, &float32info);
f = sys.float32frombits(uint32(b));
if ovf {
err = os.ERANGE;
return f, err
}
-export func atof(s string) (f float, err *os.Error) {
+export func Atof(s string) (f float, err *os.Error) {
if FloatSize == 32 {
- f1, err1 := atof32(s);
+ f1, err1 := Atof32(s);
return float(f1), err1;
}
- f1, err1 := atof64(s);
+ f1, err1 := Atof64(s);
return float(f1), err1;
}
"testing"
)
-type AtofTest struct {
+type atofTest struct {
in string;
out string;
err *os.Error;
}
-var atoftests = []AtofTest {
- AtofTest{ "", "0", os.EINVAL },
- AtofTest{ "1", "1", nil },
- AtofTest{ "+1", "1", nil },
- AtofTest{ "1x", "0", os.EINVAL },
- AtofTest{ "1.1.", "0", os.EINVAL },
- AtofTest{ "1e23", "1e+23", nil },
- AtofTest{ "100000000000000000000000", "1e+23", nil },
- AtofTest{ "1e-100", "1e-100", nil },
- AtofTest{ "123456700", "1.234567e+08", nil },
- AtofTest{ "99999999999999974834176", "9.999999999999997e+22", nil },
- AtofTest{ "100000000000000000000001", "1.0000000000000001e+23", nil },
- AtofTest{ "100000000000000008388608", "1.0000000000000001e+23", nil },
- AtofTest{ "100000000000000016777215", "1.0000000000000001e+23", nil },
- AtofTest{ "100000000000000016777216", "1.0000000000000003e+23", nil },
- AtofTest{ "-1", "-1", nil },
- AtofTest{ "-0", "-0", nil },
- AtofTest{ "1e-20", "1e-20", nil },
- AtofTest{ "625e-3", "0.625", nil },
+var atoftests = []atofTest {
+ atofTest{ "", "0", os.EINVAL },
+ atofTest{ "1", "1", nil },
+ atofTest{ "+1", "1", nil },
+ atofTest{ "1x", "0", os.EINVAL },
+ atofTest{ "1.1.", "0", os.EINVAL },
+ atofTest{ "1e23", "1e+23", nil },
+ atofTest{ "100000000000000000000000", "1e+23", nil },
+ atofTest{ "1e-100", "1e-100", nil },
+ atofTest{ "123456700", "1.234567e+08", nil },
+ atofTest{ "99999999999999974834176", "9.999999999999997e+22", nil },
+ atofTest{ "100000000000000000000001", "1.0000000000000001e+23", nil },
+ atofTest{ "100000000000000008388608", "1.0000000000000001e+23", nil },
+ atofTest{ "100000000000000016777215", "1.0000000000000001e+23", nil },
+ atofTest{ "100000000000000016777216", "1.0000000000000003e+23", nil },
+ atofTest{ "-1", "-1", nil },
+ atofTest{ "-0", "-0", nil },
+ atofTest{ "1e-20", "1e-20", nil },
+ atofTest{ "625e-3", "0.625", nil },
// largest float64
- AtofTest{ "1.7976931348623157e308", "1.7976931348623157e+308", nil },
- AtofTest{ "-1.7976931348623157e308", "-1.7976931348623157e+308", nil },
+ atofTest{ "1.7976931348623157e308", "1.7976931348623157e+308", nil },
+ atofTest{ "-1.7976931348623157e308", "-1.7976931348623157e+308", nil },
// next float64 - too large
- AtofTest{ "1.7976931348623159e308", "+Inf", os.ERANGE },
- AtofTest{ "-1.7976931348623159e308", "-Inf", os.ERANGE },
+ atofTest{ "1.7976931348623159e308", "+Inf", os.ERANGE },
+ atofTest{ "-1.7976931348623159e308", "-Inf", os.ERANGE },
// the border is ...158079
// borderline - okay
- AtofTest{ "1.7976931348623158e308", "1.7976931348623157e+308", nil },
- AtofTest{ "-1.7976931348623158e308", "-1.7976931348623157e+308", nil },
+ atofTest{ "1.7976931348623158e308", "1.7976931348623157e+308", nil },
+ atofTest{ "-1.7976931348623158e308", "-1.7976931348623157e+308", nil },
// borderline - too large
- AtofTest{ "1.797693134862315808e308", "+Inf", os.ERANGE },
- AtofTest{ "-1.797693134862315808e308", "-Inf", os.ERANGE },
+ atofTest{ "1.797693134862315808e308", "+Inf", os.ERANGE },
+ atofTest{ "-1.797693134862315808e308", "-Inf", os.ERANGE },
// a little too large
- AtofTest{ "1e308", "1e+308", nil },
- AtofTest{ "2e308", "+Inf", os.ERANGE },
- AtofTest{ "1e309", "+Inf", os.ERANGE },
+ atofTest{ "1e308", "1e+308", nil },
+ atofTest{ "2e308", "+Inf", os.ERANGE },
+ atofTest{ "1e309", "+Inf", os.ERANGE },
// way too large
- AtofTest{ "1e310", "+Inf", os.ERANGE },
- AtofTest{ "-1e310", "-Inf", os.ERANGE },
- AtofTest{ "1e400", "+Inf", os.ERANGE },
- AtofTest{ "-1e400", "-Inf", os.ERANGE },
- AtofTest{ "1e400000", "+Inf", os.ERANGE },
- AtofTest{ "-1e400000", "-Inf", os.ERANGE },
+ atofTest{ "1e310", "+Inf", os.ERANGE },
+ atofTest{ "-1e310", "-Inf", os.ERANGE },
+ atofTest{ "1e400", "+Inf", os.ERANGE },
+ atofTest{ "-1e400", "-Inf", os.ERANGE },
+ atofTest{ "1e400000", "+Inf", os.ERANGE },
+ atofTest{ "-1e400000", "-Inf", os.ERANGE },
// denormalized
- AtofTest{ "1e-305", "1e-305", nil },
- AtofTest{ "1e-306", "1e-306", nil },
- AtofTest{ "1e-307", "1e-307", nil },
- AtofTest{ "1e-308", "1e-308", nil },
- AtofTest{ "1e-309", "1e-309", nil },
- AtofTest{ "1e-310", "1e-310", nil },
- AtofTest{ "1e-322", "1e-322", nil },
+ atofTest{ "1e-305", "1e-305", nil },
+ atofTest{ "1e-306", "1e-306", nil },
+ atofTest{ "1e-307", "1e-307", nil },
+ atofTest{ "1e-308", "1e-308", nil },
+ atofTest{ "1e-309", "1e-309", nil },
+ atofTest{ "1e-310", "1e-310", nil },
+ atofTest{ "1e-322", "1e-322", nil },
// smallest denormal
- AtofTest{ "5e-324", "5e-324", nil },
+ atofTest{ "5e-324", "5e-324", nil },
// too small
- AtofTest{ "4e-324", "0", nil },
+ atofTest{ "4e-324", "0", nil },
// way too small
- AtofTest{ "1e-350", "0", nil },
- AtofTest{ "1e-400000", "0", nil },
+ atofTest{ "1e-350", "0", nil },
+ atofTest{ "1e-400000", "0", nil },
// try to overflow exponent
- AtofTest{ "1e-4294967296", "0", nil },
- AtofTest{ "1e+4294967296", "+Inf", os.ERANGE },
- AtofTest{ "1e-18446744073709551616", "0", nil },
- AtofTest{ "1e+18446744073709551616", "+Inf", os.ERANGE },
+ atofTest{ "1e-4294967296", "0", nil },
+ atofTest{ "1e+4294967296", "+Inf", os.ERANGE },
+ atofTest{ "1e-18446744073709551616", "0", nil },
+ atofTest{ "1e+18446744073709551616", "+Inf", os.ERANGE },
// Parse errors
- AtofTest{ "1e", "0", os.EINVAL },
- AtofTest{ "1e-", "0", os.EINVAL },
- AtofTest{ ".e-1", "0", os.EINVAL },
+ atofTest{ "1e", "0", os.EINVAL },
+ atofTest{ "1e-", "0", os.EINVAL },
+ atofTest{ ".e-1", "0", os.EINVAL },
}
-func XTestAtof(t *testing.T, opt bool) {
+func testAtof(t *testing.T, opt bool) {
oldopt := strconv.optimize;
strconv.optimize = opt;
for i := 0; i < len(atoftests); i++ {
test := &atoftests[i];
- out, err := strconv.atof64(test.in);
- outs := strconv.ftoa64(out, 'g', -1);
+ out, err := strconv.Atof64(test.in);
+ outs := strconv.Ftoa64(out, 'g', -1);
if outs != test.out || err != test.err {
- t.Errorf("strconv.atof64(%v) = %v, %v want %v, %v\n",
+ t.Errorf("strconv.Atof64(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
if float64(float32(out)) == out {
- out32, err := strconv.atof32(test.in);
- outs := strconv.ftoa32(out32, 'g', -1);
+ out32, err := strconv.Atof32(test.in);
+ outs := strconv.Ftoa32(out32, 'g', -1);
if outs != test.out || err != test.err {
- t.Errorf("strconv.atof32(%v) = %v, %v want %v, %v # %v\n",
+ t.Errorf("strconv.Atof32(%v) = %v, %v want %v, %v # %v\n",
test.in, out32, err, test.out, test.err, out);
}
}
if FloatSize == 64 || float64(float32(out)) == out {
- outf, err := strconv.atof(test.in);
- outs := strconv.ftoa(outf, 'g', -1);
+ outf, err := strconv.Atof(test.in);
+ outs := strconv.Ftoa(outf, 'g', -1);
if outs != test.out || err != test.err {
- t.Errorf("strconv.ftoa(%v) = %v, %v want %v, %v # %v\n",
+ t.Errorf("strconv.Ftoa(%v) = %v, %v want %v, %v # %v\n",
test.in, outf, err, test.out, test.err, out);
}
}
}
export func TestAtof(t *testing.T) {
- XTestAtof(t, true);
+ testAtof(t, true);
}
export func TestAtofSlow(t *testing.T) {
- XTestAtof(t, false);
+ testAtof(t, false);
}
package strconv
import "os"
-func IntSize() uint {
+func computeIntsize() uint {
siz := uint(8);
for 1<<siz != 0 {
siz *= 2
}
return siz
}
-var intsize = IntSize();
+var intsize = computeIntsize();
// Convert decimal string to unsigned integer.
-export func atoui64(s string) (i uint64, err *os.Error) {
+export func Atoui64(s string) (i uint64, err *os.Error) {
// empty string bad
if len(s) == 0 {
return 0, os.EINVAL
}
// Convert decimal string to integer.
-export func atoi64(s string) (i int64, err *os.Error) {
+export func Atoi64(s string) (i int64, err *os.Error) {
// empty string bad
if len(s) == 0 {
return 0, os.EINVAL
}
var un uint64;
- un, err = atoui64(s);
+ un, err = Atoui64(s);
if err != nil && err != os.ERANGE {
return 0, err
}
return n, nil
}
-export func atoui(s string) (i uint, err *os.Error) {
- i1, e1 := atoui64(s);
+export func Atoui(s string) (i uint, err *os.Error) {
+ i1, e1 := Atoui64(s);
if e1 != nil && e1 != os.ERANGE {
return 0, e1
}
return i, nil
}
-export func atoi(s string) (i int, err *os.Error) {
- i1, e1 := atoi64(s);
+export func Atoi(s string) (i int, err *os.Error) {
+ i1, e1 := Atoi64(s);
if e1 != nil && e1 != os.ERANGE {
return 0, e1
}
"testing"
)
-type Atoui64Test struct {
+type atoui64Test struct {
in string;
out uint64;
err *os.Error;
}
-var atoui64tests = []Atoui64Test {
- Atoui64Test{ "", 0, os.EINVAL },
- Atoui64Test{ "0", 0, nil },
- Atoui64Test{ "1", 1, nil },
- Atoui64Test{ "12345", 12345, nil },
- Atoui64Test{ "012345", 0, os.EINVAL },
- Atoui64Test{ "12345x", 0, os.EINVAL },
- Atoui64Test{ "98765432100", 98765432100, nil },
- Atoui64Test{ "18446744073709551615", 1<<64-1, nil },
- Atoui64Test{ "18446744073709551616", 1<<64-1, os.ERANGE },
- Atoui64Test{ "18446744073709551620", 1<<64-1, os.ERANGE },
+var atoui64tests = []atoui64Test {
+ atoui64Test{ "", 0, os.EINVAL },
+ atoui64Test{ "0", 0, nil },
+ atoui64Test{ "1", 1, nil },
+ atoui64Test{ "12345", 12345, nil },
+ atoui64Test{ "012345", 0, os.EINVAL },
+ atoui64Test{ "12345x", 0, os.EINVAL },
+ atoui64Test{ "98765432100", 98765432100, nil },
+ atoui64Test{ "18446744073709551615", 1<<64-1, nil },
+ atoui64Test{ "18446744073709551616", 1<<64-1, os.ERANGE },
+ atoui64Test{ "18446744073709551620", 1<<64-1, os.ERANGE },
}
-type Atoi64Test struct {
+type atoi64Test struct {
in string;
out int64;
err *os.Error;
}
-var atoi64test = []Atoi64Test {
- Atoi64Test{ "", 0, os.EINVAL },
- Atoi64Test{ "0", 0, nil },
- Atoi64Test{ "-0", 0, nil },
- Atoi64Test{ "1", 1, nil },
- Atoi64Test{ "-1", -1, nil },
- Atoi64Test{ "12345", 12345, nil },
- Atoi64Test{ "-12345", -12345, nil },
- Atoi64Test{ "012345", 0, os.EINVAL },
- Atoi64Test{ "-012345", 0, os.EINVAL },
- Atoi64Test{ "12345x", 0, os.EINVAL },
- Atoi64Test{ "-12345x", 0, os.EINVAL },
- Atoi64Test{ "98765432100", 98765432100, nil },
- Atoi64Test{ "-98765432100", -98765432100, nil },
- Atoi64Test{ "9223372036854775807", 1<<63-1, nil },
- Atoi64Test{ "-9223372036854775807", -(1<<63-1), nil },
- Atoi64Test{ "9223372036854775808", 1<<63-1, os.ERANGE },
- Atoi64Test{ "-9223372036854775808", -1<<63, nil },
- Atoi64Test{ "9223372036854775809", 1<<63-1, os.ERANGE },
- Atoi64Test{ "-9223372036854775809", -1<<63, os.ERANGE },
+var atoi64test = []atoi64Test {
+ atoi64Test{ "", 0, os.EINVAL },
+ atoi64Test{ "0", 0, nil },
+ atoi64Test{ "-0", 0, nil },
+ atoi64Test{ "1", 1, nil },
+ atoi64Test{ "-1", -1, nil },
+ atoi64Test{ "12345", 12345, nil },
+ atoi64Test{ "-12345", -12345, nil },
+ atoi64Test{ "012345", 0, os.EINVAL },
+ atoi64Test{ "-012345", 0, os.EINVAL },
+ atoi64Test{ "12345x", 0, os.EINVAL },
+ atoi64Test{ "-12345x", 0, os.EINVAL },
+ atoi64Test{ "98765432100", 98765432100, nil },
+ atoi64Test{ "-98765432100", -98765432100, nil },
+ atoi64Test{ "9223372036854775807", 1<<63-1, nil },
+ atoi64Test{ "-9223372036854775807", -(1<<63-1), nil },
+ atoi64Test{ "9223372036854775808", 1<<63-1, os.ERANGE },
+ atoi64Test{ "-9223372036854775808", -1<<63, nil },
+ atoi64Test{ "9223372036854775809", 1<<63-1, os.ERANGE },
+ atoi64Test{ "-9223372036854775809", -1<<63, os.ERANGE },
}
-type Atoui32Test struct {
+type atoui32Test struct {
in string;
out uint32;
err *os.Error;
}
-var atoui32tests = []Atoui32Test {
- Atoui32Test{ "", 0, os.EINVAL },
- Atoui32Test{ "0", 0, nil },
- Atoui32Test{ "1", 1, nil },
- Atoui32Test{ "12345", 12345, nil },
- Atoui32Test{ "012345", 0, os.EINVAL },
- Atoui32Test{ "12345x", 0, os.EINVAL },
- Atoui32Test{ "987654321", 987654321, nil },
- Atoui32Test{ "4294967295", 1<<32-1, nil },
- Atoui32Test{ "4294967296", 1<<32-1, os.ERANGE },
+var atoui32tests = []atoui32Test {
+ atoui32Test{ "", 0, os.EINVAL },
+ atoui32Test{ "0", 0, nil },
+ atoui32Test{ "1", 1, nil },
+ atoui32Test{ "12345", 12345, nil },
+ atoui32Test{ "012345", 0, os.EINVAL },
+ atoui32Test{ "12345x", 0, os.EINVAL },
+ atoui32Test{ "987654321", 987654321, nil },
+ atoui32Test{ "4294967295", 1<<32-1, nil },
+ atoui32Test{ "4294967296", 1<<32-1, os.ERANGE },
}
-type Atoi32Test struct {
+type atoi32Test struct {
in string;
out int32;
err *os.Error;
}
-var atoi32tests = []Atoi32Test {
- Atoi32Test{ "", 0, os.EINVAL },
- Atoi32Test{ "0", 0, nil },
- Atoi32Test{ "-0", 0, nil },
- Atoi32Test{ "1", 1, nil },
- Atoi32Test{ "-1", -1, nil },
- Atoi32Test{ "12345", 12345, nil },
- Atoi32Test{ "-12345", -12345, nil },
- Atoi32Test{ "012345", 0, os.EINVAL },
- Atoi32Test{ "-012345", 0, os.EINVAL },
- Atoi32Test{ "12345x", 0, os.EINVAL },
- Atoi32Test{ "-12345x", 0, os.EINVAL },
- Atoi32Test{ "987654321", 987654321, nil },
- Atoi32Test{ "-987654321", -987654321, nil },
- Atoi32Test{ "2147483647", 1<<31-1, nil },
- Atoi32Test{ "-2147483647", -(1<<31-1), nil },
- Atoi32Test{ "2147483648", 1<<31-1, os.ERANGE },
- Atoi32Test{ "-2147483648", -1<<31, nil },
- Atoi32Test{ "2147483649", 1<<31-1, os.ERANGE },
- Atoi32Test{ "-2147483649", -1<<31, os.ERANGE },
+var atoi32tests = []atoi32Test {
+ atoi32Test{ "", 0, os.EINVAL },
+ atoi32Test{ "0", 0, nil },
+ atoi32Test{ "-0", 0, nil },
+ atoi32Test{ "1", 1, nil },
+ atoi32Test{ "-1", -1, nil },
+ atoi32Test{ "12345", 12345, nil },
+ atoi32Test{ "-12345", -12345, nil },
+ atoi32Test{ "012345", 0, os.EINVAL },
+ atoi32Test{ "-012345", 0, os.EINVAL },
+ atoi32Test{ "12345x", 0, os.EINVAL },
+ atoi32Test{ "-12345x", 0, os.EINVAL },
+ atoi32Test{ "987654321", 987654321, nil },
+ atoi32Test{ "-987654321", -987654321, nil },
+ atoi32Test{ "2147483647", 1<<31-1, nil },
+ atoi32Test{ "-2147483647", -(1<<31-1), nil },
+ atoi32Test{ "2147483648", 1<<31-1, os.ERANGE },
+ atoi32Test{ "-2147483648", -1<<31, nil },
+ atoi32Test{ "2147483649", 1<<31-1, os.ERANGE },
+ atoi32Test{ "-2147483649", -1<<31, os.ERANGE },
}
export func TestAtoui64(t *testing.T) {
for i := 0; i < len(atoui64tests); i++ {
test := &atoui64tests[i];
- out, err := strconv.atoui64(test.in);
+ out, err := strconv.Atoui64(test.in);
if test.out != out || test.err != err {
- t.Errorf("strconv.atoui64(%v) = %v, %v want %v, %v\n",
+ t.Errorf("strconv.Atoui64(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
export func TestAtoi64(t *testing.T) {
for i := 0; i < len(atoi64test); i++ {
test := &atoi64test[i];
- out, err := strconv.atoi64(test.in);
+ out, err := strconv.Atoi64(test.in);
if test.out != out || test.err != err {
- t.Errorf("strconv.atoi64(%v) = %v, %v want %v, %v\n",
+ t.Errorf("strconv.Atoi64(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
}
-func IntSize1() uint {
- tmp := 1;
- if tmp<<16<<16 == 0 {
- return 32;
- }
- return 64;
-}
-
export func TestAtoui(t *testing.T) {
- switch IntSize1() {
+ switch intsize {
case 32:
for i := 0; i < len(atoui32tests); i++ {
test := &atoui32tests[i];
- out, err := strconv.atoui(test.in);
+ out, err := strconv.Atoui(test.in);
if test.out != uint32(out) || test.err != err {
- t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n",
+ t.Errorf("strconv.Atoui(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
case 64:
for i := 0; i < len(atoui64tests); i++ {
test := &atoui64tests[i];
- out, err := strconv.atoui(test.in);
+ out, err := strconv.Atoui(test.in);
if test.out != uint64(out) || test.err != err {
- t.Errorf("strconv.atoui(%v) = %v, %v want %v, %v\n",
+ t.Errorf("strconv.Atoui(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
}
export func TestAtoi(t *testing.T) {
- switch IntSize1() {
+ switch intsize {
case 32:
for i := 0; i < len(atoi32tests); i++ {
test := &atoi32tests[i];
- out, err := strconv.atoi(test.in);
+ out, err := strconv.Atoi(test.in);
if test.out != int32(out) || test.err != err {
- t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n",
+ t.Errorf("strconv.Atoi(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
case 64:
for i := 0; i < len(atoi64test); i++ {
test := &atoi64test[i];
- out, err := strconv.atoi(test.in);
+ out, err := strconv.Atoi(test.in);
if test.out != int64(out) || test.err != err {
- t.Errorf("strconv.atoi(%v) = %v, %v want %v, %v\n",
+ t.Errorf("strconv.Atoi(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
package strconv
-package type Decimal struct {
+type decimal struct {
// TODO(rsc): Can make d[] a bit smaller and add
// truncated bool;
d [2000] byte; // digits
nd int; // number of digits used
dp int; // decimal point
};
-func (a *Decimal) String() string;
-func (a *Decimal) Assign(v uint64);
-func (a *Decimal) Shift(k int) *Decimal;
-func (a *Decimal) Round(nd int) *Decimal;
-func (a *Decimal) RoundUp(nd int) *Decimal;
-func (a *Decimal) RoundDown(nd int) *Decimal;
-func (a *Decimal) RoundedInteger() uint64;
+func (a *decimal) String() string;
+func (a *decimal) Assign(v uint64);
+func (a *decimal) Shift(k int) *decimal;
+func (a *decimal) Round(nd int) *decimal;
+func (a *decimal) RoundUp(nd int) *decimal;
+func (a *decimal) RoundDown(nd int) *decimal;
+func (a *decimal) RoundedInteger() uint64;
-func Copy(dst []byte, src []byte) int;
-func DigitZero(dst []byte) int;
+func copy(dst []byte, src []byte) int;
+func digitZero(dst []byte) int;
-func (a *Decimal) String() string {
+func (a *decimal) String() string {
n := 10 + a.nd;
if a.dp > 0 {
n += a.dp;
w++;
buf[w] = '.';
w++;
- w += DigitZero(buf[w:w+-a.dp]);
- w += Copy(buf[w:w+a.nd], a.d[0:a.nd]);
+ w += digitZero(buf[w:w+-a.dp]);
+ w += copy(buf[w:w+a.nd], a.d[0:a.nd]);
case a.dp < a.nd:
// decimal point in middle of digits
- w += Copy(buf[w:w+a.dp], a.d[0:a.dp]);
+ w += copy(buf[w:w+a.dp], a.d[0:a.dp]);
buf[w] = '.';
w++;
- w += Copy(buf[w:w+a.nd-a.dp], a.d[a.dp:a.nd]);
+ w += copy(buf[w:w+a.nd-a.dp], a.d[a.dp:a.nd]);
default:
// zeros fill space between digits and decimal point
- w += Copy(buf[w:w+a.nd], a.d[0:a.nd]);
- w += DigitZero(buf[w:w+a.dp-a.nd]);
+ w += copy(buf[w:w+a.nd], a.d[0:a.nd]);
+ w += digitZero(buf[w:w+a.dp-a.nd]);
}
return string(buf[0:w]);
}
-func Copy(dst []byte, src []byte) int {
+func copy(dst []byte, src []byte) int {
for i := 0; i < len(dst); i++ {
dst[i] = src[i];
}
return len(dst);
}
-func DigitZero(dst []byte) int {
+func digitZero(dst []byte) int {
for i := 0; i < len(dst); i++ {
dst[i] = '0';
}
return len(dst);
}
-// Trim trailing zeros from number.
+// trim trailing zeros from number.
// (They are meaningless; the decimal point is tracked
// independent of the number of digits.)
-func Trim(a *Decimal) {
+func trim(a *decimal) {
for a.nd > 0 && a.d[a.nd-1] == '0' {
a.nd--;
}
}
// Assign v to a.
-func (a *Decimal) Assign(v uint64) {
+func (a *decimal) Assign(v uint64) {
var buf [50]byte;
// Write reversed decimal in buf.
a.nd++;
}
a.dp = a.nd;
- Trim(a);
+ trim(a);
}
-package func NewDecimal(i uint64) *Decimal {
- a := new(Decimal);
+func newDecimal(i uint64) *decimal {
+ a := new(decimal);
a.Assign(i);
return a;
}
// Maximum shift that we can do in one pass without overflow.
// Signed int has 31 bits, and we have to be able to accomodate 9<<k.
-const MaxShift = 27
+const maxShift = 27
-// Binary shift right (* 2) by k bits. k <= MaxShift to avoid overflow.
-func RightShift(a *Decimal, k uint) {
+// Binary shift right (* 2) by k bits. k <= maxShift to avoid overflow.
+func rightShift(a *decimal, k uint) {
r := 0; // read pointer
w := 0; // write pointer
}
a.nd = w;
- Trim(a);
+ trim(a);
}
// Cheat sheet for left shift: table indexed by shift count giving
// number of new digits that will be introduced by that shift.
//
-// For example, leftcheat[4] = {2, "625"}. That means that
+// For example, leftcheats[4] = {2, "625"}. That means that
// if we are shifting by 4 (multiplying by 16), it will add 2 digits
// when the string prefix is "625" through "999", and one fewer digit
// if the string prefix is "000" through "624".
//
// Credit for this trick goes to Ken.
-type LeftCheat struct {
+type leftCheat struct {
delta int; // number of new digits
cutoff string; // minus one digit if original < a.
}
-var leftcheat = []LeftCheat {
+var leftcheats = []leftCheat {
// Leading digits of 1/2^i = 5^i.
// 5^23 is not an exact 64-bit floating point number,
// so have to use bc for the math.
/*
seq 27 | sed 's/^/5^/' | bc |
- awk 'BEGIN{ print "\tLeftCheat{ 0, \"\" }," }
+ awk 'BEGIN{ print "\tleftCheat{ 0, \"\" }," }
{
log2 = log(2)/log(10)
- printf("\tLeftCheat{ %d, \"%s\" },\t// * %d\n",
+ printf("\tleftCheat{ %d, \"%s\" },\t// * %d\n",
int(log2*NR+1), $0, 2**NR)
}'
*/
- LeftCheat{ 0, "" },
- LeftCheat{ 1, "5" }, // * 2
- LeftCheat{ 1, "25" }, // * 4
- LeftCheat{ 1, "125" }, // * 8
- LeftCheat{ 2, "625" }, // * 16
- LeftCheat{ 2, "3125" }, // * 32
- LeftCheat{ 2, "15625" }, // * 64
- LeftCheat{ 3, "78125" }, // * 128
- LeftCheat{ 3, "390625" }, // * 256
- LeftCheat{ 3, "1953125" }, // * 512
- LeftCheat{ 4, "9765625" }, // * 1024
- LeftCheat{ 4, "48828125" }, // * 2048
- LeftCheat{ 4, "244140625" }, // * 4096
- LeftCheat{ 4, "1220703125" }, // * 8192
- LeftCheat{ 5, "6103515625" }, // * 16384
- LeftCheat{ 5, "30517578125" }, // * 32768
- LeftCheat{ 5, "152587890625" }, // * 65536
- LeftCheat{ 6, "762939453125" }, // * 131072
- LeftCheat{ 6, "3814697265625" }, // * 262144
- LeftCheat{ 6, "19073486328125" }, // * 524288
- LeftCheat{ 7, "95367431640625" }, // * 1048576
- LeftCheat{ 7, "476837158203125" }, // * 2097152
- LeftCheat{ 7, "2384185791015625" }, // * 4194304
- LeftCheat{ 7, "11920928955078125" }, // * 8388608
- LeftCheat{ 8, "59604644775390625" }, // * 16777216
- LeftCheat{ 8, "298023223876953125" }, // * 33554432
- LeftCheat{ 8, "1490116119384765625" }, // * 67108864
- LeftCheat{ 9, "7450580596923828125" }, // * 134217728
+ leftCheat{ 0, "" },
+ leftCheat{ 1, "5" }, // * 2
+ leftCheat{ 1, "25" }, // * 4
+ leftCheat{ 1, "125" }, // * 8
+ leftCheat{ 2, "625" }, // * 16
+ leftCheat{ 2, "3125" }, // * 32
+ leftCheat{ 2, "15625" }, // * 64
+ leftCheat{ 3, "78125" }, // * 128
+ leftCheat{ 3, "390625" }, // * 256
+ leftCheat{ 3, "1953125" }, // * 512
+ leftCheat{ 4, "9765625" }, // * 1024
+ leftCheat{ 4, "48828125" }, // * 2048
+ leftCheat{ 4, "244140625" }, // * 4096
+ leftCheat{ 4, "1220703125" }, // * 8192
+ leftCheat{ 5, "6103515625" }, // * 16384
+ leftCheat{ 5, "30517578125" }, // * 32768
+ leftCheat{ 5, "152587890625" }, // * 65536
+ leftCheat{ 6, "762939453125" }, // * 131072
+ leftCheat{ 6, "3814697265625" }, // * 262144
+ leftCheat{ 6, "19073486328125" }, // * 524288
+ leftCheat{ 7, "95367431640625" }, // * 1048576
+ leftCheat{ 7, "476837158203125" }, // * 2097152
+ leftCheat{ 7, "2384185791015625" }, // * 4194304
+ leftCheat{ 7, "11920928955078125" }, // * 8388608
+ leftCheat{ 8, "59604644775390625" }, // * 16777216
+ leftCheat{ 8, "298023223876953125" }, // * 33554432
+ leftCheat{ 8, "1490116119384765625" }, // * 67108864
+ leftCheat{ 9, "7450580596923828125" }, // * 134217728
}
// Is the leading prefix of b lexicographically less than s?
-func PrefixIsLessThan(b []byte, s string) bool {
+func prefixIsLessThan(b []byte, s string) bool {
for i := 0; i < len(s); i++ {
if i >= len(b) {
return true;
return false;
}
-// Binary shift left (/ 2) by k bits. k <= MaxShift to avoid overflow.
-func LeftShift(a *Decimal, k uint) {
- delta := leftcheat[k].delta;
- if PrefixIsLessThan(a.d[0:a.nd], leftcheat[k].cutoff) {
+// Binary shift left (/ 2) by k bits. k <= maxShift to avoid overflow.
+func leftShift(a *decimal, k uint) {
+ delta := leftcheats[k].delta;
+ if prefixIsLessThan(a.d[0:a.nd], leftcheats[k].cutoff) {
delta--;
}
if w != 0 {
// TODO: Remove - has no business panicking.
- panicln("strconv: bad LeftShift", w);
+ panicln("strconv: bad leftShift", w);
}
a.nd += delta;
a.dp += delta;
- Trim(a);
+ trim(a);
}
// Binary shift left (k > 0) or right (k < 0).
// Returns receiver for convenience.
-func (a *Decimal) Shift(k int) *Decimal {
+func (a *decimal) Shift(k int) *decimal {
switch {
case a.nd == 0:
// nothing to do: a == 0
case k > 0:
- for k > MaxShift {
- LeftShift(a, MaxShift);
- k -= MaxShift;
+ for k > maxShift {
+ leftShift(a, maxShift);
+ k -= maxShift;
}
- LeftShift(a, uint(k));
+ leftShift(a, uint(k));
case k < 0:
- for k < -MaxShift {
- RightShift(a, MaxShift);
- k += MaxShift;
+ for k < -maxShift {
+ rightShift(a, maxShift);
+ k += maxShift;
}
- RightShift(a, uint(-k));
+ rightShift(a, uint(-k));
}
return a;
}
// If we chop a at nd digits, should we round up?
-func ShouldRoundUp(a *Decimal, nd int) bool {
+func shouldRoundUp(a *decimal, nd int) bool {
if nd <= 0 || nd >= a.nd {
return false;
}
// Round a to nd digits (or fewer).
// Returns receiver for convenience.
-func (a *Decimal) Round(nd int) *Decimal {
+func (a *decimal) Round(nd int) *decimal {
if nd <= 0 || nd >= a.nd {
return a;
}
- if(ShouldRoundUp(a, nd)) {
+ if(shouldRoundUp(a, nd)) {
return a.RoundUp(nd);
}
return a.RoundDown(nd);
// Round a down to nd digits (or fewer).
// Returns receiver for convenience.
-func (a *Decimal) RoundDown(nd int) *Decimal {
+func (a *decimal) RoundDown(nd int) *decimal {
if nd <= 0 || nd >= a.nd {
return a;
}
a.nd = nd;
- Trim(a);
+ trim(a);
return a;
}
// Round a up to nd digits (or fewer).
// Returns receiver for convenience.
-func (a *Decimal) RoundUp(nd int) *Decimal {
+func (a *decimal) RoundUp(nd int) *decimal {
if nd <= 0 || nd >= a.nd {
return a;
}
// Extract integer part, rounded appropriately.
// No guarantees about overflow.
-func (a *Decimal) RoundedInteger() uint64 {
+func (a *decimal) RoundedInteger() uint64 {
if a.dp > 20 {
return 0xFFFFFFFFFFFFFFFF;
}
for ; i < a.dp; i++ {
n *= 10;
}
- if ShouldRoundUp(a, a.dp) {
+ if shouldRoundUp(a, a.dp) {
n++;
}
return n;
"testing";
)
-type ShiftTest struct {
+type shiftTest struct {
i uint64;
shift int;
out string;
}
-var shifttests = []ShiftTest {
- ShiftTest{ 0, -100, "0" },
- ShiftTest{ 0, 100, "0" },
- ShiftTest{ 1, 100, "1267650600228229401496703205376" },
- ShiftTest{ 1, -100,
+var shifttests = []shiftTest {
+ shiftTest{ 0, -100, "0" },
+ shiftTest{ 0, 100, "0" },
+ shiftTest{ 1, 100, "1267650600228229401496703205376" },
+ shiftTest{ 1, -100,
"0.00000000000000000000000000000078886090522101180541"
"17285652827862296732064351090230047702789306640625" },
- ShiftTest{ 12345678, 8, "3160493568" },
- ShiftTest{ 12345678, -8, "48225.3046875" },
- ShiftTest{ 195312, 9, "99999744" },
- ShiftTest{ 1953125, 9, "1000000000" },
+ shiftTest{ 12345678, 8, "3160493568" },
+ shiftTest{ 12345678, -8, "48225.3046875" },
+ shiftTest{ 195312, 9, "99999744" },
+ shiftTest{ 1953125, 9, "1000000000" },
}
export func TestDecimalShift(t *testing.T) {
ok := true;
for i := 0; i < len(shifttests); i++ {
test := &shifttests[i];
- s := strconv.NewDecimal(test.i).Shift(test.shift).String();
+ s := strconv.newDecimal(test.i).Shift(test.shift).String();
if s != test.out {
t.Errorf("Decimal %v << %v = %v, want %v\n",
test.i, test.shift, s, test.out);
}
}
-type RoundTest struct {
+type roundTest struct {
i uint64;
nd int;
down, round, up string;
int uint64;
}
-var roundtests = []RoundTest {
- RoundTest{ 0, 4, "0", "0", "0", 0 },
- RoundTest{ 12344999, 4, "12340000", "12340000", "12350000", 12340000 },
- RoundTest{ 12345000, 4, "12340000", "12340000", "12350000", 12340000 },
- RoundTest{ 12345001, 4, "12340000", "12350000", "12350000", 12350000 },
- RoundTest{ 23454999, 4, "23450000", "23450000", "23460000", 23450000 },
- RoundTest{ 23455000, 4, "23450000", "23460000", "23460000", 23460000 },
- RoundTest{ 23455001, 4, "23450000", "23460000", "23460000", 23460000 },
+var roundtests = []roundTest {
+ roundTest{ 0, 4, "0", "0", "0", 0 },
+ roundTest{ 12344999, 4, "12340000", "12340000", "12350000", 12340000 },
+ roundTest{ 12345000, 4, "12340000", "12340000", "12350000", 12340000 },
+ roundTest{ 12345001, 4, "12340000", "12350000", "12350000", 12350000 },
+ roundTest{ 23454999, 4, "23450000", "23450000", "23460000", 23450000 },
+ roundTest{ 23455000, 4, "23450000", "23460000", "23460000", 23460000 },
+ roundTest{ 23455001, 4, "23450000", "23460000", "23460000", 23460000 },
- RoundTest{ 99994999, 4, "99990000", "99990000", "100000000", 99990000 },
- RoundTest{ 99995000, 4, "99990000", "100000000", "100000000", 100000000 },
- RoundTest{ 99999999, 4, "99990000", "100000000", "100000000", 100000000 },
+ roundTest{ 99994999, 4, "99990000", "99990000", "100000000", 99990000 },
+ roundTest{ 99995000, 4, "99990000", "100000000", "100000000", 100000000 },
+ roundTest{ 99999999, 4, "99990000", "100000000", "100000000", 100000000 },
- RoundTest{ 12994999, 4, "12990000", "12990000", "13000000", 12990000 },
- RoundTest{ 12995000, 4, "12990000", "13000000", "13000000", 13000000 },
- RoundTest{ 12999999, 4, "12990000", "13000000", "13000000", 13000000 },
+ roundTest{ 12994999, 4, "12990000", "12990000", "13000000", 12990000 },
+ roundTest{ 12995000, 4, "12990000", "13000000", "13000000", 13000000 },
+ roundTest{ 12999999, 4, "12990000", "13000000", "13000000", 13000000 },
}
export func TestDecimalRound(t *testing.T) {
for i := 0; i < len(roundtests); i++ {
test := &roundtests[i];
- s := strconv.NewDecimal(test.i).RoundDown(test.nd).String();
+ s := strconv.newDecimal(test.i).RoundDown(test.nd).String();
if s != test.down {
t.Errorf("Decimal %v RoundDown %d = %v, want %v\n",
test.i, test.nd, s, test.down);
}
- s = strconv.NewDecimal(test.i).Round(test.nd).String();
+ s = strconv.newDecimal(test.i).Round(test.nd).String();
if s != test.round {
t.Errorf("Decimal %v Round %d = %v, want %v\n",
test.i, test.nd, s, test.down);
}
- s = strconv.NewDecimal(test.i).RoundUp(test.nd).String();
+ s = strconv.newDecimal(test.i).RoundUp(test.nd).String();
if s != test.up {
t.Errorf("Decimal %v RoundUp %d = %v, want %v\n",
test.i, test.nd, s, test.up);
}
}
-type RoundIntTest struct {
+type roundIntTest struct {
i uint64;
shift int;
int uint64;
}
-var roundinttests = []RoundIntTest {
- RoundIntTest{ 0, 100, 0 },
- RoundIntTest{ 512, -8, 2 },
- RoundIntTest{ 513, -8, 2 },
- RoundIntTest{ 640, -8, 2 },
- RoundIntTest{ 641, -8, 3 },
- RoundIntTest{ 384, -8, 2 },
- RoundIntTest{ 385, -8, 2 },
- RoundIntTest{ 383, -8, 1 },
- RoundIntTest{ 1, 100, 1<<64-1 },
- RoundIntTest{ 1000, 0, 1000 },
+var roundinttests = []roundIntTest {
+ roundIntTest{ 0, 100, 0 },
+ roundIntTest{ 512, -8, 2 },
+ roundIntTest{ 513, -8, 2 },
+ roundIntTest{ 640, -8, 2 },
+ roundIntTest{ 641, -8, 3 },
+ roundIntTest{ 384, -8, 2 },
+ roundIntTest{ 385, -8, 2 },
+ roundIntTest{ 383, -8, 1 },
+ roundIntTest{ 1, 100, 1<<64-1 },
+ roundIntTest{ 1000, 0, 1000 },
}
export func TestDecimalRoundedInteger(t *testing.T) {
for i := 0; i < len(roundinttests); i++ {
test := roundinttests[i];
// TODO: should be able to use int := here.
- int1 := strconv.NewDecimal(test.i).Shift(test.shift).RoundedInteger();
+ int1 := strconv.newDecimal(test.i).Shift(test.shift).RoundedInteger();
if int1 != test.int {
t.Errorf("Decimal %v >> %v RoundedInteger = %v, want %v\n",
test.i, test.shift, int1, test.int);
return pow2(i/2) * pow2(i-i/2);
}
-// Wrapper around strconv.atof64. Handles dddddp+ddd (binary exponent)
-// itself, passes the rest on to strconv.atof64.
+// Wrapper around strconv.Atof64. Handles dddddp+ddd (binary exponent)
+// itself, passes the rest on to strconv.Atof64.
func myatof64(s string) (f float64, ok bool) {
a := strings.split(s, "p");
if len(a) == 2 {
- n, err := strconv.atoi64(a[0]);
+ n, err := strconv.Atoi64(a[0]);
if err != nil {
return 0, false;
}
- e, err1 := strconv.atoi(a[1]);
+ e, err1 := strconv.Atoi(a[1]);
if err1 != nil {
println("bad e", a[1]);
return 0, false;
}
return v*pow2(e), true;
}
- f1, err := strconv.atof64(s);
+ f1, err := strconv.Atof64(s);
if err != nil {
return 0, false;
}
return f1, true;
}
-// Wrapper around strconv.atof32. Handles dddddp+ddd (binary exponent)
-// itself, passes the rest on to strconv.atof32.
+// Wrapper around strconv.Atof32. Handles dddddp+ddd (binary exponent)
+// itself, passes the rest on to strconv.Atof32.
func myatof32(s string) (f float32, ok bool) {
a := strings.split(s, "p");
if len(a) == 2 {
- n, err := strconv.atoi(a[0]);
+ n, err := strconv.Atoi(a[0]);
if err != nil {
println("bad n", a[0]);
return 0, false;
}
- e, err1 := strconv.atoi(a[1]);
+ e, err1 := strconv.Atoi(a[1]);
if err1 != nil {
println("bad p", a[1]);
return 0, false;
}
return float32(float64(n)*pow2(e)), true;
}
- f1, err1 := strconv.atof32(s);
+ f1, err1 := strconv.Atof32(s);
if err1 != nil {
return 0, false;
}
import "strconv"
// TODO: move elsewhere?
-package type FloatInfo struct {
+type floatInfo struct {
mantbits uint;
expbits uint;
bias int;
}
-package var float32info = FloatInfo{ 23, 8, -127 }
-package var float64info = FloatInfo{ 52, 11, -1023 }
+var float32info = floatInfo{ 23, 8, -127 }
+var float64info = floatInfo{ 52, 11, -1023 }
-func FmtB(neg bool, mant uint64, exp int, flt *FloatInfo) string
-func FmtE(neg bool, d *Decimal, prec int) string
-func FmtF(neg bool, d *Decimal, prec int) string
-func GenericFtoa(bits uint64, fmt byte, prec int, flt *FloatInfo) string
-func Max(a, b int) int
-func RoundShortest(d *Decimal, mant uint64, exp int, flt *FloatInfo)
+func fmtB(neg bool, mant uint64, exp int, flt *floatInfo) string
+func fmtE(neg bool, d *decimal, prec int) string
+func fmtF(neg bool, d *decimal, prec int) string
+func genericFtoa(bits uint64, fmt byte, prec int, flt *floatInfo) string
+func max(a, b int) int
+func roundShortest(d *decimal, mant uint64, exp int, flt *floatInfo)
func floatsize() int {
// Figure out whether float is float32 or float64.
}
export var FloatSize = floatsize()
-export func ftoa32(f float32, fmt byte, prec int) string {
- return GenericFtoa(uint64(sys.float32bits(f)), fmt, prec, &float32info);
+export func Ftoa32(f float32, fmt byte, prec int) string {
+ return genericFtoa(uint64(sys.float32bits(f)), fmt, prec, &float32info);
}
-export func ftoa64(f float64, fmt byte, prec int) string {
- return GenericFtoa(sys.float64bits(f), fmt, prec, &float64info);
+export func Ftoa64(f float64, fmt byte, prec int) string {
+ return genericFtoa(sys.float64bits(f), fmt, prec, &float64info);
}
-export func ftoa(f float, fmt byte, prec int) string {
+export func Ftoa(f float, fmt byte, prec int) string {
if FloatSize == 32 {
- return ftoa32(float32(f), fmt, prec);
+ return Ftoa32(float32(f), fmt, prec);
}
- return ftoa64(float64(f), fmt, prec);
+ return Ftoa64(float64(f), fmt, prec);
}
-func GenericFtoa(bits uint64, fmt byte, prec int, flt *FloatInfo) string {
+func genericFtoa(bits uint64, fmt byte, prec int, flt *floatInfo) string {
neg := bits>>flt.expbits>>flt.mantbits != 0;
exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
mant := bits & (uint64(1)<<flt.mantbits - 1);
// Pick off easy binary format.
if fmt == 'b' {
- return FmtB(neg, mant, exp, flt);
+ return fmtB(neg, mant, exp, flt);
}
// Create exact decimal representation.
// The shift is exp - flt.mantbits because mant is a 1-bit integer
// followed by a flt.mantbits fraction, and we are treating it as
// a 1+flt.mantbits-bit integer.
- d := NewDecimal(mant).Shift(exp - int(flt.mantbits));
+ d := newDecimal(mant).Shift(exp - int(flt.mantbits));
// Round appropriately.
// Negative precision means "only as much as needed to be exact."
shortest := false;
if prec < 0 {
shortest = true;
- RoundShortest(d, mant, exp, flt);
+ roundShortest(d, mant, exp, flt);
switch fmt {
case 'e':
prec = d.nd - 1;
case 'f':
- prec = Max(d.nd - d.dp, 0);
+ prec = max(d.nd - d.dp, 0);
case 'g':
prec = d.nd;
}
switch fmt {
case 'e':
- return FmtE(neg, d, prec);
+ return fmtE(neg, d, prec);
case 'f':
- return FmtF(neg, d, prec);
+ return fmtF(neg, d, prec);
case 'g':
// trailing zeros are removed.
if prec > d.nd {
}
exp := d.dp - 1;
if exp < -4 || exp >= eprec {
- return FmtE(neg, d, prec - 1);
+ return fmtE(neg, d, prec - 1);
}
- return FmtF(neg, d, Max(prec - d.dp, 0));
+ return fmtF(neg, d, max(prec - d.dp, 0));
}
return "%" + string(fmt);
// Round d (= mant * 2^exp) to the shortest number of digits
// that will let the original floating point value be precisely
// reconstructed. Size is original floating point size (64 or 32).
-func RoundShortest(d *Decimal, mant uint64, exp int, flt *FloatInfo) {
+func roundShortest(d *decimal, mant uint64, exp int, flt *floatInfo) {
// If mantissa is zero, the number is zero; stop now.
if mant == 0 {
d.nd = 0;
// d = mant << (exp - mantbits)
// Next highest floating point number is mant+1 << exp-mantbits.
// Our upper bound is halfway inbetween, mant*2+1 << exp-mantbits-1.
- upper := NewDecimal(mant*2+1).Shift(exp-int(flt.mantbits)-1);
+ upper := newDecimal(mant*2+1).Shift(exp-int(flt.mantbits)-1);
// d = mant << (exp - mantbits)
// Next lowest floating point number is mant-1 << exp-mantbits,
mantlo = mant*2-1;
explo = exp-1;
}
- lower := NewDecimal(mantlo*2+1).Shift(explo-int(flt.mantbits)-1);
+ lower := newDecimal(mantlo*2+1).Shift(explo-int(flt.mantbits)-1);
// The upper and lower bounds are possible outputs only if
// the original mantissa is even, so that IEEE round-to-even
}
// %e: -d.ddddde±dd
-func FmtE(neg bool, d *Decimal, prec int) string {
- buf := make([]byte, 3+Max(prec, 0)+30); // "-0." + prec digits + exp
+func fmtE(neg bool, d *decimal, prec int) string {
+ buf := make([]byte, 3+max(prec, 0)+30); // "-0." + prec digits + exp
w := 0; // write index
// sign
}
// %f: -ddddddd.ddddd
-func FmtF(neg bool, d *Decimal, prec int) string {
- buf := make([]byte, 1+Max(d.dp, 1)+1+Max(prec, 0));
+func fmtF(neg bool, d *decimal, prec int) string {
+ buf := make([]byte, 1+max(d.dp, 1)+1+max(prec, 0));
w := 0;
// sign
}
// %b: -ddddddddp+ddd
-func FmtB(neg bool, mant uint64, exp int, flt *FloatInfo) string {
+func fmtB(neg bool, mant uint64, exp int, flt *floatInfo) string {
var buf [50]byte;
w := len(buf);
exp -= int(flt.mantbits);
return string(buf[w:len(buf)]);
}
-func Max(a, b int) int {
+func max(a, b int) int {
if a > b {
return a;
}
"testing"
)
-type FtoaTest struct {
+type ftoaTest struct {
f float64;
fmt byte;
prec int;
func fdiv(a, b float64) float64 { return a / b } // keep compiler in the dark
const (
- Below1e23 = 99999999999999974834176;
- Above1e23 = 100000000000000008388608;
+ below1e23 = 99999999999999974834176;
+ above1e23 = 100000000000000008388608;
)
-var ftoatests = []FtoaTest {
- FtoaTest{ 1, 'e', 5, "1.00000e+00" },
- FtoaTest{ 1, 'f', 5, "1.00000" },
- FtoaTest{ 1, 'g', 5, "1" },
- FtoaTest{ 1, 'g', -1, "1" },
- FtoaTest{ 20, 'g', -1, "20" },
- FtoaTest{ 1234567.8, 'g', -1, "1.2345678e+06" },
- FtoaTest{ 200000, 'g', -1, "200000" },
- FtoaTest{ 2000000, 'g', -1, "2e+06" },
-
- FtoaTest{ 0, 'e', 5, "0.00000e+00" },
- FtoaTest{ 0, 'f', 5, "0.00000" },
- FtoaTest{ 0, 'g', 5, "0" },
- FtoaTest{ 0, 'g', -1, "0" },
-
- FtoaTest{ -1, 'e', 5, "-1.00000e+00" },
- FtoaTest{ -1, 'f', 5, "-1.00000" },
- FtoaTest{ -1, 'g', 5, "-1" },
- FtoaTest{ -1, 'g', -1, "-1" },
-
- FtoaTest{ 12, 'e', 5, "1.20000e+01" },
- FtoaTest{ 12, 'f', 5, "12.00000" },
- FtoaTest{ 12, 'g', 5, "12" },
- FtoaTest{ 12, 'g', -1, "12" },
-
- FtoaTest{ 123456700, 'e', 5, "1.23457e+08" },
- FtoaTest{ 123456700, 'f', 5, "123456700.00000" },
- FtoaTest{ 123456700, 'g', 5, "1.2346e+08" },
- FtoaTest{ 123456700, 'g', -1, "1.234567e+08" },
-
- FtoaTest{ 1.2345e6, 'e', 5, "1.23450e+06" },
- FtoaTest{ 1.2345e6, 'f', 5, "1234500.00000" },
- FtoaTest{ 1.2345e6, 'g', 5, "1.2345e+06" },
-
- FtoaTest{ 1e23, 'e', 17, "9.99999999999999916e+22" },
- FtoaTest{ 1e23, 'f', 17, "99999999999999991611392.00000000000000000" },
- FtoaTest{ 1e23, 'g', 17, "9.9999999999999992e+22" },
-
- FtoaTest{ 1e23, 'e', -1, "1e+23" },
- FtoaTest{ 1e23, 'f', -1, "100000000000000000000000" },
- FtoaTest{ 1e23, 'g', -1, "1e+23" },
-
- FtoaTest{ Below1e23, 'e', 17, "9.99999999999999748e+22" },
- FtoaTest{ Below1e23, 'f', 17, "99999999999999974834176.00000000000000000" },
- FtoaTest{ Below1e23, 'g', 17, "9.9999999999999975e+22" },
-
- FtoaTest{ Below1e23, 'e', -1, "9.999999999999997e+22" },
- FtoaTest{ Below1e23, 'f', -1, "99999999999999970000000" },
- FtoaTest{ Below1e23, 'g', -1, "9.999999999999997e+22" },
-
- FtoaTest{ Above1e23, 'e', 17, "1.00000000000000008e+23" },
- FtoaTest{ Above1e23, 'f', 17, "100000000000000008388608.00000000000000000" },
- FtoaTest{ Above1e23, 'g', 17, "1.0000000000000001e+23" },
-
- FtoaTest{ Above1e23, 'e', -1, "1.0000000000000001e+23" },
- FtoaTest{ Above1e23, 'f', -1, "100000000000000010000000" },
- FtoaTest{ Above1e23, 'g', -1, "1.0000000000000001e+23" },
-
- FtoaTest{ fdiv(5e-304, 1e20), 'g', -1, "5e-324" },
- FtoaTest{ fdiv(-5e-304, 1e20), 'g', -1, "-5e-324" },
-
- FtoaTest{ 32, 'g', -1, "32" },
- FtoaTest{ 32, 'g', 0, "3e+01" },
-
- FtoaTest{ 100, 'x', -1, "%x" },
-
- FtoaTest{ sys.NaN(), 'g', -1, "NaN" },
- FtoaTest{ -sys.NaN(), 'g', -1, "NaN" },
- FtoaTest{ sys.Inf(0), 'g', -1, "+Inf" },
- FtoaTest{ sys.Inf(-1), 'g', -1, "-Inf" },
- FtoaTest{ -sys.Inf(0), 'g', -1, "-Inf" },
-
- FtoaTest{ -1, 'b', -1, "-4503599627370496p-52" },
+var ftoatests = []ftoaTest {
+ ftoaTest{ 1, 'e', 5, "1.00000e+00" },
+ ftoaTest{ 1, 'f', 5, "1.00000" },
+ ftoaTest{ 1, 'g', 5, "1" },
+ ftoaTest{ 1, 'g', -1, "1" },
+ ftoaTest{ 20, 'g', -1, "20" },
+ ftoaTest{ 1234567.8, 'g', -1, "1.2345678e+06" },
+ ftoaTest{ 200000, 'g', -1, "200000" },
+ ftoaTest{ 2000000, 'g', -1, "2e+06" },
+
+ ftoaTest{ 0, 'e', 5, "0.00000e+00" },
+ ftoaTest{ 0, 'f', 5, "0.00000" },
+ ftoaTest{ 0, 'g', 5, "0" },
+ ftoaTest{ 0, 'g', -1, "0" },
+
+ ftoaTest{ -1, 'e', 5, "-1.00000e+00" },
+ ftoaTest{ -1, 'f', 5, "-1.00000" },
+ ftoaTest{ -1, 'g', 5, "-1" },
+ ftoaTest{ -1, 'g', -1, "-1" },
+
+ ftoaTest{ 12, 'e', 5, "1.20000e+01" },
+ ftoaTest{ 12, 'f', 5, "12.00000" },
+ ftoaTest{ 12, 'g', 5, "12" },
+ ftoaTest{ 12, 'g', -1, "12" },
+
+ ftoaTest{ 123456700, 'e', 5, "1.23457e+08" },
+ ftoaTest{ 123456700, 'f', 5, "123456700.00000" },
+ ftoaTest{ 123456700, 'g', 5, "1.2346e+08" },
+ ftoaTest{ 123456700, 'g', -1, "1.234567e+08" },
+
+ ftoaTest{ 1.2345e6, 'e', 5, "1.23450e+06" },
+ ftoaTest{ 1.2345e6, 'f', 5, "1234500.00000" },
+ ftoaTest{ 1.2345e6, 'g', 5, "1.2345e+06" },
+
+ ftoaTest{ 1e23, 'e', 17, "9.99999999999999916e+22" },
+ ftoaTest{ 1e23, 'f', 17, "99999999999999991611392.00000000000000000" },
+ ftoaTest{ 1e23, 'g', 17, "9.9999999999999992e+22" },
+
+ ftoaTest{ 1e23, 'e', -1, "1e+23" },
+ ftoaTest{ 1e23, 'f', -1, "100000000000000000000000" },
+ ftoaTest{ 1e23, 'g', -1, "1e+23" },
+
+ ftoaTest{ below1e23, 'e', 17, "9.99999999999999748e+22" },
+ ftoaTest{ below1e23, 'f', 17, "99999999999999974834176.00000000000000000" },
+ ftoaTest{ below1e23, 'g', 17, "9.9999999999999975e+22" },
+
+ ftoaTest{ below1e23, 'e', -1, "9.999999999999997e+22" },
+ ftoaTest{ below1e23, 'f', -1, "99999999999999970000000" },
+ ftoaTest{ below1e23, 'g', -1, "9.999999999999997e+22" },
+
+ ftoaTest{ above1e23, 'e', 17, "1.00000000000000008e+23" },
+ ftoaTest{ above1e23, 'f', 17, "100000000000000008388608.00000000000000000" },
+ ftoaTest{ above1e23, 'g', 17, "1.0000000000000001e+23" },
+
+ ftoaTest{ above1e23, 'e', -1, "1.0000000000000001e+23" },
+ ftoaTest{ above1e23, 'f', -1, "100000000000000010000000" },
+ ftoaTest{ above1e23, 'g', -1, "1.0000000000000001e+23" },
+
+ ftoaTest{ fdiv(5e-304, 1e20), 'g', -1, "5e-324" },
+ ftoaTest{ fdiv(-5e-304, 1e20), 'g', -1, "-5e-324" },
+
+ ftoaTest{ 32, 'g', -1, "32" },
+ ftoaTest{ 32, 'g', 0, "3e+01" },
+
+ ftoaTest{ 100, 'x', -1, "%x" },
+
+ ftoaTest{ sys.NaN(), 'g', -1, "NaN" },
+ ftoaTest{ -sys.NaN(), 'g', -1, "NaN" },
+ ftoaTest{ sys.Inf(0), 'g', -1, "+Inf" },
+ ftoaTest{ sys.Inf(-1), 'g', -1, "-Inf" },
+ ftoaTest{ -sys.Inf(0), 'g', -1, "-Inf" },
+
+ ftoaTest{ -1, 'b', -1, "-4503599627370496p-52" },
}
export func TestFtoa(t *testing.T) {
}
for i := 0; i < len(ftoatests); i++ {
test := &ftoatests[i];
- s := strconv.ftoa64(test.f, test.fmt, test.prec);
+ s := strconv.Ftoa64(test.f, test.fmt, test.prec);
if s != test.s {
t.Error("test", test.f, string(test.fmt), test.prec, "want", test.s, "got", s);
}
if float64(float32(test.f)) == test.f && test.fmt != 'b' {
- s := strconv.ftoa32(float32(test.f), test.fmt, test.prec);
+ s := strconv.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);
}
package strconv
-export func itoa64(i int64) string {
+export func Itoa64(i int64) string {
if i == 0 {
return "0"
}
}
return string(b[bp:len(b)])
- //return string((&b)[bp:len(b)])
}
-export func itoa(i int) string {
- return itoa64(int64(i));
+export func Itoa(i int) string {
+ return Itoa64(int64(i));
}
"testing";
)
-type Itoa64Test struct {
+type itoa64Test struct {
in int64;
out string;
}
-var itoa64tests = []Itoa64Test {
- Itoa64Test{ 0, "0" },
- Itoa64Test{ 1, "1" },
- Itoa64Test{ -1, "-1" },
- Itoa64Test{ 12345678, "12345678" },
- Itoa64Test{ -987654321, "-987654321" },
- Itoa64Test{ 1<<31-1, "2147483647" },
- Itoa64Test{ -1<<31+1, "-2147483647" },
- Itoa64Test{ 1<<31, "2147483648" },
- Itoa64Test{ -1<<31, "-2147483648" },
- Itoa64Test{ 1<<31+1, "2147483649" },
- Itoa64Test{ -1<<31-1, "-2147483649" },
- Itoa64Test{ 1<<32-1, "4294967295" },
- Itoa64Test{ -1<<32+1, "-4294967295" },
- Itoa64Test{ 1<<32, "4294967296" },
- Itoa64Test{ -1<<32, "-4294967296" },
- Itoa64Test{ 1<<32+1, "4294967297" },
- Itoa64Test{ -1<<32-1, "-4294967297" },
- Itoa64Test{ 1<<50, "1125899906842624" },
- Itoa64Test{ 1<<63-1, "9223372036854775807" },
- Itoa64Test{ -1<<63+1, "-9223372036854775807" },
- Itoa64Test{ -1<<63, "-9223372036854775808" },
+var itoa64tests = []itoa64Test {
+ itoa64Test{ 0, "0" },
+ itoa64Test{ 1, "1" },
+ itoa64Test{ -1, "-1" },
+ itoa64Test{ 12345678, "12345678" },
+ itoa64Test{ -987654321, "-987654321" },
+ itoa64Test{ 1<<31-1, "2147483647" },
+ itoa64Test{ -1<<31+1, "-2147483647" },
+ itoa64Test{ 1<<31, "2147483648" },
+ itoa64Test{ -1<<31, "-2147483648" },
+ itoa64Test{ 1<<31+1, "2147483649" },
+ itoa64Test{ -1<<31-1, "-2147483649" },
+ itoa64Test{ 1<<32-1, "4294967295" },
+ itoa64Test{ -1<<32+1, "-4294967295" },
+ itoa64Test{ 1<<32, "4294967296" },
+ itoa64Test{ -1<<32, "-4294967296" },
+ itoa64Test{ 1<<32+1, "4294967297" },
+ itoa64Test{ -1<<32-1, "-4294967297" },
+ itoa64Test{ 1<<50, "1125899906842624" },
+ itoa64Test{ 1<<63-1, "9223372036854775807" },
+ itoa64Test{ -1<<63+1, "-9223372036854775807" },
+ itoa64Test{ -1<<63, "-9223372036854775808" },
}
export func TestItoa(t *testing.T) {
for i := 0; i < len(itoa64tests); i++ {
test := itoa64tests[i];
- s := strconv.itoa64(test.in);
+ s := strconv.Itoa64(test.in);
if s != test.out {
- t.Error("strconv.itoa64(%v) = %v want %v\n",
+ t.Error("strconv.Itoa64(%v) = %v want %v\n",
test.in, s, test.out);
}
if int64(int(test.in)) == test.in {
- s := strconv.itoa(int(test.in));
+ s := strconv.Itoa(int(test.in));
if s != test.out {
- t.Error("strconv.itoa(%v) = %v want %v\n",
+ t.Error("strconv.Itoa(%v) = %v want %v\n",
test.in, s, test.out);
}
}
}
// TODO: Use once there is a strconv.uitoa
-type Uitoa64Test struct {
+type uitoa64Test struct {
in uint64;
out string;
}
// TODO: should be able to call this atoui64tests.
-var uitoa64tests = []Uitoa64Test {
- Uitoa64Test{ 1<<63-1, "9223372036854775807" },
- Uitoa64Test{ 1<<63, "9223372036854775808" },
- Uitoa64Test{ 1<<63+1, "9223372036854775809" },
- Uitoa64Test{ 1<<64-2, "18446744073709551614" },
- Uitoa64Test{ 1<<64-1, "18446744073709551615" },
+var uitoa64tests = []uitoa64Test {
+ uitoa64Test{ 1<<63-1, "9223372036854775807" },
+ uitoa64Test{ 1<<63, "9223372036854775808" },
+ uitoa64Test{ 1<<63+1, "9223372036854775809" },
+ uitoa64Test{ 1<<64-2, "18446744073709551614" },
+ uitoa64Test{ 1<<64-1, "18446744073709551615" },
}
"testing";
)
-type QuoteTest struct {
+type quoteTest struct {
in string;
out string;
}
-var quotetests = []QuoteTest {
- QuoteTest{ "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"` },
- QuoteTest{ "\\", `"\\"` },
- QuoteTest{ "abc\xffdef", `"abc\xffdef"` },
- QuoteTest{ "\u263a", `"\u263a"` },
- QuoteTest{ "\U0010ffff", `"\U0010ffff"` },
- QuoteTest{ "\x04", `"\x04"` },
+var quotetests = []quoteTest {
+ quoteTest{ "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"` },
+ quoteTest{ "\\", `"\\"` },
+ quoteTest{ "abc\xffdef", `"abc\xffdef"` },
+ quoteTest{ "\u263a", `"\u263a"` },
+ quoteTest{ "\U0010ffff", `"\U0010ffff"` },
+ quoteTest{ "\x04", `"\x04"` },
}
export func TestQuote(t *testing.T) {
}
}
-type CanBackquoteTest struct {
+type canBackquoteTest struct {
in string;
out bool;
}
-var canbackquotetests = []CanBackquoteTest {
- CanBackquoteTest{ "`", false },
- CanBackquoteTest{ string(0), false },
- CanBackquoteTest{ string(1), false },
- CanBackquoteTest{ string(2), false },
- CanBackquoteTest{ string(3), false },
- CanBackquoteTest{ string(4), false },
- CanBackquoteTest{ string(5), false },
- CanBackquoteTest{ string(6), false },
- CanBackquoteTest{ string(7), false },
- CanBackquoteTest{ string(8), false },
- CanBackquoteTest{ string(9), false },
- CanBackquoteTest{ string(10), false },
- CanBackquoteTest{ string(11), false },
- CanBackquoteTest{ string(12), false },
- CanBackquoteTest{ string(13), false },
- CanBackquoteTest{ string(14), false },
- CanBackquoteTest{ string(15), false },
- CanBackquoteTest{ string(16), false },
- CanBackquoteTest{ string(17), false },
- CanBackquoteTest{ string(18), false },
- CanBackquoteTest{ string(19), false },
- CanBackquoteTest{ string(20), false },
- CanBackquoteTest{ string(21), false },
- CanBackquoteTest{ string(22), false },
- CanBackquoteTest{ string(23), false },
- CanBackquoteTest{ string(24), false },
- CanBackquoteTest{ string(25), false },
- CanBackquoteTest{ string(26), false },
- CanBackquoteTest{ string(27), false },
- CanBackquoteTest{ string(28), false },
- CanBackquoteTest{ string(29), false },
- CanBackquoteTest{ string(30), false },
- CanBackquoteTest{ string(31), false },
- CanBackquoteTest{ `' !"#$%&'()*+,-./:;<=>?@[\]^_{|}~`, true },
- CanBackquoteTest{ `0123456789`, true },
- CanBackquoteTest{ `ABCDEFGHIJKLMNOPQRSTUVWXYZ`, true },
- CanBackquoteTest{ `abcdefghijklmnopqrstuvwxyz`, true },
- CanBackquoteTest{ `☺`, true },
+var canbackquotetests = []canBackquoteTest {
+ canBackquoteTest{ "`", false },
+ canBackquoteTest{ string(0), false },
+ canBackquoteTest{ string(1), false },
+ canBackquoteTest{ string(2), false },
+ canBackquoteTest{ string(3), false },
+ canBackquoteTest{ string(4), false },
+ canBackquoteTest{ string(5), false },
+ canBackquoteTest{ string(6), false },
+ canBackquoteTest{ string(7), false },
+ canBackquoteTest{ string(8), false },
+ canBackquoteTest{ string(9), false },
+ canBackquoteTest{ string(10), false },
+ canBackquoteTest{ string(11), false },
+ canBackquoteTest{ string(12), false },
+ canBackquoteTest{ string(13), false },
+ canBackquoteTest{ string(14), false },
+ canBackquoteTest{ string(15), false },
+ canBackquoteTest{ string(16), false },
+ canBackquoteTest{ string(17), false },
+ canBackquoteTest{ string(18), false },
+ canBackquoteTest{ string(19), false },
+ canBackquoteTest{ string(20), false },
+ canBackquoteTest{ string(21), false },
+ canBackquoteTest{ string(22), false },
+ canBackquoteTest{ string(23), false },
+ canBackquoteTest{ string(24), false },
+ canBackquoteTest{ string(25), false },
+ canBackquoteTest{ string(26), false },
+ canBackquoteTest{ string(27), false },
+ canBackquoteTest{ string(28), false },
+ canBackquoteTest{ string(29), false },
+ canBackquoteTest{ string(30), false },
+ canBackquoteTest{ string(31), false },
+ canBackquoteTest{ `' !"#$%&'()*+,-./:;<=>?@[\]^_{|}~`, true },
+ canBackquoteTest{ `0123456789`, true },
+ canBackquoteTest{ `ABCDEFGHIJKLMNOPQRSTUVWXYZ`, true },
+ canBackquoteTest{ `abcdefghijklmnopqrstuvwxyz`, true },
+ canBackquoteTest{ `☺`, true },
}
export func TestCanBackquote(t *testing.T) {
var n = 10000;
if sys.argc() > 1 {
var err *os.Error;
- n, err = strconv.atoi(sys.argv(1));
+ n, err = strconv.Atoi(sys.argv(1));
if err != nil {
print("bad arg\n");
sys.exit(1);
ok := true;
for i := 0; i < len(tests); i++ {
t := tests[i];
- v := strconv.ftoa64(t.f, 'g', -1);
+ v := strconv.Ftoa64(t.f, 'g', -1);
if v != t.out {
println("Bad float64 const:", t.in, "want", t.out, "got", v);
- x, err := strconv.atof64(t.out);
+ x, err := strconv.Atof64(t.out);
if err != nil {
- panicln("bug120: strconv.atof64", t.out);
+ panicln("bug120: strconv.Atof64", t.out);
}
- println("\twant exact:", strconv.ftoa64(x, 'g', 1000));
- println("\tgot exact: ", strconv.ftoa64(t.f, 'g', 1000));
+ println("\twant exact:", strconv.Ftoa64(x, 'g', 1000));
+ println("\tgot exact: ", strconv.Ftoa64(t.f, 'g', 1000));
ok = false;
}
}
}
func atoi(s string) int {
- i, xx1 := strconv.atoi(s);
+ i, xx1 := strconv.Atoi(s);
return i
}
var apT [2*count]*T;
for i := 0; i < count; i++ {
- s := strconv.itoa(i);
- s10 := strconv.itoa(i*10);
+ s := strconv.Itoa(i);
+ s10 := strconv.Itoa(i*10);
f := float(i);
t := T{int64(i),f};
apT[i] = new(T);
// test construction directly
for i := 0; i < count; i++ {
- s := strconv.itoa(i);
- s10 := strconv.itoa(i*10);
+ s := strconv.Itoa(i);
+ s10 := strconv.Itoa(i*10);
f := float(i);
t := T{int64(i), f};
// BUG m := M(i, i+1);
// test existence with tuple check
// failed lookups yield a false value for the boolean.
for i := 0; i < count; i++ {
- s := strconv.itoa(i);
+ s := strconv.Itoa(i);
f := float(i);
t := T{int64(i), f};
{
// test nonexistence with tuple check
// failed lookups yield a false value for the boolean.
for i := count; i < 2*count; i++ {
- s := strconv.itoa(i);
+ s := strconv.Itoa(i);
f := float(i);
t := T{int64(i),f};
{
// tests for structured map element updates
for i := 0; i < count; i++ {
- s := strconv.itoa(i);
+ s := strconv.Itoa(i);
mspa[s][i % 2] = "deleted";
if mspa[s][i % 2] != "deleted" {
fmt.Printf("update mspa[%s][%d] = %s\n", s, i %2, mspa[s][i % 2]);