@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/util/coding/nth-derivative.h

@@ -0,0 +1,134 @@
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+//   far-far-superior implementation courtesy of amc@google.com (Adam Costello)
+//
+// Nth Derivative Coding
+//   (In signal processing disciplines, this is known as N-th Delta Coding.)
+//
+// Good for varint coding integer sequences with polynomial trends.
+//
+// Instead of coding a sequence of values directly, code its nth-order discrete
+// derivative.  Overflow in integer addition and subtraction makes this a
+// lossless transform.
+//
+//                                       constant     linear      quadratic
+//                                        trend       trend         trend
+//                                      /        \  /        \  /           \_
+// input                               |0  0  0  0  1  2  3  4  9  16  25  36
+// 0th derivative(identity)            |0  0  0  0  1  2  3  4  9  16  25  36
+// 1st derivative(delta coding)        |   0  0  0  1  1  1  1  5   7   9  11
+// 2nd derivative(linear prediction)   |      0  0  1  0  0  0  4   2   2   2
+//                                      -------------------------------------
+//                                      0  1  2  3  4  5  6  7  8   9  10  11
+//                                                  n in sequence
+//
+// Higher-order codings can break even or be detrimental on other sequences.
+//
+//                                           random            oscillating
+//                                      /               \  /                  \_
+// input                               |5  9  6  1   8  8  2 -2   4  -4   6  -6
+// 0th derivative(identity)            |5  9  6  1   8  8  2 -2   4  -4   6  -6
+// 1st derivative(delta coding)        |   4 -3 -5   7  0 -6 -4   6  -8  10 -12
+// 2nd derivative(linear prediction)   |     -7 -2  12 -7 -6  2  10 -14  18 -22
+//                                      ---------------------------------------
+//                                      0  1  2  3  4   5  6  7   8   9  10  11
+//                                                  n in sequence
+//
+// Note that the nth derivative isn't available until sequence item n.  Earlier
+// values are coded at lower order.  For the above table, read 5 4 -7 -2 12 ...
+//
+// A caveat on class usage.  Encode() and Decode() share state.  Using both
+// without a Reset() in-between probably doesn't make sense.
+
+#ifndef S2_UTIL_CODING_NTH_DERIVATIVE_H_
+#define S2_UTIL_CODING_NTH_DERIVATIVE_H_
+
+#include "s2/base/integral_types.h"
+#include "s2/base/logging.h"
+
+class NthDerivativeCoder {
+ public:
+  // range of supported Ns: [ N_MIN, N_MAX ]
+  enum {
+    N_MIN = 0,
+    N_MAX = 10,
+  };
+
+  // Initialize a new NthDerivativeCoder of the given N.
+  explicit NthDerivativeCoder(int n);
+
+  // Encode the next value in the sequence.  Don't mix with Decode() calls.
+  int32 Encode(int32 k);
+
+  // Decode the next value in the sequence.  Don't mix with Encode() calls.
+  int32 Decode(int32 k);
+
+  // Reset state.
+  void Reset();
+
+  // accessors
+  int n() const { return n_; }
+
+ private:
+  int n_;  // derivative order of the coder (the N in NthDerivative)
+  int m_;  // the derivative order in which to code the next value(ramps to n_)
+  int32 memory_[N_MAX];  // value memory. [0] is oldest
+};
+
+// Implementation below.  Callers Ignore.
+//
+// Inlining the implementation roughly doubled the speed.  All other
+// optimization tricks failed miserably.
+
+#if ~0 != -1
+#error Sorry, this code needs twos complement integers.
+#endif
+
+inline NthDerivativeCoder::NthDerivativeCoder(int n) : n_(n) {
+  if (n < N_MIN || n > N_MAX) {
+    S2_LOG(ERROR) << "Unsupported N: " << n << ".  Using 0 instead.";
+    n_ = 0;
+  }
+  Reset();
+}
+
+inline int32 NthDerivativeCoder::Encode(int32 k) {
+  for (int i = 0; i < m_; ++i) {
+    uint32 delta = static_cast<uint32>(k) - memory_[i];
+    memory_[i] = k;
+    k = delta;
+  }
+  if (m_ < n_)
+    memory_[m_++] = k;
+  return k;
+}
+
+inline int32 NthDerivativeCoder::Decode(int32 k) {
+  if (m_ < n_)
+    m_++;
+  for (int i = m_ - 1; i >= 0; --i)
+    k = memory_[i] = memory_[i] + static_cast<uint32>(k);
+  return k;
+}
+
+inline void NthDerivativeCoder::Reset() {
+  for (int i = 0; i < n_; ++i)
+    memory_[i] = 0;
+  m_ = 0;
+}
+
+#endif  // S2_UTIL_CODING_NTH_DERIVATIVE_H_

