func TestMemsetAsync(t *testing.T) {
N := int64(32 * 1024)
host1 := make([]float32, N)
for i := range host1 {
host1[i] = float32(i)
}
host2 := make([]float32, N)
dev1 := MemAlloc(int64(4 * N))
MemcpyHtoD(dev1, (unsafe.Pointer(&host1[0])), 4*N)
str := StreamCreate()
MemsetD32Async(dev1, math.Float32bits(42), N, str)
MemsetD32Async(dev1, math.Float32bits(21), N/2, str)
MemcpyDtoH((unsafe.Pointer(&host2[0])), dev1, 4*N)
str.Synchronize()
(&str).Destroy()
for i := 0; i < len(host2)/2; i++ {
if host2[i] != 21 {
t.Fail()
}
}
for i := len(host2) / 2; i < len(host2); i++ {
if host2[i] != 42 {
t.Fail()
}
}
dev1.Free()
}
func test32(a, b float32) {
abits := math.Float32bits(a)
bbits := math.Float32bits(b)
if abits != bbits {
panic(fmt.Sprintf("%08x != %08x\n", abits, bbits))
}
}
func (m *GPSMetadata) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Time != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintGateway(dAtA, i, uint64(m.Time))
}
if m.Latitude != 0 {
dAtA[i] = 0x15
i++
i = encodeFixed32Gateway(dAtA, i, uint32(math.Float32bits(float32(m.Latitude))))
}
if m.Longitude != 0 {
dAtA[i] = 0x1d
i++
i = encodeFixed32Gateway(dAtA, i, uint32(math.Float32bits(float32(m.Longitude))))
}
if m.Altitude != 0 {
dAtA[i] = 0x20
i++
i = encodeVarintGateway(dAtA, i, uint64(m.Altitude))
}
return i, nil
}
func WriteComplex64LE(w io.Writer, c complex64) error {
b := make([]byte, 8)
// little-endian
re := math.Float32bits(real(c))
for i := 0; i < 4; i++ {
b[i] = byte(re & 255)
re = re >> 8
}
im := math.Float32bits(imag(c))
for i := 4; i < 8; i++ {
b[i] = byte(im & 255)
im = im >> 8
}
n, err := w.Write(b)
if n != 8 {
return errors.New(fmt.Sprintf(
"Too few bytes written: %d, %s", n, err.Error()))
}
return nil
}
func (p *PlayerPositionLook) write(ww io.Writer) (err error) {
var tmp [8]byte
tmp0 := math.Float64bits(p.X)
tmp[0] = byte(tmp0 >> 56)
tmp[1] = byte(tmp0 >> 48)
tmp[2] = byte(tmp0 >> 40)
tmp[3] = byte(tmp0 >> 32)
tmp[4] = byte(tmp0 >> 24)
tmp[5] = byte(tmp0 >> 16)
tmp[6] = byte(tmp0 >> 8)
tmp[7] = byte(tmp0 >> 0)
if _, err = ww.Write(tmp[:8]); err != nil {
return
}
tmp1 := math.Float64bits(p.Y)
tmp[0] = byte(tmp1 >> 56)
tmp[1] = byte(tmp1 >> 48)
tmp[2] = byte(tmp1 >> 40)
tmp[3] = byte(tmp1 >> 32)
tmp[4] = byte(tmp1 >> 24)
tmp[5] = byte(tmp1 >> 16)
tmp[6] = byte(tmp1 >> 8)
tmp[7] = byte(tmp1 >> 0)
if _, err = ww.Write(tmp[:8]); err != nil {
return
}
tmp2 := math.Float64bits(p.Z)
tmp[0] = byte(tmp2 >> 56)
tmp[1] = byte(tmp2 >> 48)
tmp[2] = byte(tmp2 >> 40)
tmp[3] = byte(tmp2 >> 32)
tmp[4] = byte(tmp2 >> 24)
tmp[5] = byte(tmp2 >> 16)
tmp[6] = byte(tmp2 >> 8)
tmp[7] = byte(tmp2 >> 0)
if _, err = ww.Write(tmp[:8]); err != nil {
return
}
tmp3 := math.Float32bits(p.Yaw)
tmp[0] = byte(tmp3 >> 24)
tmp[1] = byte(tmp3 >> 16)
tmp[2] = byte(tmp3 >> 8)
tmp[3] = byte(tmp3 >> 0)
if _, err = ww.Write(tmp[:4]); err != nil {
return
}
tmp4 := math.Float32bits(p.Pitch)
tmp[0] = byte(tmp4 >> 24)
tmp[1] = byte(tmp4 >> 16)
tmp[2] = byte(tmp4 >> 8)
tmp[3] = byte(tmp4 >> 0)
if _, err = ww.Write(tmp[:4]); err != nil {
return
}
if err = WriteBool(ww, p.OnGround); err != nil {
return
}
return
}
func TestFloat32SpecialCases(t *testing.T) {
//switch runtime.GOARCH {
//case "cs", "java":
// return
//}
for _, input := range float64inputs {
if strings.HasPrefix(input, "long:") {
if testing.Short() {
continue
}
input = input[len("long:"):]
}
r, ok := new(Rat).SetString(input)
if !ok {
t.Errorf("Rat.SetString(%q) failed", input)
continue
}
f, exact := r.Float32()
// 1. Check string -> Rat -> float32 conversions are
// consistent with strconv.ParseFloat.
// Skip this check if the input uses "a/b" rational syntax.
if !strings.Contains(input, "/") {
e64, _ := strconv.ParseFloat(input, 32)
e := float32(e64)
// Careful: negative Rats too small for
// float64 become -0, but Rat obviously cannot
// preserve the sign from SetString("-0").
switch {
case math.Float32bits(e) == math.Float32bits(f):
// Ok: bitwise equal.
case f == 0 && r.Num().BitLen() == 0:
// Ok: Rat(0) is equivalent to both +/- float64(0).
default:
t.Errorf("strconv.ParseFloat(%q) = %g (%b), want %g (%b); delta = %g", input, e, e, f, f, f-e)
}
}
if !isFinite(float64(f)) {
continue
}
// 2. Check f is best approximation to r.
if !checkIsBestApprox32(t, f, r) {
// Append context information.
t.Errorf("(input was %q)", input)
}
// 3. Check f->R->f roundtrip is non-lossy.
checkNonLossyRoundtrip32(t, f)
// 4. Check exactness using slow algorithm.
if wasExact := new(Rat).SetFloat64(float64(f)).Cmp(r) == 0; wasExact != exact {
t.Errorf("Rat.SetString(%q).Float32().exact = %t, want %t", input, exact, wasExact)
}
}
}
func complex64Encoder(enc *encoder, v reflect.Value) error {
bs := enc.buf[:8]
x := v.Complex()
enc.order.PutUint32(bs, math.Float32bits(float32(real(x))))
enc.order.PutUint32(bs[4:], math.Float32bits(float32(imag(x))))
_, err := enc.Write(bs)
return err
}
func complex64Encoder(enc *encoder, p unsafe.Pointer) error {
bs := enc.buf[:8]
v := (*complex64)(p)
enc.order.PutUint32(bs, math.Float32bits(real(*v)))
enc.order.PutUint32(bs[4:], math.Float32bits(imag(*v)))
_, err := enc.Write(bs)
return err
}
// AppendComplex64 appends a complex64 to the slice as a MessagePack extension
func AppendComplex64(b []byte, c complex64) []byte {
o, n := ensure(b, Complex64Size)
o[n] = mfixext8
o[n+1] = Complex64Extension
big.PutUint32(o[n+2:], math.Float32bits(real(c)))
big.PutUint32(o[n+6:], math.Float32bits(imag(c)))
return o
}
func (ctx *context) PolygonOffset(factor, units float32) {
ctx.enqueue(call{
args: fnargs{
fn: glfnPolygonOffset,
a0: uintptr(math.Float32bits(factor)),
a1: uintptr(math.Float32bits(units)),
},
})
}
func (ctx *context) DepthRangef(n, f float32) {
ctx.enqueue(call{
args: fnargs{
fn: glfnDepthRangef,
a0: uintptr(math.Float32bits(n)),
a1: uintptr(math.Float32bits(f)),
},
})
}
func (ctx *context) PolygonOffset(factor, units float32) {
ctx.enqueue(call{
args: C.struct_fnargs{
fn: C.glfnPolygonOffset,
a0: C.uintptr_t(math.Float32bits(factor)),
a1: C.uintptr_t(math.Float32bits(units)),
},
})
}
func (ctx *context) DepthRangef(n, f float32) {
ctx.enqueue(call{
args: C.struct_fnargs{
fn: C.glfnDepthRangef,
a0: C.uintptr_t(math.Float32bits(n)),
a1: C.uintptr_t(math.Float32bits(f)),
},
})
}
func (ctx *context) Uniform2f(dst Uniform, v0, v1 float32) {
ctx.enqueue(call{
args: C.struct_fnargs{
fn: C.glfnUniform2f,
a0: dst.c(),
a1: C.uintptr_t(math.Float32bits(v0)),
a2: C.uintptr_t(math.Float32bits(v1)),
},
})
}
func (ctx *context) Uniform2f(dst Uniform, v0, v1 float32) {
ctx.enqueue(call{
args: fnargs{
fn: glfnUniform2f,
a0: dst.c(),
a1: uintptr(math.Float32bits(v0)),
a2: uintptr(math.Float32bits(v1)),
},
})
}
func (ctx *context) VertexAttrib2f(dst Attrib, x, y float32) {
ctx.enqueue(call{
args: fnargs{
fn: glfnVertexAttrib2f,
a0: dst.c(),
a1: uintptr(math.Float32bits(x)),
a2: uintptr(math.Float32bits(y)),
},
})
}
func (ctx *context) VertexAttrib2f(dst Attrib, x, y float32) {
ctx.enqueue(call{
args: C.struct_fnargs{
fn: C.glfnVertexAttrib2f,
a0: dst.c(),
a1: C.uintptr_t(math.Float32bits(x)),
a2: C.uintptr_t(math.Float32bits(y)),
},
})
}
func TestFloatFloat32(t *testing.T) {
for i, g := range golden {
f32 := g.f8.Float32()
if f32 != g.f32 {
got := math.Float32bits(f32)
want := math.Float32bits(g.f32)
t.Errorf("i=%d: expected %032b, got %032b.", i, want, got)
continue
}
}
}
func (ctx *context) BlendColor(red, green, blue, alpha float32) {
ctx.enqueue(call{
args: fnargs{
fn: glfnBlendColor,
a0: uintptr(math.Float32bits(red)),
a1: uintptr(math.Float32bits(green)),
a2: uintptr(math.Float32bits(blue)),
a3: uintptr(math.Float32bits(alpha)),
},
})
}
// WriteComplex64 writes a complex64 to the writer
func (mw *Writer) WriteComplex64(f complex64) error {
o, err := mw.require(10)
if err != nil {
return err
}
mw.buf[o] = mfixext8
mw.buf[o+1] = Complex64Extension
big.PutUint32(mw.buf[o+2:], math.Float32bits(real(f)))
big.PutUint32(mw.buf[o+6:], math.Float32bits(imag(f)))
return nil
}
func (ctx *context) BlendColor(red, green, blue, alpha float32) {
ctx.enqueue(call{
args: C.struct_fnargs{
fn: C.glfnBlendColor,
a0: C.uintptr_t(math.Float32bits(red)),
a1: C.uintptr_t(math.Float32bits(green)),
a2: C.uintptr_t(math.Float32bits(blue)),
a3: C.uintptr_t(math.Float32bits(alpha)),
},
})
}
func TestIf(t *testing.T) {
count := 0
for j := -63; j <= 63; j++ {
count++
x := int64(0)
if j < 0 {
x = -1 << uint(-j)
} else {
x = 1<<uint(j) - 1
}
if ift0s(uint8(x)) != ift0(uint8(x)) {
t.Errorf("ift0s (%v) != ift0 (%v)", ift0s(uint8(x)), ift0(uint8(x)))
}
if ift1s(uint16(x)) != ift1(uint16(x)) {
t.Errorf("ift1s (%v) != ift1 (%v)", ift1s(uint16(x)), ift1(uint16(x)))
}
if ift2s(uint32(x)) != ift2(uint32(x)) {
t.Errorf("ift2s (%v) != ift2 (%v)", ift2s(uint32(x)), ift2(uint32(x)))
}
if ift3s(uint64(x)) != ift3(uint64(x)) {
t.Errorf("ift3s (%v) != ift3 (%v)", ift3s(uint64(x)), ift3(uint64(x)))
}
if ift4s(int8(x)) != ift4(int8(x)) {
t.Errorf("ift4s (%v) != ift4 (%v)", ift4s(int8(x)), ift4(int8(x)))
}
if ift5s(int16(x)) != ift5(int16(x)) {
t.Errorf("ift5s (%v) != ift5 (%v)", ift5s(int16(x)), ift5(int16(x)))
}
if ift6s(int32(x)) != ift6(int32(x)) {
t.Errorf("ift6s (%v) != ift6 (%v)", ift6s(int32(x)), ift6(int32(x)))
}
if ift7s(x) != ift7(x) {
t.Errorf("ift7s (%v) != ift7 (%v)", ift7s(x), ift7(x))
}
if ift8s(float32(x)) != ift8(float32(x)) {
sbits := math.Float32bits(ift8s(float32(x)))
tbits := math.Float32bits(ift8(float32(x)))
t.Errorf("ift8s (x=%v) (%v=%08x) != ift8 (%v=%08x)", float32(x), ift8s(float32(x)), sbits, ift8(float32(x)), tbits)
}
if ift9s(float64(x)) != ift9(float64(x)) {
t.Errorf("ift9s (%v) != ift9 (%v)", ift9s(float64(x)), ift9(float64(x)))
}
}
t.Log("Test Count:", count)
}
func marshalFloat(info TypeInfo, value interface{}) ([]byte, error) {
switch v := value.(type) {
case Marshaler:
return v.MarshalCQL(info)
case float32:
return encInt(int32(math.Float32bits(v))), nil
}
rv := reflect.ValueOf(value)
switch rv.Type().Kind() {
case reflect.Float32:
return encInt(int32(math.Float32bits(float32(rv.Float())))), nil
}
return nil, marshalErrorf("can not marshal %T into %s", value, info)
}
func (m *GoGoProtobufTestMessage1) MarshalTo(data []byte) (n int, err error) {
var i int
_ = i
var l int
_ = l
if m.F0 != nil {
data[i] = 0x8
i++
i = encodeVarintGogoproto(data, i, uint64(uint32(*m.F0)))
}
if m.F1 != nil {
data[i] = 0x12
i++
i = encodeVarintGogoproto(data, i, uint64(len(*m.F1)))
i += copy(data[i:], *m.F1)
}
if m.F2 != nil {
data[i] = 0x1d
i++
i = encodeFixed32Gogoproto(data, i, uint32(math2.Float32bits(*m.F2)))
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func main() {
for _, t := range []struct {
value float32
bits uint32
}{
{0e+00, 0x00000000},
{1e-45, 0x00000000},
{2e-45, 0x00000001},
{3e-45, 0x00000002},
{4e-45, 0x00000003},
{5e-45, 0x00000004},
{6e-45, 0x00000004},
{7e-45, 0x00000005},
{8e-45, 0x00000006},
{9e-45, 0x00000006},
{1.0e-44, 0x00000007},
{1.1e-44, 0x00000008},
{1.2e-44, 0x00000009},
} {
got := math.Float32bits(t.value)
want := t.bits
if got != want {
panic(fmt.Sprintf("bits(%g) = 0x%08x; want 0x%08x", t.value, got, want))
}
}
}
func float32Encoder(enc *encoder, p unsafe.Pointer) error {
bs := enc.buf[:4]
v := (*float32)(p)
enc.order.PutUint32(bs, math.Float32bits(*v))
_, err := enc.Write(bs)
return err
}
func byteList(byteOrder binary.ByteOrder, values []float32) []byte {
le := false
switch byteOrder {
case binary.BigEndian:
case binary.LittleEndian:
le = true
default:
panic(fmt.Sprintf("invalid byte order %v", byteOrder))
}
b := make([]byte, 4*len(values))
for i, v := range values {
u := math.Float32bits(v)
if le {
b[4*i+0] = byte(u >> 0)
b[4*i+1] = byte(u >> 8)
b[4*i+2] = byte(u >> 16)
b[4*i+3] = byte(u >> 24)
} else {
b[4*i+0] = byte(u >> 24)
b[4*i+1] = byte(u >> 16)
b[4*i+2] = byte(u >> 8)
b[4*i+3] = byte(u >> 0)
}
}
return b
}
func _Metric_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Metric)
// data
switch x := m.Data.(type) {
case *Metric_StringData:
b.EncodeVarint(9<<3 | proto.WireBytes)
b.EncodeStringBytes(x.StringData)
case *Metric_Float32Data:
b.EncodeVarint(10<<3 | proto.WireFixed32)
b.EncodeFixed32(uint64(math.Float32bits(x.Float32Data)))
case *Metric_Float64Data:
b.EncodeVarint(11<<3 | proto.WireFixed64)
b.EncodeFixed64(math.Float64bits(x.Float64Data))
case *Metric_Int32Data:
b.EncodeVarint(12<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Int32Data))
case *Metric_Int64Data:
b.EncodeVarint(13<<3 | proto.WireVarint)
b.EncodeVarint(uint64(x.Int64Data))
case *Metric_BytesData:
b.EncodeVarint(14<<3 | proto.WireBytes)
b.EncodeRawBytes(x.BytesData)
case *Metric_BoolData:
t := uint64(0)
if x.BoolData {
t = 1
}
b.EncodeVarint(15<<3 | proto.WireVarint)
b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("Metric.Data has unexpected type %T", x)
}
return nil
}
func (conn *Conn) writeFloat32(f float32) {
var buf [4]byte
b := buf[:]
binary.BigEndian.PutUint32(b, math.Float32bits(f))
conn.write(b)
}
func castFloat32ToByte(vertexes []float32) []byte {
b := make([]byte, len(vertexes)*4)
for i, v := range vertexes {
binary.LittleEndian.PutUint32(b[4*i:], math.Float32bits(v))
}
return b
}