// float
func (x *Fmt) f(a float) *Fmt {
- if strconv.floatsize == 32 {
+ if strconv.FloatSize == 32 {
return x.Fmt_f32(float32(a))
}
return x.Fmt_f64(float64(a))
}
func (x *Fmt) e(a float) *Fmt {
- if strconv.floatsize == 32 {
+ if strconv.FloatSize == 32 {
return x.Fmt_e32(float32(a))
}
return x.Fmt_e64(float64(a))
}
func (x *Fmt) g(a float) *Fmt {
- if strconv.floatsize == 32 {
+ if strconv.FloatSize == 32 {
return x.Fmt_g32(float32(a))
}
return x.Fmt_g64(float64(a))
}
func (x *Fmt) fb(a float) *Fmt {
- if strconv.floatsize == 32 {
+ if strconv.FloatSize == 32 {
return x.Fmt_fb32(float32(a))
}
return x.Fmt_fb64(float64(a))
floor.$O\
fmod.$O\
hypot.$O\
- log.$O\
pow10.$O\
sin.$O\
sqrt.$O\
tan.$O\
+ const.$O\
O2=\
asin.$O\
atan2.$O\
- pow.$O\
+ log.$O\
sinh.$O\
O3=\
+ pow.$O\
tanh.$O\
math.a: a1 a2 a3
a1: $(O1)
- $(AR) grc math.a atan.$O exp.$O fabs.$O floor.$O fmod.$O hypot.$O log.$O pow10.$O sin.$O sqrt.$O tan.$O
+ $(AR) grc math.a atan.$O exp.$O fabs.$O floor.$O fmod.$O hypot.$O pow10.$O sin.$O sqrt.$O tan.$O const.$O
rm -f $(O1)
a2: $(O2)
- $(AR) grc math.a asin.$O atan2.$O pow.$O sinh.$O
+ $(AR) grc math.a asin.$O atan2.$O log.$O sinh.$O
rm -f $(O2)
a3: $(O3)
- $(AR) grc math.a tanh.$O
+ $(AR) grc math.a pow.$O tanh.$O
rm -f $(O3)
newpkg: clean
const
(
- p4 = .161536412982230228262e2;
- p3 = .26842548195503973794141e3;
- p2 = .11530293515404850115428136e4;
- p1 = .178040631643319697105464587e4;
- p0 = .89678597403663861959987488e3;
- q4 = .5895697050844462222791e2;
- q3 = .536265374031215315104235e3;
- q2 = .16667838148816337184521798e4;
- q1 = .207933497444540981287275926e4;
- q0 = .89678597403663861962481162e3;
- pio2 = .15707963267948966192313216e1;
- pio4 = .7853981633974483096156608e0;
- sq2p1 = .2414213562373095048802e1; // sqrt(2)+1
- sq2m1 = .414213562373095048802e0; // sqrt(2)-1
+ ap4 = .161536412982230228262e2;
+ ap3 = .26842548195503973794141e3;
+ ap2 = .11530293515404850115428136e4;
+ ap1 = .178040631643319697105464587e4;
+ ap0 = .89678597403663861959987488e3;
+ aq4 = .5895697050844462222791e2;
+ aq3 = .536265374031215315104235e3;
+ aq2 = .16667838148816337184521798e4;
+ aq1 = .207933497444540981287275926e4;
+ aq0 = .89678597403663861962481162e3;
+ apio2 = .15707963267948966192313216e1;
+ apio4 = .7853981633974483096156608e0;
+ asq2p1 = .2414213562373095048802e1; // sqrt(2)+1
+ asq2m1 = .414213562373095048802e0; // sqrt(2)-1
)
/*
* xatan evaluates a series valid in the
* range [-0.414...,+0.414...]. (tan(pi/8))
*/
-func Xatan(arg float64) float64 {
+func xatan(arg float64) float64 {
argsq := arg*arg;
- value := ((((p4*argsq + p3)*argsq + p2)*argsq + p1)*argsq + p0);
- value = value/(((((argsq + q4)*argsq + q3)*argsq + q2)*argsq + q1)*argsq + q0);
+ value := ((((ap4*argsq + ap3)*argsq + ap2)*argsq + ap1)*argsq + ap0);
+ value = value/(((((argsq + aq4)*argsq + aq3)*argsq + aq2)*argsq + aq1)*argsq + aq0);
return value*arg;
}
* satan reduces its argument (known to be positive)
* to the range [0,0.414...] and calls xatan.
*/
-func Satan(arg float64) float64 {
- if arg < sq2m1 {
- return Xatan(arg);
+func satan(arg float64) float64 {
+ if arg < asq2m1 {
+ return xatan(arg);
}
- if arg > sq2p1 {
- return pio2 - Xatan(1/arg);
+ if arg > asq2p1 {
+ return apio2 - xatan(1/arg);
}
- return pio4 + Xatan((arg-1)/(arg+1));
+ return apio4 + xatan((arg-1)/(arg+1));
}
/*
*/
export func Atan(arg float64) float64 {
if arg > 0 {
- return Satan(arg);
+ return satan(arg);
}
- return -Satan(-arg);
+ return -satan(-arg);
}
--- /dev/null
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package math
+
+export const (
+ Sqrt2 = 1.41421356237309504880168872420969808;
+)
package math
+import "math"
+
// The original C code, the long comment, and the constants
// below are from FreeBSD's /usr/src/lib/msun/src/e_log.c
// and came with this notice. The go code is a simpler
// of this polynomial approximation is bounded by 2**-58.45. In
// other words,
// 2 4 6 8 10 12 14
-// R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s +Lg6*s +Lg7*s
-// (the values of Lg1 to Lg7 are listed in the program)
+// R(z) ~ lg1*s +lg2*s +lg3*s +lg4*s +lg5*s +lg6*s +lg7*s
+// (the values of lg1 to lg7 are listed in the program)
// and
// | 2 14 | -58.45
-// | Lg1*s +...+Lg7*s - R(z) | <= 2
+// | lg1*s +...+lg7*s - R(z) | <= 2
// | |
// Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
// In order to guarantee error in log below 1ulp, we compute log
// to produce the hexadecimal values shown.
const (
- Ln2Hi = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */
- Ln2Lo = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */
- Lg1 = 6.666666666666735130e-01; /* 3FE55555 55555593 */
- Lg2 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */
- Lg3 = 2.857142874366239149e-01; /* 3FD24924 94229359 */
- Lg4 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */
- Lg5 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
- Lg6 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
- Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
-
- Two54 = 1<<54; // 2^54
- TwoM20 = 1.0/(1<<20); // 2^-20
- TwoM1022 = 2.2250738585072014e-308; // 2^-1022
- Sqrt2 = 1.41421356237309504880168872420969808;
+ ln2Hi = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */
+ ln2Lo = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */
+ lg1 = 6.666666666666735130e-01; /* 3FE55555 55555593 */
+ lg2 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */
+ lg3 = 2.857142874366239149e-01; /* 3FD24924 94229359 */
+ lg4 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */
+ lg5 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
+ lg6 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
+ lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
)
export func Log(x float64) float64 {
s := f/(2+f);
s2 := s*s;
s4 := s2*s2;
- t1 := s2*(Lg1 + s4*(Lg3 + s4*(Lg5 + s4*Lg7)));
- t2 := s4*(Lg2 + s4*(Lg4 + s4*Lg6));
+ t1 := s2*(lg1 + s4*(lg3 + s4*(lg5 + s4*lg7)));
+ t2 := s4*(lg2 + s4*(lg4 + s4*lg6));
R := t1 + t2;
hfsq := 0.5*f*f;
- return k*Ln2Hi - ((hfsq-(s*(hfsq+R)+k*Ln2Lo)) - f);
+ return k*ln2Hi - ((hfsq-(s*(hfsq+R)+k*ln2Lo)) - f);
}
const
*/
const
(
- p0 = .1357884097877375669092680e8;
- p1 = -.4942908100902844161158627e7;
- p2 = .4401030535375266501944918e6;
- p3 = -.1384727249982452873054457e5;
- p4 = .1459688406665768722226959e3;
- q0 = .8644558652922534429915149e7;
- q1 = .4081792252343299749395779e6;
- q2 = .9463096101538208180571257e4;
- q3 = .1326534908786136358911494e3;
+ sp0 = .1357884097877375669092680e8;
+ sp1 = -.4942908100902844161158627e7;
+ sp2 = .4401030535375266501944918e6;
+ sp3 = -.1384727249982452873054457e5;
+ sp4 = .1459688406665768722226959e3;
+ sq0 = .8644558652922534429915149e7;
+ sq1 = .4081792252343299749395779e6;
+ sq2 = .9463096101538208180571257e4;
+ sq3 = .1326534908786136358911494e3;
- piu2 = .6366197723675813430755350e0; // 2/pi
+ spiu2 = .6366197723675813430755350e0; // 2/pi
)
-func Sinus(arg float64, quad int) float64 {
+func sinus(arg float64, quad int) float64 {
x := arg;
if(x < 0) {
x = -x;
quad = quad+2;
}
- x = x * piu2; /* underflow? */
+ x = x * spiu2; /* underflow? */
var y float64;
if x > 32764 {
var e float64;
e, y = sys.modf(x);
e = e + float64(quad);
- temp1, f := sys.modf(0.25*e);
+ temsp1, f := sys.modf(0.25*e);
quad = int(e - 4*f);
} else {
k := int32(x);
}
ysq := y*y;
- temp1 := ((((p4*ysq+p3)*ysq+p2)*ysq+p1)*ysq+p0)*y;
- temp2 := ((((ysq+q3)*ysq+q2)*ysq+q1)*ysq+q0);
- return temp1/temp2;
+ temsp1 := ((((sp4*ysq+sp3)*ysq+sp2)*ysq+sp1)*ysq+sp0)*y;
+ temsp2 := ((((ysq+sq3)*ysq+sq2)*ysq+sq1)*ysq+sq0);
+ return temsp1/temsp2;
}
export func Cos(arg float64) float64 {
if arg < 0 {
arg = -arg;
}
- return Sinus(arg, 1);
+ return sinus(arg, 1);
}
export func Sin(arg float64) float64 {
- return Sinus(arg, 0);
+ return sinus(arg, 0);
}
const
(
- p0 = -0.6307673640497716991184787251e+6;
- p1 = -0.8991272022039509355398013511e+5;
- p2 = -0.2894211355989563807284660366e+4;
- p3 = -0.2630563213397497062819489e+2;
- q0 = -0.6307673640497716991212077277e+6;
- q1 = 0.1521517378790019070696485176e+5;
- q2 = -0.173678953558233699533450911e+3;
+ shp0 = -0.6307673640497716991184787251e+6;
+ shp1 = -0.8991272022039509355398013511e+5;
+ shp2 = -0.2894211355989563807284660366e+4;
+ shp3 = -0.2630563213397497062819489e+2;
+ shq0 = -0.6307673640497716991212077277e+6;
+ shq1 = 0.1521517378790019070696485176e+5;
+ shq2 = -0.173678953558233699533450911e+3;
)
export func Sinh(arg float64) float64 {
default:
argsq := arg*arg;
- temp = (((p3*argsq+p2)*argsq+p1)*argsq+p0)*arg;
- temp = temp/(((argsq+q2)*argsq+q1)*argsq+q0);
+ temp = (((shp3*argsq+shp2)*argsq+shp1)*argsq+shp0)*arg;
+ temp = temp/(((argsq+shq2)*argsq+shq1)*argsq+shq0);
}
if sign {
case Uint64Kind:
return integer(int64(val.(Uint64Value).Get()));
case FloatKind:
- if strconv.floatsize == 32 {
+ if strconv.FloatSize == 32 {
return strconv.ftoa32(float32(val.(FloatValue).Get()), 'g', -1);
} else {
return strconv.ftoa64(float64(val.(FloatValue).Get()), 'g', -1);
}
// Fields and methods common to all types
-type Common struct {
+type commonType struct {
kind int;
str string;
name string;
size int;
}
-func (c *Common) Kind() int {
+func (c *commonType) Kind() int {
return c.kind
}
-func (c *Common) Name() string {
+func (c *commonType) Name() string {
return c.name
}
-func (c *Common) String() string {
+func (c *commonType) String() string {
// If there is a name, show that instead of its expansion.
// This is important for reflection: a named type
// might have methods that the unnamed type does not.
return c.str
}
-func (c *Common) Size() int {
+func (c *commonType) Size() int {
return c.size
}
// -- Basic
type BasicType struct {
- Common
+ commonType
}
func NewBasicType(name string, kind int, size int) Type {
- return &BasicType{ Common{kind, name, name, size} }
+ return &BasicType{ commonType{kind, name, name, size} }
}
// Prebuilt basic types
}
type PtrTypeStruct struct {
- Common;
+ commonType;
sub *StubType;
}
func NewPtrTypeStruct(name, typestring string, sub *StubType) *PtrTypeStruct {
- return &PtrTypeStruct{ Common{PtrKind, typestring, name, ptrsize}, sub}
+ return &PtrTypeStruct{ commonType{PtrKind, typestring, name, ptrsize}, sub}
}
func (t *PtrTypeStruct) Sub() Type {
}
type ArrayTypeStruct struct {
- Common;
+ commonType;
elem *StubType;
open bool; // otherwise fixed size
len int;
}
func NewArrayTypeStruct(name, typestring string, open bool, len int, elem *StubType) *ArrayTypeStruct {
- return &ArrayTypeStruct{ Common{ArrayKind, typestring, name, 0}, elem, open, len}
+ return &ArrayTypeStruct{ commonType{ArrayKind, typestring, name, 0}, elem, open, len}
}
func (t *ArrayTypeStruct) Size() int {
}
type MapTypeStruct struct {
- Common;
+ commonType;
key *StubType;
elem *StubType;
}
func NewMapTypeStruct(name, typestring string, key, elem *StubType) *MapTypeStruct {
- return &MapTypeStruct{ Common{MapKind, typestring, name, ptrsize}, key, elem}
+ return &MapTypeStruct{ commonType{MapKind, typestring, name, ptrsize}, key, elem}
}
func (t *MapTypeStruct) Key() Type {
)
type ChanTypeStruct struct {
- Common;
+ commonType;
elem *StubType;
dir int;
}
func NewChanTypeStruct(name, typestring string, dir int, elem *StubType) *ChanTypeStruct {
- return &ChanTypeStruct{ Common{ChanKind, typestring, name, ptrsize}, elem, dir}
+ return &ChanTypeStruct{ commonType{ChanKind, typestring, name, ptrsize}, elem, dir}
}
func (t *ChanTypeStruct) Dir() int {
}
type StructTypeStruct struct {
- Common;
+ commonType;
field []Field;
}
func NewStructTypeStruct(name, typestring string, field []Field) *StructTypeStruct {
- return &StructTypeStruct{ Common{StructKind, typestring, name, 0}, field}
+ return &StructTypeStruct{ commonType{StructKind, typestring, name, 0}, field}
}
// TODO: not portable; depends on 6g
}
type InterfaceTypeStruct struct {
- Common;
+ commonType;
field []Field;
}
func NewInterfaceTypeStruct(name, typestring string, field []Field) *InterfaceTypeStruct {
- return &InterfaceTypeStruct{ Common{InterfaceKind, typestring, name, interfacesize}, field }
+ return &InterfaceTypeStruct{ commonType{InterfaceKind, typestring, name, interfacesize}, field }
}
func (t *InterfaceTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) {
}
type FuncTypeStruct struct {
- Common;
+ commonType;
in *StructTypeStruct;
out *StructTypeStruct;
}
func NewFuncTypeStruct(name, typestring string, in, out *StructTypeStruct) *FuncTypeStruct {
- return &FuncTypeStruct{ Common{FuncKind, typestring, name, 0}, in, out }
+ return &FuncTypeStruct{ commonType{FuncKind, typestring, name, 0}, in, out }
}
func (t *FuncTypeStruct) Size() int {
Interface() interface {};
}
-// Common fields and functionality for all values
+// commonValue fields and functionality for all values
-type Common struct {
+type commonValue struct {
kind int;
typ Type;
addr Addr;
}
-func (c *Common) Kind() int {
+func (c *commonValue) Kind() int {
return c.kind
}
-func (c *Common) Type() Type {
+func (c *commonValue) Type() Type {
return c.typ
}
-func (c *Common) Addr() Addr {
+func (c *commonValue) Addr() Addr {
return c.addr
}
-func (c *Common) Interface() interface {} {
+func (c *commonValue) Interface() interface {} {
var i interface {};
if c.typ.Size() > 8 { // TODO(rsc): how do we know it is 8?
i = sys.unreflect(c.addr.(uintptr).(uint64), c.typ.String(), true);
}
type MissingValueStruct struct {
- Common
+ commonValue
}
func MissingCreator(typ Type, addr Addr) Value {
- return &MissingValueStruct{ Common{MissingKind, typ, addr} }
+ return &MissingValueStruct{ commonValue{MissingKind, typ, addr} }
}
// -- Int
}
type IntValueStruct struct {
- Common
+ commonValue
}
func IntCreator(typ Type, addr Addr) Value {
- return &IntValueStruct{ Common{IntKind, typ, addr} }
+ return &IntValueStruct{ commonValue{IntKind, typ, addr} }
}
func (v *IntValueStruct) Get() int {
}
type Int8ValueStruct struct {
- Common
+ commonValue
}
func Int8Creator(typ Type, addr Addr) Value {
- return &Int8ValueStruct{ Common{Int8Kind, typ, addr} }
+ return &Int8ValueStruct{ commonValue{Int8Kind, typ, addr} }
}
func (v *Int8ValueStruct) Get() int8 {
}
type Int16ValueStruct struct {
- Common
+ commonValue
}
func Int16Creator(typ Type, addr Addr) Value {
- return &Int16ValueStruct{ Common{Int16Kind, typ, addr} }
+ return &Int16ValueStruct{ commonValue{Int16Kind, typ, addr} }
}
func (v *Int16ValueStruct) Get() int16 {
}
type Int32ValueStruct struct {
- Common
+ commonValue
}
func Int32Creator(typ Type, addr Addr) Value {
- return &Int32ValueStruct{ Common{Int32Kind, typ, addr} }
+ return &Int32ValueStruct{ commonValue{Int32Kind, typ, addr} }
}
func (v *Int32ValueStruct) Get() int32 {
}
type Int64ValueStruct struct {
- Common
+ commonValue
}
func Int64Creator(typ Type, addr Addr) Value {
- return &Int64ValueStruct{ Common{Int64Kind, typ, addr} }
+ return &Int64ValueStruct{ commonValue{Int64Kind, typ, addr} }
}
func (v *Int64ValueStruct) Get() int64 {
}
type UintValueStruct struct {
- Common
+ commonValue
}
func UintCreator(typ Type, addr Addr) Value {
- return &UintValueStruct{ Common{UintKind, typ, addr} }
+ return &UintValueStruct{ commonValue{UintKind, typ, addr} }
}
func (v *UintValueStruct) Get() uint {
}
type Uint8ValueStruct struct {
- Common
+ commonValue
}
func Uint8Creator(typ Type, addr Addr) Value {
- return &Uint8ValueStruct{ Common{Uint8Kind, typ, addr} }
+ return &Uint8ValueStruct{ commonValue{Uint8Kind, typ, addr} }
}
func (v *Uint8ValueStruct) Get() uint8 {
}
type Uint16ValueStruct struct {
- Common
+ commonValue
}
func Uint16Creator(typ Type, addr Addr) Value {
- return &Uint16ValueStruct{ Common{Uint16Kind, typ, addr} }
+ return &Uint16ValueStruct{ commonValue{Uint16Kind, typ, addr} }
}
func (v *Uint16ValueStruct) Get() uint16 {
}
type Uint32ValueStruct struct {
- Common
+ commonValue
}
func Uint32Creator(typ Type, addr Addr) Value {
- return &Uint32ValueStruct{ Common{Uint32Kind, typ, addr} }
+ return &Uint32ValueStruct{ commonValue{Uint32Kind, typ, addr} }
}
func (v *Uint32ValueStruct) Get() uint32 {
}
type Uint64ValueStruct struct {
- Common
+ commonValue
}
func Uint64Creator(typ Type, addr Addr) Value {
- return &Uint64ValueStruct{ Common{Uint64Kind, typ, addr} }
+ return &Uint64ValueStruct{ commonValue{Uint64Kind, typ, addr} }
}
func (v *Uint64ValueStruct) Get() uint64 {
}
type UintptrValueStruct struct {
- Common
+ commonValue
}
func UintptrCreator(typ Type, addr Addr) Value {
- return &UintptrValueStruct{ Common{UintptrKind, typ, addr} }
+ return &UintptrValueStruct{ commonValue{UintptrKind, typ, addr} }
}
func (v *UintptrValueStruct) Get() uintptr {
}
type FloatValueStruct struct {
- Common
+ commonValue
}
func FloatCreator(typ Type, addr Addr) Value {
- return &FloatValueStruct{ Common{FloatKind, typ, addr} }
+ return &FloatValueStruct{ commonValue{FloatKind, typ, addr} }
}
func (v *FloatValueStruct) Get() float {
}
type Float32ValueStruct struct {
- Common
+ commonValue
}
func Float32Creator(typ Type, addr Addr) Value {
- return &Float32ValueStruct{ Common{Float32Kind, typ, addr} }
+ return &Float32ValueStruct{ commonValue{Float32Kind, typ, addr} }
}
func (v *Float32ValueStruct) Get() float32 {
}
type Float64ValueStruct struct {
- Common
+ commonValue
}
func Float64Creator(typ Type, addr Addr) Value {
- return &Float64ValueStruct{ Common{Float64Kind, typ, addr} }
+ return &Float64ValueStruct{ commonValue{Float64Kind, typ, addr} }
}
func (v *Float64ValueStruct) Get() float64 {
}
type Float80ValueStruct struct {
- Common
+ commonValue
}
func Float80Creator(typ Type, addr Addr) Value {
- return &Float80ValueStruct{ Common{Float80Kind, typ, addr} }
+ return &Float80ValueStruct{ commonValue{Float80Kind, typ, addr} }
}
/*
}
type StringValueStruct struct {
- Common
+ commonValue
}
func StringCreator(typ Type, addr Addr) Value {
- return &StringValueStruct{ Common{StringKind, typ, addr} }
+ return &StringValueStruct{ commonValue{StringKind, typ, addr} }
}
func (v *StringValueStruct) Get() string {
}
type BoolValueStruct struct {
- Common
+ commonValue
}
func BoolCreator(typ Type, addr Addr) Value {
- return &BoolValueStruct{ Common{BoolKind, typ, addr} }
+ return &BoolValueStruct{ commonValue{BoolKind, typ, addr} }
}
func (v *BoolValueStruct) Get() bool {
}
type PtrValueStruct struct {
- Common
+ commonValue
}
func (v *PtrValueStruct) Get() Addr {
}
func PtrCreator(typ Type, addr Addr) Value {
- return &PtrValueStruct{ Common{PtrKind, typ, addr} };
+ return &PtrValueStruct{ commonValue{PtrKind, typ, addr} };
}
// -- Array
}
type OpenArrayValueStruct struct {
- Common;
+ commonValue;
elemtype Type;
elemsize int;
array *RuntimeArray;
}
type FixedArrayValueStruct struct {
- Common;
+ commonValue;
elemtype Type;
elemsize int;
len int;
}
type MapValueStruct struct {
- Common
+ commonValue
}
func MapCreator(typ Type, addr Addr) Value {
- return &MapValueStruct{ Common{MapKind, typ, addr} }
+ return &MapValueStruct{ commonValue{MapKind, typ, addr} }
}
func (v *MapValueStruct) Len() int {
}
type ChanValueStruct struct {
- Common
+ commonValue
}
func ChanCreator(typ Type, addr Addr) Value {
- return &ChanValueStruct{ Common{ChanKind, typ, addr} }
+ return &ChanValueStruct{ commonValue{ChanKind, typ, addr} }
}
// -- Struct
}
type StructValueStruct struct {
- Common;
+ commonValue;
field []Value;
}
func StructCreator(typ Type, addr Addr) Value {
t := typ.(StructType);
nfield := t.Len();
- v := &StructValueStruct{ Common{StructKind, typ, addr}, make([]Value, nfield) };
+ v := &StructValueStruct{ commonValue{StructKind, typ, addr}, make([]Value, nfield) };
for i := 0; i < nfield; i++ {
name, ftype, str, offset := t.Field(i);
addr_uint := uintptr(addr) + uintptr(offset);
}
type InterfaceValueStruct struct {
- Common
+ commonValue
}
func (v *InterfaceValueStruct) Get() interface{} {
}
func InterfaceCreator(typ Type, addr Addr) Value {
- return &InterfaceValueStruct{ Common{InterfaceKind, typ, addr} }
+ return &InterfaceValueStruct{ commonValue{InterfaceKind, typ, addr} }
}
// -- Func
}
type FuncValueStruct struct {
- Common
+ commonValue
}
func FuncCreator(typ Type, addr Addr) Value {
- return &FuncValueStruct{ Common{FuncKind, typ, addr} }
+ return &FuncValueStruct{ commonValue{FuncKind, typ, addr} }
}
var creator = map[int] Creator {
}
export func atof(s string) (f float, err *os.Error) {
- if floatsize == 32 {
+ if FloatSize == 32 {
f1, err1 := atof32(s);
return float(f1), err1;
}
"testing"
)
-type Test struct {
+type AtofTest struct {
in string;
out string;
err *os.Error;
}
-var tests = []Test {
- Test{ "", "0", os.EINVAL },
- Test{ "1", "1", nil },
- Test{ "+1", "1", nil },
- Test{ "1x", "0", os.EINVAL },
- Test{ "1.1.", "0", os.EINVAL },
- Test{ "1e23", "1e+23", nil },
- Test{ "100000000000000000000000", "1e+23", nil },
- Test{ "1e-100", "1e-100", nil },
- Test{ "123456700", "1.234567e+08", nil },
- Test{ "99999999999999974834176", "9.999999999999997e+22", nil },
- Test{ "100000000000000000000001", "1.0000000000000001e+23", nil },
- Test{ "100000000000000008388608", "1.0000000000000001e+23", nil },
- Test{ "100000000000000016777215", "1.0000000000000001e+23", nil },
- Test{ "100000000000000016777216", "1.0000000000000003e+23", nil },
- Test{ "-1", "-1", nil },
- Test{ "-0", "-0", nil },
- Test{ "1e-20", "1e-20", nil },
- Test{ "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
- Test{ "1.7976931348623157e308", "1.7976931348623157e+308", nil },
- Test{ "-1.7976931348623157e308", "-1.7976931348623157e+308", nil },
+ AtofTest{ "1.7976931348623157e308", "1.7976931348623157e+308", nil },
+ AtofTest{ "-1.7976931348623157e308", "-1.7976931348623157e+308", nil },
// next float64 - too large
- Test{ "1.7976931348623159e308", "+Inf", os.ERANGE },
- Test{ "-1.7976931348623159e308", "-Inf", os.ERANGE },
+ AtofTest{ "1.7976931348623159e308", "+Inf", os.ERANGE },
+ AtofTest{ "-1.7976931348623159e308", "-Inf", os.ERANGE },
// the border is ...158079
// borderline - okay
- Test{ "1.7976931348623158e308", "1.7976931348623157e+308", nil },
- Test{ "-1.7976931348623158e308", "-1.7976931348623157e+308", nil },
+ AtofTest{ "1.7976931348623158e308", "1.7976931348623157e+308", nil },
+ AtofTest{ "-1.7976931348623158e308", "-1.7976931348623157e+308", nil },
// borderline - too large
- Test{ "1.797693134862315808e308", "+Inf", os.ERANGE },
- Test{ "-1.797693134862315808e308", "-Inf", os.ERANGE },
+ AtofTest{ "1.797693134862315808e308", "+Inf", os.ERANGE },
+ AtofTest{ "-1.797693134862315808e308", "-Inf", os.ERANGE },
// a little too large
- Test{ "1e308", "1e+308", nil },
- Test{ "2e308", "+Inf", os.ERANGE },
- Test{ "1e309", "+Inf", os.ERANGE },
+ AtofTest{ "1e308", "1e+308", nil },
+ AtofTest{ "2e308", "+Inf", os.ERANGE },
+ AtofTest{ "1e309", "+Inf", os.ERANGE },
// way too large
- Test{ "1e310", "+Inf", os.ERANGE },
- Test{ "-1e310", "-Inf", os.ERANGE },
- Test{ "1e400", "+Inf", os.ERANGE },
- Test{ "-1e400", "-Inf", os.ERANGE },
- Test{ "1e400000", "+Inf", os.ERANGE },
- Test{ "-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
- Test{ "1e-305", "1e-305", nil },
- Test{ "1e-306", "1e-306", nil },
- Test{ "1e-307", "1e-307", nil },
- Test{ "1e-308", "1e-308", nil },
- Test{ "1e-309", "1e-309", nil },
- Test{ "1e-310", "1e-310", nil },
- Test{ "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
- Test{ "5e-324", "5e-324", nil },
+ AtofTest{ "5e-324", "5e-324", nil },
// too small
- Test{ "4e-324", "0", nil },
+ AtofTest{ "4e-324", "0", nil },
// way too small
- Test{ "1e-350", "0", nil },
- Test{ "1e-400000", "0", nil },
+ AtofTest{ "1e-350", "0", nil },
+ AtofTest{ "1e-400000", "0", nil },
// try to overflow exponent
- Test{ "1e-4294967296", "0", nil },
- Test{ "1e+4294967296", "+Inf", os.ERANGE },
- Test{ "1e-18446744073709551616", "0", nil },
- Test{ "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
- Test{ "1e", "0", os.EINVAL },
- Test{ "1e-", "0", os.EINVAL },
- Test{ ".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) {
oldopt := strconv.optimize;
strconv.optimize = opt;
- for i := 0; i < len(tests); i++ {
- test := &tests[i];
+ for i := 0; i < len(atoftests); i++ {
+ test := &atoftests[i];
out, err := strconv.atof64(test.in);
outs := strconv.ftoa64(out, 'g', -1);
if outs != test.out || err != test.err {
}
}
- if floatsize == 64 || float64(float32(out)) == out {
+ if FloatSize == 64 || float64(float32(out)) == out {
outf, err := strconv.atof(test.in);
outs := strconv.ftoa(outf, 'g', -1);
if outs != test.out || err != test.err {
"testing"
)
-type Uint64Test struct {
+type Atoui64Test struct {
in string;
out uint64;
err *os.Error;
}
-var uint64tests = []Uint64Test {
- Uint64Test{ "", 0, os.EINVAL },
- Uint64Test{ "0", 0, nil },
- Uint64Test{ "1", 1, nil },
- Uint64Test{ "12345", 12345, nil },
- Uint64Test{ "012345", 0, os.EINVAL },
- Uint64Test{ "12345x", 0, os.EINVAL },
- Uint64Test{ "98765432100", 98765432100, nil },
- Uint64Test{ "18446744073709551615", 1<<64-1, nil },
- Uint64Test{ "18446744073709551616", 1<<64-1, os.ERANGE },
- Uint64Test{ "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 Int64Test struct {
+type Atoi64Test struct {
in string;
out int64;
err *os.Error;
}
-var int64tests = []Int64Test {
- Int64Test{ "", 0, os.EINVAL },
- Int64Test{ "0", 0, nil },
- Int64Test{ "-0", 0, nil },
- Int64Test{ "1", 1, nil },
- Int64Test{ "-1", -1, nil },
- Int64Test{ "12345", 12345, nil },
- Int64Test{ "-12345", -12345, nil },
- Int64Test{ "012345", 0, os.EINVAL },
- Int64Test{ "-012345", 0, os.EINVAL },
- Int64Test{ "12345x", 0, os.EINVAL },
- Int64Test{ "-12345x", 0, os.EINVAL },
- Int64Test{ "98765432100", 98765432100, nil },
- Int64Test{ "-98765432100", -98765432100, nil },
- Int64Test{ "9223372036854775807", 1<<63-1, nil },
- Int64Test{ "-9223372036854775807", -(1<<63-1), nil },
- Int64Test{ "9223372036854775808", 1<<63-1, os.ERANGE },
- Int64Test{ "-9223372036854775808", -1<<63, nil },
- Int64Test{ "9223372036854775809", 1<<63-1, os.ERANGE },
- Int64Test{ "-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 Uint32Test struct {
+type Atoui32Test struct {
in string;
out uint32;
err *os.Error;
}
-var uint32tests = []Uint32Test {
- Uint32Test{ "", 0, os.EINVAL },
- Uint32Test{ "0", 0, nil },
- Uint32Test{ "1", 1, nil },
- Uint32Test{ "12345", 12345, nil },
- Uint32Test{ "012345", 0, os.EINVAL },
- Uint32Test{ "12345x", 0, os.EINVAL },
- Uint32Test{ "987654321", 987654321, nil },
- Uint32Test{ "4294967295", 1<<32-1, nil },
- Uint32Test{ "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 Int32Test struct {
+type Atoi32Test struct {
in string;
out int32;
err *os.Error;
}
-var int32tests = []Int32Test {
- Int32Test{ "", 0, os.EINVAL },
- Int32Test{ "0", 0, nil },
- Int32Test{ "-0", 0, nil },
- Int32Test{ "1", 1, nil },
- Int32Test{ "-1", -1, nil },
- Int32Test{ "12345", 12345, nil },
- Int32Test{ "-12345", -12345, nil },
- Int32Test{ "012345", 0, os.EINVAL },
- Int32Test{ "-012345", 0, os.EINVAL },
- Int32Test{ "12345x", 0, os.EINVAL },
- Int32Test{ "-12345x", 0, os.EINVAL },
- Int32Test{ "987654321", 987654321, nil },
- Int32Test{ "-987654321", -987654321, nil },
- Int32Test{ "2147483647", 1<<31-1, nil },
- Int32Test{ "-2147483647", -(1<<31-1), nil },
- Int32Test{ "2147483648", 1<<31-1, os.ERANGE },
- Int32Test{ "-2147483648", -1<<31, nil },
- Int32Test{ "2147483649", 1<<31-1, os.ERANGE },
- Int32Test{ "-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(uint64tests); i++ {
- test := &uint64tests[i];
+ for i := 0; i < len(atoui64tests); i++ {
+ test := &atoui64tests[i];
out, err := strconv.atoui64(test.in);
if test.out != out || test.err != err {
t.Errorf("strconv.atoui64(%v) = %v, %v want %v, %v\n",
}
export func TestAtoi64(t *testing.T) {
- for i := 0; i < len(int64tests); i++ {
- test := &int64tests[i];
+ for i := 0; i < len(atoi64test); i++ {
+ test := &atoi64test[i];
out, err := strconv.atoi64(test.in);
if test.out != out || test.err != err {
t.Errorf("strconv.atoi64(%v) = %v, %v want %v, %v\n",
export func TestAtoui(t *testing.T) {
switch IntSize1() {
case 32:
- for i := 0; i < len(uint32tests); i++ {
- test := &uint32tests[i];
+ for i := 0; i < len(atoui32tests); i++ {
+ test := &atoui32tests[i];
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",
}
}
case 64:
- for i := 0; i < len(uint64tests); i++ {
- test := &uint64tests[i];
+ for i := 0; i < len(atoui64tests); i++ {
+ test := &atoui64tests[i];
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",
export func TestAtoi(t *testing.T) {
switch IntSize1() {
case 32:
- for i := 0; i < len(int32tests); i++ {
- test := &int32tests[i];
+ for i := 0; i < len(atoi32tests); i++ {
+ test := &atoi32tests[i];
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",
}
}
case 64:
- for i := 0; i < len(int64tests); i++ {
- test := &int64tests[i];
+ for i := 0; i < len(atoi64test); i++ {
+ test := &atoi64test[i];
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",
func Max(a, b int) int
func RoundShortest(d *Decimal, mant uint64, exp int, flt *FloatInfo)
-func FloatSize() int {
+func floatsize() int {
// Figure out whether float is float32 or float64.
// 1e-35 is representable in both, but 1e-70
// is too small for a float32.
}
return 64;
}
-export var floatsize = FloatSize()
+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 ftoa(f float, fmt byte, prec int) string {
- if floatsize == 32 {
+ if FloatSize == 32 {
return ftoa32(float32(f), fmt, prec);
}
return ftoa64(float64(f), fmt, prec);
"testing"
)
-type Test struct {
+type FtoaTest struct {
f float64;
fmt byte;
prec int;
Above1e23 = 100000000000000008388608;
)
-// TODO: Should be able to call this tests but it conflicts with testatof.go
-var ftests = []Test {
- Test{ 1, 'e', 5, "1.00000e+00" },
- Test{ 1, 'f', 5, "1.00000" },
- Test{ 1, 'g', 5, "1" },
- Test{ 1, 'g', -1, "1" },
- Test{ 20, 'g', -1, "20" },
- Test{ 1234567.8, 'g', -1, "1.2345678e+06" },
- Test{ 200000, 'g', -1, "200000" },
- Test{ 2000000, 'g', -1, "2e+06" },
-
- Test{ 0, 'e', 5, "0.00000e+00" },
- Test{ 0, 'f', 5, "0.00000" },
- Test{ 0, 'g', 5, "0" },
- Test{ 0, 'g', -1, "0" },
-
- Test{ -1, 'e', 5, "-1.00000e+00" },
- Test{ -1, 'f', 5, "-1.00000" },
- Test{ -1, 'g', 5, "-1" },
- Test{ -1, 'g', -1, "-1" },
-
- Test{ 12, 'e', 5, "1.20000e+01" },
- Test{ 12, 'f', 5, "12.00000" },
- Test{ 12, 'g', 5, "12" },
- Test{ 12, 'g', -1, "12" },
-
- Test{ 123456700, 'e', 5, "1.23457e+08" },
- Test{ 123456700, 'f', 5, "123456700.00000" },
- Test{ 123456700, 'g', 5, "1.2346e+08" },
- Test{ 123456700, 'g', -1, "1.234567e+08" },
-
- Test{ 1.2345e6, 'e', 5, "1.23450e+06" },
- Test{ 1.2345e6, 'f', 5, "1234500.00000" },
- Test{ 1.2345e6, 'g', 5, "1.2345e+06" },
-
- Test{ 1e23, 'e', 17, "9.99999999999999916e+22" },
- Test{ 1e23, 'f', 17, "99999999999999991611392.00000000000000000" },
- Test{ 1e23, 'g', 17, "9.9999999999999992e+22" },
-
- Test{ 1e23, 'e', -1, "1e+23" },
- Test{ 1e23, 'f', -1, "100000000000000000000000" },
- Test{ 1e23, 'g', -1, "1e+23" },
-
- Test{ Below1e23, 'e', 17, "9.99999999999999748e+22" },
- Test{ Below1e23, 'f', 17, "99999999999999974834176.00000000000000000" },
- Test{ Below1e23, 'g', 17, "9.9999999999999975e+22" },
-
- Test{ Below1e23, 'e', -1, "9.999999999999997e+22" },
- Test{ Below1e23, 'f', -1, "99999999999999970000000" },
- Test{ Below1e23, 'g', -1, "9.999999999999997e+22" },
-
- Test{ Above1e23, 'e', 17, "1.00000000000000008e+23" },
- Test{ Above1e23, 'f', 17, "100000000000000008388608.00000000000000000" },
- Test{ Above1e23, 'g', 17, "1.0000000000000001e+23" },
-
- Test{ Above1e23, 'e', -1, "1.0000000000000001e+23" },
- Test{ Above1e23, 'f', -1, "100000000000000010000000" },
- Test{ Above1e23, 'g', -1, "1.0000000000000001e+23" },
-
- Test{ fdiv(5e-304, 1e20), 'g', -1, "5e-324" },
- Test{ fdiv(-5e-304, 1e20), 'g', -1, "-5e-324" },
-
- Test{ 32, 'g', -1, "32" },
- Test{ 32, 'g', 0, "3e+01" },
-
- Test{ 100, 'x', -1, "%x" },
-
- Test{ sys.NaN(), 'g', -1, "NaN" },
- Test{ -sys.NaN(), 'g', -1, "NaN" },
- Test{ sys.Inf(0), 'g', -1, "+Inf" },
- Test{ sys.Inf(-1), 'g', -1, "-Inf" },
- Test{ -sys.Inf(0), 'g', -1, "-Inf" },
-
- Test{ -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) {
- if strconv.floatsize != 32 {
- panic("floatsize: ", strconv.floatsize);
+ if strconv.FloatSize != 32 {
+ panic("floatsize: ", strconv.FloatSize);
}
- for i := 0; i < len(ftests); i++ {
- test := &ftests[i];
+ for i := 0; i < len(ftoatests); i++ {
+ test := &ftoatests[i];
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);
"testing";
)
-type Int64Test struct {
+type Itoa64Test struct {
in int64;
out string;
}
-// TODO: should be called int64tests
-
-var xint64tests = []Int64Test {
- Int64Test{ 0, "0" },
- Int64Test{ 1, "1" },
- Int64Test{ -1, "-1" },
- Int64Test{ 12345678, "12345678" },
- Int64Test{ -987654321, "-987654321" },
- Int64Test{ 1<<31-1, "2147483647" },
- Int64Test{ -1<<31+1, "-2147483647" },
- Int64Test{ 1<<31, "2147483648" },
- Int64Test{ -1<<31, "-2147483648" },
- Int64Test{ 1<<31+1, "2147483649" },
- Int64Test{ -1<<31-1, "-2147483649" },
- Int64Test{ 1<<32-1, "4294967295" },
- Int64Test{ -1<<32+1, "-4294967295" },
- Int64Test{ 1<<32, "4294967296" },
- Int64Test{ -1<<32, "-4294967296" },
- Int64Test{ 1<<32+1, "4294967297" },
- Int64Test{ -1<<32-1, "-4294967297" },
- Int64Test{ 1<<50, "1125899906842624" },
- Int64Test{ 1<<63-1, "9223372036854775807" },
- Int64Test{ -1<<63+1, "-9223372036854775807" },
- Int64Test{ -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(xint64tests); i++ {
- test := xint64tests[i];
+ for i := 0; i < len(itoa64tests); i++ {
+ test := itoa64tests[i];
s := strconv.itoa64(test.in);
if s != test.out {
t.Error("strconv.itoa64(%v) = %v want %v\n",
}
// TODO: Use once there is a strconv.uitoa
-type Uint64Test struct {
+type Uitoa64Test struct {
in uint64;
out string;
}
-// TODO: should be able to call this uint64tests.
-var xuint64tests = []Uint64Test {
- Uint64Test{ 1<<63-1, "9223372036854775807" },
- Uint64Test{ 1<<63, "9223372036854775808" },
- Uint64Test{ 1<<63+1, "9223372036854775809" },
- Uint64Test{ 1<<64-2, "18446744073709551614" },
- Uint64Test{ 1<<64-1, "18446744073709551615" },
+// 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" },
}
"utf8";
)
-const ldigits = "0123456789abcdef"
-const udigits = "0123456789ABCDEF"
+const lowerhex = "0123456789abcdef"
export func Quote(s string) string {
t := `"`;
t += `\v`;
case s[i] < utf8.RuneSelf:
- t += `\x` + string(ldigits[s[i]>>4]) + string(ldigits[s[i]&0xF]);
+ t += `\x` + string(lowerhex[s[i]>>4]) + string(lowerhex[s[i]&0xF]);
case utf8.FullRuneInString(s, i):
r, size := utf8.DecodeRuneInString(s, i);
if r < 0x10000 {
t += `\u`;
for j:=uint(0); j<4; j++ {
- t += string(ldigits[(r>>(12-4*j))&0xF]);
+ t += string(lowerhex[(r>>(12-4*j))&0xF]);
}
} else {
t += `\U`;
for j:=uint(0); j<8; j++ {
- t += string(ldigits[(r>>(28-4*j))&0xF]);
+ t += string(lowerhex[(r>>(28-4*j))&0xF]);
}
}
default:
EscX:
t += `\x`;
- t += string(ldigits[s[i]>>4]);
- t += string(ldigits[s[i]&0xF]);
+ t += string(lowerhex[s[i]>>4]);
+ t += string(lowerhex[s[i]&0xF]);
}
}
t += `"`;