package/third_party/s2geometry/src/s2/util/coding/transforms.h

@@ -0,0 +1,62 @@
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+//
+// Data transforms that can help code more efficiently.
+
+#ifndef S2_UTIL_CODING_TRANSFORMS_H_
+#define S2_UTIL_CODING_TRANSFORMS_H_
+
+#include "s2/base/integral_types.h"
+
+// ZigZag Transform
+//
+// Good for varint coding small signed integers centered around 0.
+//
+//       int32 ->     uint32
+// -------------------------
+//           0 ->          0
+//          -1 ->          1
+//           1 ->          2
+//          -2 ->          3
+//         ... ->        ...
+//  2147483647 -> 4294967294
+// -2147483648 -> 4294967295
+//
+//        >> encode >>
+//        << decode <<
+
+static inline uint32 ZigZagEncode(int32 n) {
+  // We need the cast to avoid an arithmetic shift.
+  uint32 sign = (static_cast<uint32>(n)) >> 31;
+  return (static_cast<uint32>(n) << 1) ^ (0u - sign);
+}
+
+static inline int32 ZigZagDecode(uint32 n) {
+  return (n >> 1) ^ (0u - (n & 1));
+}
+
+static inline uint64 ZigZagEncode64(int64 n) {
+  // We need the cast to avoid an arithmetic shift.
+  uint64 sign = (static_cast<uint64>(n)) >> 63;
+  return (static_cast<uint64>(n) << 1) ^ (0u - sign);
+}
+
+static inline int64 ZigZagDecode64(uint64 n) {
+  return (n >> 1) ^ (0u - (n & 1));
+}
+
+#endif  // S2_UTIL_CODING_TRANSFORMS_H_

package/third_party/s2geometry/src/s2/util/coding/varint.cc

