// encodeValue encodes db value from metric.
func encodeValue(m *models.Metric) []byte {
b := make([]byte, 8+8+8)
binary.BigEndian.PutUint64(b[:8], math.Float64bits(m.Value))
binary.BigEndian.PutUint64(b[8:8+8], math.Float64bits(m.Score))
binary.BigEndian.PutUint64(b[8+8:], math.Float64bits(m.Average))
return b
}
func formatBinaryValue(value interface{}) ([]byte, error) {
switch v := value.(type) {
case int8:
return Uint64ToBytes(uint64(v)), nil
case int16:
return Uint64ToBytes(uint64(v)), nil
case int32:
return Uint64ToBytes(uint64(v)), nil
case int64:
return Uint64ToBytes(uint64(v)), nil
case int:
return Uint64ToBytes(uint64(v)), nil
case uint8:
return Uint64ToBytes(uint64(v)), nil
case uint16:
return Uint64ToBytes(uint64(v)), nil
case uint32:
return Uint64ToBytes(uint64(v)), nil
case uint64:
return Uint64ToBytes(uint64(v)), nil
case uint:
return Uint64ToBytes(uint64(v)), nil
case float32:
return Uint64ToBytes(math.Float64bits(float64(v))), nil
case float64:
return Uint64ToBytes(math.Float64bits(v)), nil
case []byte:
return v, nil
case string:
return hack.Slice(v), nil
default:
return nil, errors.Errorf("invalid type %T", value)
}
}
// Marshal serialized the Frame into bytes. We'll
// reuse the space pointed to by buf if there is
// sufficient space in it. We return the bytes
// that we wrote, plus any error.
func (f *Frame) Marshal(buf []byte) ([]byte, error) {
n := f.NumBytes()
var m []byte
if int64(len(buf)) >= n {
m = buf[:n]
} else {
m = make([]byte, n)
}
binary.LittleEndian.PutUint64(m[:8], uint64(f.Prim))
if n == 8 {
return m, nil
}
pti := f.GetPTI()
switch pti {
case PtiOneInt64:
binary.LittleEndian.PutUint64(m[8:16], uint64(f.Ude))
case PtiOneFloat64:
binary.LittleEndian.PutUint64(m[8:16], math.Float64bits(f.V0))
case PtiTwo64:
binary.LittleEndian.PutUint64(m[8:16], math.Float64bits(f.V0))
binary.LittleEndian.PutUint64(m[16:24], uint64(f.Ude))
case PtiUDE:
binary.LittleEndian.PutUint64(m[8:16], uint64(f.Ude))
if n == 16 {
return m, nil
}
copy(m[16:], f.Data)
m[n-1] = 0
}
return m, nil
}
func marshal() (outstring []string) {
// <bandcount>|trackname|beat0band0lbeat0band0r...Beat0bandNr
// numbers aren't intended to be human readable, but it is easier to emit human readable integers
out := make([]string, 0)
out = append(out, fmt.Sprintf("%d", bands))
for _, track := range sources {
out = append(out, fmt.Sprintf("|%s|%d|", track.filename, len(track.beats)))
if len(track.beats) <= 128 {
for i := uint(0); i < bands; i += 1 {
for j := uint(0); j < uint(len(track.beats)); j += 1 {
// fmt.Fprintf(os.Stderr, "%d %d %f %f\n", i, j, track.beats[j].buckets[i].left, track.beats[j].buckets[i].right)
}
}
}
for _, beat := range track.beats {
for _, band := range beat.buckets {
l := math.Float64bits(band.left)
r := math.Float64bits(band.right)
var sb bytes.Buffer
binary.Write(&sb, binary.BigEndian, l)
binary.Write(&sb, binary.BigEndian, r)
out = append(out, sb.String())
}
}
}
return out
}
// Blake2b returns the 64-byte BLAKE2b cryptographic
// hash of the Frame. This is useful for hashing and
// de-duplicating a stream of Frames.
//
// reference: https://godoc.org/github.com/codahale/blake2
// reference: https://blake2.net/
// reference: https://tools.ietf.org/html/rfc7693
//
func (f *Frame) Blake2b() []byte {
h, err := blake2b.New(nil)
panicOn(err)
n := f.NumBytes()
var m [24]byte
binary.LittleEndian.PutUint64(m[:8], uint64(f.Prim))
switch {
case n == 8:
h.Write(m[:8])
default:
pti := f.GetPTI()
switch pti {
case PtiOneInt64:
binary.LittleEndian.PutUint64(m[8:16], uint64(f.Ude))
h.Write(m[:16])
case PtiOneFloat64:
binary.LittleEndian.PutUint64(m[8:16], math.Float64bits(f.V0))
h.Write(m[:16])
case PtiTwo64:
binary.LittleEndian.PutUint64(m[8:16], math.Float64bits(f.V0))
binary.LittleEndian.PutUint64(m[16:24], uint64(f.Ude))
h.Write(m[:24])
case PtiUDE:
binary.LittleEndian.PutUint64(m[8:16], uint64(f.Ude))
h.Write(m[:16])
h.Write(f.Data)
}
}
return []byte(h.Sum(nil))
}
// turn uint64 op into float64 op
func fop(f func(x, y uint64) uint64) func(x, y float64) float64 {
return func(x, y float64) float64 {
bx := math.Float64bits(x)
by := math.Float64bits(y)
return math.Float64frombits(f(bx, by))
}
}
func test64(a, b float64) {
abits := math.Float64bits(a)
bbits := math.Float64bits(b)
if abits != bbits {
panic(fmt.Sprintf("%016x != %016x\n", abits, bbits))
}
}
func (m *InternalTimeSeriesSample) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
data[i] = 0x8
i++
i = encodeVarintInternal(data, i, uint64(m.Offset))
data[i] = 0x30
i++
i = encodeVarintInternal(data, i, uint64(m.Count))
data[i] = 0x39
i++
i = encodeFixed64Internal(data, i, uint64(math.Float64bits(float64(m.Sum))))
if m.Max != nil {
data[i] = 0x41
i++
i = encodeFixed64Internal(data, i, uint64(math.Float64bits(float64(*m.Max))))
}
if m.Min != nil {
data[i] = 0x49
i++
i = encodeFixed64Internal(data, i, uint64(math.Float64bits(float64(*m.Min))))
}
return i, nil
}
func (self PathData) Interator() NextElement {
count := 0
num_data := len(self)
return func() (PathDataType, []PathDataPoint) {
if count >= num_data {
return -1, nil
}
length := int(math.Float64bits(self[count]) >> 32)
path_type := int((math.Float64bits(self[count]) << 32) >> 32)
count += 2
var pathPoints []PathDataPoint
if length >= 2 {
length--
pathPoints = make([]PathDataPoint, length)
for index := range pathPoints {
pathPoints[index].x = self[count]
pathPoints[index].y = self[count+1]
}
count += (length * 2)
} else {
pathPoints = []PathDataPoint{}
}
return PathDataType(path_type), pathPoints
}
}
func testcmp(t *testing.T, f, g float64) {
hcmp, hisnan := hwcmp(f, g)
scmp, sisnan := Fcmp64(math.Float64bits(f), math.Float64bits(g))
if int32(hcmp) != scmp || hisnan != sisnan {
err(t, "cmp(%g, %g) = sw %v, %v, hw %v, %v\n", f, g, scmp, sisnan, hcmp, hisnan)
}
}
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
}
// AppendComplex128 appends a complex128 to the slice as a MessagePack extension
func AppendComplex128(b []byte, c complex128) []byte {
o, n := ensure(b, Complex128Size)
o[n] = mfixext16
o[n+1] = Complex128Extension
big.PutUint64(o[n+2:], math.Float64bits(real(c)))
big.PutUint64(o[n+10:], math.Float64bits(imag(c)))
return o
}
func writeByteSortableFloat(b []byte, f float64) {
if math.Signbit(f) {
binary.BigEndian.PutUint64(b, math.Float64bits(f))
for i, v := range b[:8] {
b[i] = v ^ 255
}
} else {
binary.BigEndian.PutUint64(b, math.Float64bits(-f))
}
}
func SameF64Approx(str string, c, native, absTol, relTol float64) {
if math.IsNaN(c) && math.IsNaN(native) {
return
}
if !floats.EqualWithinAbsOrRel(c, native, absTol, relTol) {
cb := math.Float64bits(c)
nb := math.Float64bits(native)
same := floats.EqualWithinAbsOrRel(c, native, absTol, relTol)
panic(fmt.Sprintf("Case %s: Float64 mismatch. c = %v, native = %v\n cb: %v, nb: %v\n%v,%v,%v", str, c, native, cb, nb, same, absTol, relTol))
}
}
func complex128Encoder(enc *encoder, p unsafe.Pointer) error {
bs := enc.buf[:8]
v := (*complex128)(p)
enc.order.PutUint64(bs, math.Float64bits(real(*v)))
if _, err := enc.Write(bs); err != nil {
return err
}
enc.order.PutUint64(bs, math.Float64bits(imag(*v)))
_, err := enc.Write(bs)
return err
}
func complex128Encoder(enc *encoder, v reflect.Value) error {
bs := enc.buf[:8]
x := v.Complex()
enc.order.PutUint64(bs, math.Float64bits(real(x)))
if _, err := enc.Write(bs); err != nil {
return err
}
enc.order.PutUint64(bs, math.Float64bits(imag(x)))
_, err := enc.Write(bs)
return err
}
func TestFloatArgs(t *testing.T) {
if _, err := exec.LookPath("gcc"); err != nil {
t.Skip("skipping test: gcc is missing")
}
if runtime.GOARCH != "amd64" {
t.Skipf("skipping test: GOARCH=%s", runtime.GOARCH)
}
const src = `
#include <stdint.h>
#include <windows.h>
uintptr_t cfunc(uintptr_t a, double b, float c, double d) {
if (a == 1 && b == 2.2 && c == 3.3f && d == 4.4e44) {
return 1;
}
return 0;
}
`
tmpdir, err := ioutil.TempDir("", "TestFloatArgs")
if err != nil {
t.Fatal("TempDir failed: ", err)
}
defer os.RemoveAll(tmpdir)
srcname := "mydll.c"
err = ioutil.WriteFile(filepath.Join(tmpdir, srcname), []byte(src), 0)
if err != nil {
t.Fatal(err)
}
outname := "mydll.dll"
cmd := exec.Command("gcc", "-shared", "-s", "-Werror", "-o", outname, srcname)
cmd.Dir = tmpdir
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("failed to build dll: %v - %v", err, string(out))
}
dllpath := filepath.Join(tmpdir, outname)
dll := syscall.MustLoadDLL(dllpath)
defer dll.Release()
proc := dll.MustFindProc("cfunc")
r, _, err := proc.Call(
1,
uintptr(math.Float64bits(2.2)),
uintptr(math.Float32bits(3.3)),
uintptr(math.Float64bits(4.4e44)),
)
if r != 1 {
t.Errorf("got %d want 1 (err=%v)", r, err)
}
}
func TestFloat64SpecialCases(t *testing.T) {
for _, input := range float64inputs {
if strings.HasPrefix(input, "long:") {
if !*long {
continue
}
input = input[len("long:"):]
}
r, ok := new(Rat).SetString(input)
if !ok {
t.Errorf("Rat.SetString(%q) failed", input)
continue
}
f, exact := r.Float64()
// 1. Check string -> Rat -> float64 conversions are
// consistent with strconv.ParseFloat.
// Skip this check if the input uses "a/b" rational syntax.
if !strings.Contains(input, "/") {
e, _ := strconv.ParseFloat(input, 64)
// Careful: negative Rats too small for
// float64 become -0, but Rat obviously cannot
// preserve the sign from SetString("-0").
switch {
case math.Float64bits(e) == math.Float64bits(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(f) {
continue
}
// 2. Check f is best approximation to r.
if !checkIsBestApprox64(t, f, r) {
// Append context information.
t.Errorf("(input was %q)", input)
}
// 3. Check f->R->f roundtrip is non-lossy.
checkNonLossyRoundtrip64(t, f)
// 4. Check exactness using slow algorithm.
if wasExact := new(Rat).SetFloat64(f).Cmp(r) == 0; wasExact != exact {
t.Errorf("Rat.SetString(%q).Float64().exact = %t, want %t", input, exact, wasExact)
}
}
}
// WriteComplex128 writes a complex128 to the writer
func (mw *Writer) WriteComplex128(f complex128) error {
o, err := mw.require(18)
if err != nil {
return err
}
mw.buf[o] = mfixext16
mw.buf[o+1] = Complex128Extension
big.PutUint64(mw.buf[o+2:], math.Float64bits(real(f)))
big.PutUint64(mw.buf[o+10:], math.Float64bits(imag(f)))
return nil
}
func (s *FloatEncoder) Push(v float64) {
// Only allow NaN as a sentinel value
if math.IsNaN(v) && !s.finished {
s.err = fmt.Errorf("unsupported value: NaN")
return
}
if s.first {
// first point
s.val = v
s.first = false
s.bw.WriteBits(math.Float64bits(v), 64)
return
}
vDelta := math.Float64bits(v) ^ math.Float64bits(s.val)
if vDelta == 0 {
s.bw.WriteBit(bitstream.Zero)
} else {
s.bw.WriteBit(bitstream.One)
leading := bits.Clz(vDelta)
trailing := bits.Ctz(vDelta)
// Clamp number of leading zeros to avoid overflow when encoding
leading &= 0x1F
if leading >= 32 {
leading = 31
}
// TODO(dgryski): check if it's 'cheaper' to reset the leading/trailing bits instead
if s.leading != ^uint64(0) && leading >= s.leading && trailing >= s.trailing {
s.bw.WriteBit(bitstream.Zero)
s.bw.WriteBits(vDelta>>s.trailing, 64-int(s.leading)-int(s.trailing))
} else {
s.leading, s.trailing = leading, trailing
s.bw.WriteBit(bitstream.One)
s.bw.WriteBits(leading, 5)
// Note that if leading == trailing == 0, then sigbits == 64. But that
// value doesn't actually fit into the 6 bits we have.
// Luckily, we never need to encode 0 significant bits, since that would
// put us in the other case (vdelta == 0). So instead we write out a 0 and
// adjust it back to 64 on unpacking.
sigbits := 64 - leading - trailing
s.bw.WriteBits(sigbits, 6)
s.bw.WriteBits(vDelta>>trailing, int(sigbits))
}
}
s.val = v
}
// EqualWithinULP returns true if a and b are equal to within
// the specified number of floating point units in the last place.
func EqualWithinULP(a, b float64, ulp uint) bool {
if a == b {
return true
}
if math.IsNaN(a) || math.IsNaN(b) {
return false
}
if math.Signbit(a) != math.Signbit(b) {
return math.Float64bits(math.Abs(a))+math.Float64bits(math.Abs(b)) <= uint64(ulp)
}
return ulpDiff(math.Float64bits(a), math.Float64bits(b)) <= uint64(ulp)
}
func (c *Compressor) Encode(buf *bytes.Buffer, d, e float64) {
dbits := int64(math.Float64bits(d))
diff1d := c.pred1.Prediction() ^ dbits
diff2d := c.pred2.Prediction() ^ dbits
pred1BetterForD := countLeadingZeros(uint64(diff1d)) >= countLeadingZeros(uint64(diff2d))
c.pred1.Update(dbits)
c.pred2.Update(dbits)
ebits := int64(math.Float64bits(e))
diff1e := c.pred1.Prediction() ^ ebits
diff2e := c.pred2.Prediction() ^ ebits
pred1BetterForE := countLeadingZeros(uint64(diff1e)) >= countLeadingZeros(uint64(diff2e))
c.pred1.Update(ebits)
c.pred2.Update(ebits)
var code byte
if pred1BetterForD {
zb := encodeZeroBytes(diff1d)
code |= byte(zb << 4)
} else {
zb := encodeZeroBytes(diff2d)
code |= 0x80
code |= byte(zb << 4)
}
if pred1BetterForE {
zb := encodeZeroBytes(diff1e)
code |= byte(zb)
} else {
zb := encodeZeroBytes(diff2e)
code |= 0x08
code |= byte(zb)
}
// FIXME: ignoring errors
buf.WriteByte(code)
if pred1BetterForD {
buf.Write(c.ToByteArray(diff1d))
} else {
buf.Write(c.ToByteArray(diff2d))
}
if pred1BetterForE {
buf.Write(c.ToByteArray(diff1e))
} else {
buf.Write(c.ToByteArray(diff2e))
}
}
func (h *NumericHistogram) Bytes() []byte {
b := make([]byte, 2*8*len(h.bins)+8+8+8)
binary.LittleEndian.PutUint64(b, h.total)
binary.LittleEndian.PutUint64(b[8:], uint64(h.maxbins))
binary.LittleEndian.PutUint64(b[16:], uint64(len(h.bins)))
p := 24
for _, v := range h.bins {
binary.LittleEndian.PutUint64(b[p:], math.Float64bits(v.value))
binary.LittleEndian.PutUint64(b[p+8:], math.Float64bits(v.count))
p += 16
}
return b
}
func toIndexedBytes(value interface{}) ([]byte, byte) {
// https://golang.org/pkg/encoding/json/#Unmarshal
switch converted := value.(type) {
case bool:
// JSON boolean
if converted {
return []byte{1}, ValueTypeBool
} else {
return []byte{0}, ValueTypeBool
}
case string:
// JSON string
return []byte(converted), ValueTypeString
case float64:
// JSON number
// http://stackoverflow.com/questions/22491876/convert-byte-array-uint8-to-float64-in-golang
bits := math.Float64bits(converted)
bytes := make([]byte, 8)
binary.BigEndian.PutUint64(bytes, bits)
return bytes, ValueTypeFloat64
case int:
// JSON number
c := float64(converted)
bits := math.Float64bits(c)
bytes := make([]byte, 8)
binary.BigEndian.PutUint64(bytes, bits)
return bytes, ValueTypeFloat64
case int64:
// JSON number
c := float64(converted)
bits := math.Float64bits(c)
bytes := make([]byte, 8)
binary.BigEndian.PutUint64(bytes, bits)
return bytes, ValueTypeFloat64
case nil:
// JSON null
return nil, ValueTypeNil
case []interface{}:
// JSON array
// not support indexing...
return nil, valueTypeNoIndex
case map[string]interface{}:
// JSON object
// not support indexing...
return nil, valueTypeNoIndex
default:
return nil, valueTypeNoIndex
}
}
func marshalDouble(info TypeInfo, value interface{}) ([]byte, error) {
switch v := value.(type) {
case Marshaler:
return v.MarshalCQL(info)
case float64:
return encBigInt(int64(math.Float64bits(v))), nil
}
rv := reflect.ValueOf(value)
switch rv.Type().Kind() {
case reflect.Float64:
return encBigInt(int64(math.Float64bits(rv.Float()))), nil
}
return nil, marshalErrorf("can not marshal %T into %s", value, info)
}
func DiffInUlps(x, y float64) uint64 {
switch {
case math.IsNaN(x) || math.IsNaN(y) || math.IsInf(x, 0) || math.IsInf(y, 0):
return math.MaxInt64
case x == y:
return 0
default:
xi := math.Float64bits(x)
yi := math.Float64bits(y)
if xi > yi {
return xi - yi
}
return yi - xi
}
}
// SetFloat64 sets z to exactly f and returns z.
// If f is not finite, SetFloat returns nil.
func (z *Rat) SetFloat64(f float64) *Rat {
const expMask = 1<<11 - 1
bits := math.Float64bits(f)
mantissa := bits & (1<<52 - 1)
exp := int((bits >> 52) & expMask)
switch exp {
case expMask: // non-finite
return nil
case 0: // denormal
exp -= 1022
default: // normal
mantissa |= 1 << 52
exp -= 1023
}
shift := 52 - exp
// Optimization (?): partially pre-normalise.
for mantissa&1 == 0 && shift > 0 {
mantissa >>= 1
shift--
}
z.a.SetUint64(mantissa)
z.a.neg = f < 0
z.b.Set(intOne)
if shift > 0 {
z.b.Lsh(&z.b, uint(shift))
} else {
z.a.Lsh(&z.a, uint(-shift))
}
return z.norm()
}
// Bit-value is determined by the sign of each sample after filtering.
func Quantize(input []float64, output []byte) {
for idx, val := range input {
output[idx] = byte(math.Float64bits(val)>>63) ^ 0x01
}
return
}
func (m *ValueMetric) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Name == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("name")
} else {
data[i] = 0xa
i++
i = encodeVarintMetric(data, i, uint64(len(*m.Name)))
i += copy(data[i:], *m.Name)
}
if m.Value == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("value")
} else {
data[i] = 0x11
i++
i = encodeFixed64Metric(data, i, uint64(math.Float64bits(*m.Value)))
}
if m.Unit == nil {
return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("unit")
} else {
data[i] = 0x1a
i++
i = encodeVarintMetric(data, i, uint64(len(*m.Unit)))
i += copy(data[i:], *m.Unit)
}
if m.XXX_unrecognized != nil {
i += copy(data[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Value_NumberValue) MarshalTo(data []byte) (int, error) {
i := 0
data[i] = 0x11
i++
i = encodeFixed64Struct(data, i, uint64(math.Float64bits(float64(m.NumberValue))))
return i, nil
}