@@ -0,0 +1,289 @@
+// Copyright 2001 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+
+#include "s2/util/coding/varint.h"
+
+#include <string>
+
+#include "s2/base/integral_types.h"
+
+#ifndef _MSC_VER
+const int Varint::kMax32;
+const int Varint::kMax64;
+const int Varint::kSlopBytes;
+#endif
+
+char* Varint::Encode32(char* sptr, uint32 v) {
+  return Encode32Inline(sptr, v);
+}
+
+char* Varint::Encode64(char* sptr, uint64 v) {
+  if (v < (1u << 28)) {
+    return Varint::Encode32(sptr, v);
+  } else {
+    // Operate on characters as unsigneds
+    unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr);
+    // Rather than computing four subresults and or'ing each with 0x80,
+    // we can do two ors now.  (Doing one now wouldn't work.)
+    const uint32 x32 = v | (1 << 7) | (1 << 21);
+    const uint32 y32 = v | (1 << 14) | (1 << 28);
+    *(ptr++) = x32;
+    *(ptr++) = y32 >> 7;
+    *(ptr++) = x32 >> 14;
+    *(ptr++) = y32 >> 21;
+    if (v < (1ull << 35)) {
+      *(ptr++) = v >> 28;
+      return reinterpret_cast<char*>(ptr);
+    } else {
+      *(ptr++) = (v >> 28) | (1 << 7);
+      return Varint::Encode32(reinterpret_cast<char*>(ptr), v >> 35);
+    }
+  }
+}
+
+const char* Varint::Parse32Fallback(const char* ptr, uint32* OUTPUT) {
+  return Parse32FallbackInline(ptr, OUTPUT);
+}
+
+const char* Varint::Parse64Fallback(const char* p, uint64* OUTPUT) {
+  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
+  assert(*ptr >= 128);
+#if defined(__x86_64__)
+  // This approach saves one redundant operation on the last byte (masking a
+  // byte that doesn't need it). This is conditional on x86 because:
+  // - PowerPC has specialized bit instructions that make masking and
+  //   shifting very efficient
+  // - x86 seems to be one of the few architectures that has a single
+  //   instruction to add 3 values.
+  //
+  // e.g.
+  // Input: 0xff, 0x40
+  // Mask & Or calculates: (0xff & 0x7f) | ((0x40 & 0x7f) << 7) = 0x207f
+  // Sub1 & Add calculates: 0xff         + ((0x40    - 1) << 7) = 0x207f
+  //
+  // The subtract one removes the bit set by the previous byte used to
+  // indicate that more bytes are present. It also has the potential to
+  // allow instructions like LEA to combine 2 adds into one instruction.
+  //
+  // E.g. on an x86 architecture, %rcx = %rax + (%rbx - 1) << 7 could be
+  // emitted as:
+  //   shlq $7, %rbx
+  //   leaq -0x80(%rax, %rbx), %rcx
+  //
+  // Fast path: need to accumulate data in upto three result fragments
+  //    res1    bits 0..27
+  //    res2    bits 28..55
+  //    res3    bits 56..63
+
+  uint64 byte, res1, res2 = 0, res3 = 0;
+  byte = *(ptr++); res1 = byte;
+  byte = *(ptr++); res1 += (byte - 1) <<  7; if (byte < 128) goto done1;
+  byte = *(ptr++); res1 += (byte - 1) << 14; if (byte < 128) goto done1;
+  byte = *(ptr++); res1 += (byte - 1) << 21; if (byte < 128) goto done1;
+
+  byte = *(ptr++); res2 = byte;              if (byte < 128) goto done2;
+  byte = *(ptr++); res2 += (byte - 1) <<  7; if (byte < 128) goto done2;
+  byte = *(ptr++); res2 += (byte - 1) << 14; if (byte < 128) goto done2;
+  byte = *(ptr++); res2 += (byte - 1) << 21; if (byte < 128) goto done2;
+
+  byte = *(ptr++); res3 = byte;              if (byte < 128) goto done3;
+  byte = *(ptr++); res3 += (byte - 1) <<  7; if (byte < 2) goto done3;
+
+  return nullptr;       // Value is too long to be a varint64
+
+ done1:
+  assert(res2 == 0);
+  assert(res3 == 0);
+  *OUTPUT = res1;
+  return reinterpret_cast<const char*>(ptr);
+
+ done2:
+  assert(res3 == 0);
+  *OUTPUT = res1 + ((res2 - 1) << 28);
+  return reinterpret_cast<const char*>(ptr);
+
+ done3:
+  *OUTPUT = res1 + ((res2 - 1) << 28) + ((res3 - 1) << 56);
+  return reinterpret_cast<const char*>(ptr);
+#else
+  uint32 byte, res1, res2=0, res3=0;
+  byte = *(ptr++); res1 = byte & 127;
+  byte = *(ptr++); res1 |= (byte & 127) <<  7; if (byte < 128) goto done1;
+  byte = *(ptr++); res1 |= (byte & 127) << 14; if (byte < 128) goto done1;
+  byte = *(ptr++); res1 |= (byte & 127) << 21; if (byte < 128) goto done1;
+
+  byte = *(ptr++); res2 = byte & 127;          if (byte < 128) goto done2;
+  byte = *(ptr++); res2 |= (byte & 127) <<  7; if (byte < 128) goto done2;
+  byte = *(ptr++); res2 |= (byte & 127) << 14; if (byte < 128) goto done2;
+  byte = *(ptr++); res2 |= (byte & 127) << 21; if (byte < 128) goto done2;
+
+  byte = *(ptr++); res3 = byte & 127;          if (byte < 128) goto done3;
+  byte = *(ptr++); res3 |= (byte & 127) <<  7; if (byte < 2) goto done3;
+
+  return nullptr;       // Value is too long to be a varint64
+
+ done1:
+  assert(res2 == 0);
+  assert(res3 == 0);
+  *OUTPUT = res1;
+  return reinterpret_cast<const char*>(ptr);
+
+ done2:
+  assert(res3 == 0);
+  *OUTPUT = res1 | (uint64(res2) << 28);
+  return reinterpret_cast<const char*>(ptr);
+
+ done3:
+  *OUTPUT = res1 | (uint64(res2) << 28) | (uint64(res3) << 56);
+  return reinterpret_cast<const char*>(ptr);
+#endif
+}
+
+const char* Varint::Parse32BackwardSlow(const char* ptr, const char* base,
+                                        uint32* OUTPUT) {
+  // Since this method is rarely called, for simplicity, we just skip backward
+  // and then parse forward.
+  const char* prev = Skip32BackwardSlow(ptr, base);
+  if (prev == nullptr)
+    return nullptr; // no value before 'ptr'
+
+  Parse32(prev, OUTPUT);
+  return prev;
+}
+
+const char* Varint::Parse64BackwardSlow(const char* ptr, const char* base,
+                                        uint64* OUTPUT) {
+  // Since this method is rarely called, for simplicity, we just skip backward
+  // and then parse forward.
+  const char* prev = Skip64BackwardSlow(ptr, base);
+  if (prev == nullptr)
+    return nullptr; // no value before 'ptr'
+
+  Parse64(prev, OUTPUT);
+  return prev;
+}
+
+const char* Varint::Parse64WithLimit(const char* p,
+                                     const char* l,
+                                     uint64* OUTPUT) {
+  if (p + kMax64 <= l) {
+    return Parse64(p, OUTPUT);
+  } else {
+    // See detailed comment in Varint::Parse64Fallback about this general
+    // approach.
+    const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
+    const unsigned char* limit = reinterpret_cast<const unsigned char*>(l);
+    uint64 b, result;
+#if defined(__x86_64__)
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result = b;              if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) <<  7; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 14; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 21; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 28; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 35; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 42; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 49; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 56; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result += (b - 1) << 63; if (b < 2) goto done;
+    return nullptr;       // Value is too long to be a varint64
+#else
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result = b & 127;          if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) <<  7; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 28; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 35; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 42; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 49; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 56; if (b < 128) goto done;
+    if (ptr >= limit) return nullptr;
+    b = *(ptr++); result |= (b & 127) << 63; if (b < 2) goto done;
+    return nullptr;       // Value is too long to be a varint64
+#endif
+   done:
+    *OUTPUT = result;
+    return reinterpret_cast<const char*>(ptr);
+  }
+}
+
+const char* Varint::Skip32BackwardSlow(const char* p, const char* b) {
+  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
+  const unsigned char* base = reinterpret_cast<const unsigned char*>(b);
+  assert(ptr >= base);
+
+  // If the initial pointer is at the base or if the previous byte is not
+  // the last byte of a varint, we return nullptr since there is nothing to
+  // skip.
+  if (ptr == base) return nullptr;
+  if (*(--ptr) > 127) return nullptr;
+
+  for (int i = 0; i < 5; i++) {
+    if (ptr == base)    return reinterpret_cast<const char*>(ptr);
+    if (*(--ptr) < 128) return reinterpret_cast<const char*>(ptr + 1);
+  }
+
+  return nullptr; // value is too long to be a varint32
+}
+
+const char* Varint::Skip64BackwardSlow(const char* p, const char* b) {
+  const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
+  const unsigned char* base = reinterpret_cast<const unsigned char*>(b);
+  assert(ptr >= base);
+
+  // If the initial pointer is at the base or if the previous byte is not
+  // the last byte of a varint, we return nullptr since there is nothing to
+  // skip.
+  if (ptr == base) return nullptr;
+  if (*(--ptr) > 127) return nullptr;
+
+  for (int i = 0; i < 10; i++) {
+    if (ptr == base)    return reinterpret_cast<const char*>(ptr);
+    if (*(--ptr) < 128) return reinterpret_cast<const char*>(ptr + 1);
+  }
+
+  return nullptr; // value is too long to be a varint64
+}
+
+void Varint::Append32Slow(string* s, uint32 value) {
+  const size_t start = s->size();
+  s->resize(start + Varint::Length32(value));
+  Varint::Encode32(&((*s)[start]), value);
+}
+
+void Varint::Append64Slow(string* s, uint64 value) {
+  const size_t start = s->size();
+  s->resize(start + Varint::Length64(value));
+  Varint::Encode64(&((*s)[start]), value);
+}