@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/s1angle.h

@@ -0,0 +1,336 @@
+// 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.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#ifndef S2_S1ANGLE_H_
+#define S2_S1ANGLE_H_
+
+#include <cmath>
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+#include "s2/base/integral_types.h"
+#include "s2/_fp_contract_off.h"
+#include "s2/s2point.h"
+#include "s2/util/math/mathutil.h"
+#include "s2/util/math/vector.h"
+
+class S2LatLng;
+
+#ifndef SWIG
+#define IFNDEF_SWIG(x) x
+#else
+#define IFNDEF_SWIG(x)
+#endif
+
+// This class represents a one-dimensional angle (as opposed to a
+// two-dimensional solid angle).  It has methods for converting angles to
+// or from radians, degrees, and the E5/E6/E7 representations (i.e. degrees
+// multiplied by 1e5/1e6/1e7 and rounded to the nearest integer).
+//
+// The internal representation is a double-precision value in radians, so
+// conversion to and from radians is exact.  Conversions between E5, E6, E7,
+// and Degrees are not always exact; for example, Degrees(3.1) is different
+// from E6(3100000) or E7(310000000).  However, the following properties are
+// guaranteed for any integer "n", provided that "n" is in the input range of
+// both functions:
+//
+//     Degrees(n) == E6(1000000 * n)
+//     Degrees(n) == E7(10000000 * n)
+//          E6(n) == E7(10 * n)
+//
+// The corresponding properties are *not* true for E5, so if you use E5 then
+// don't test for exact equality when comparing to other formats such as
+// Degrees or E7.
+//
+// The following conversions between degrees and radians are exact:
+//
+//          Degrees(180) == Radians(M_PI)
+//       Degrees(45 * k) == Radians(k * M_PI / 4)  for k == 0..8
+//
+// These identities also hold when the arguments are scaled up or down by any
+// power of 2.  Some similar identities are also true, for example,
+// Degrees(60) == Radians(M_PI / 3), but be aware that this type of identity
+// does not hold in general.  For example, Degrees(3) != Radians(M_PI / 60).
+//
+// Similarly, the conversion to radians means that Angle::Degrees(x).degrees()
+// does not always equal "x".  For example,
+//
+//         S1Angle::Degrees(45 * k).degrees() == 45 * k      for k == 0..8
+//   but       S1Angle::Degrees(60).degrees() != 60.
+//
+// This means that when testing for equality, you should allow for numerical
+// errors (EXPECT_DOUBLE_EQ) or convert to discrete E5/E6/E7 values first.
+//
+// CAVEAT: All of the above properties depend on "double" being the usual
+// 64-bit IEEE 754 type (which is true on almost all modern platforms).
+//
+// This class is intended to be copied by value as desired.  It uses
+// the default copy constructor and assignment operator.
+class S1Angle {
+ public:
+  // These methods construct S1Angle objects from their measure in radians
+  // or degrees.
+  static constexpr S1Angle Radians(double radians);
+  static constexpr S1Angle Degrees(double degrees);
+  static constexpr S1Angle E5(int32 e5);
+  static constexpr S1Angle E6(int32 e6);
+  static constexpr S1Angle E7(int32 e7);
+
+  // Convenience functions -- to use when args have been fixed32s in protos.
+  //
+  // The arguments are static_cast into int32, so very large unsigned values
+  // are treated as negative numbers.
+  static constexpr S1Angle UnsignedE6(uint32 e6);
+  static constexpr S1Angle UnsignedE7(uint32 e7);
+
+  // The default constructor yields a zero angle.  This is useful for STL
+  // containers and class methods with output arguments.
+  IFNDEF_SWIG(constexpr) S1Angle() : radians_(0) {}
+
+  // Return an angle larger than any finite angle.
+  static constexpr S1Angle Infinity();
+
+  // A explicit shorthand for the default constructor.
+  static constexpr S1Angle Zero();
+
+  // Return the angle between two points, which is also equal to the distance
+  // between these points on the unit sphere.  The points do not need to be
+  // normalized.  This function has a maximum error of 3.25 * DBL_EPSILON (or
+  // 2.5 * DBL_EPSILON for angles up to 1 radian). If either point is
+  // zero-length (e.g. an uninitialized S2Point), or almost zero-length, the
+  // resulting angle will be zero.
+  S1Angle(const S2Point& x, const S2Point& y);
+
+  // Like the constructor above, but return the angle (i.e., distance) between
+  // two S2LatLng points.  This function has about 15 digits of accuracy for
+  // small distances but only about 8 digits of accuracy as the distance
+  // approaches 180 degrees (i.e., nearly-antipodal points).
+  S1Angle(const S2LatLng& x, const S2LatLng& y);
+
+  constexpr double radians() const;
+  constexpr double degrees() const;
+
+  int32 e5() const;
+  int32 e6() const;
+  int32 e7() const;
+
+  // Return the absolute value of an angle.
+  S1Angle abs() const;
+
+  // Comparison operators.
+  friend bool operator==(S1Angle x, S1Angle y);
+  friend bool operator!=(S1Angle x, S1Angle y);
+  friend bool operator<(S1Angle x, S1Angle y);
+  friend bool operator>(S1Angle x, S1Angle y);
+  friend bool operator<=(S1Angle x, S1Angle y);
+  friend bool operator>=(S1Angle x, S1Angle y);
+
+  // Simple arithmetic operators for manipulating S1Angles.
+  friend S1Angle operator-(S1Angle a);
+  friend S1Angle operator+(S1Angle a, S1Angle b);
+  friend S1Angle operator-(S1Angle a, S1Angle b);
+  friend S1Angle operator*(double m, S1Angle a);
+  friend S1Angle operator*(S1Angle a, double m);
+  friend S1Angle operator/(S1Angle a, double m);
+  friend double operator/(S1Angle a, S1Angle b);
+  S1Angle& operator+=(S1Angle a);
+  S1Angle& operator-=(S1Angle a);
+  S1Angle& operator*=(double m);
+  S1Angle& operator/=(double m);
+
+  // Trigonmetric functions (not necessary but slightly more convenient).
+  friend double sin(S1Angle a);
+  friend double cos(S1Angle a);
+  friend double tan(S1Angle a);
+
+  // Return the angle normalized to the range (-180, 180] degrees.
+  S1Angle Normalized() const;
+
+  // Normalize this angle to the range (-180, 180] degrees.
+  void Normalize();
+
+  // When S1Angle is used as a key in one of the btree container types
+  // (util/btree), indicate that linear rather than binary search should be
+  // used.  This is much faster when the comparison function is cheap.
+  typedef std::true_type goog_btree_prefer_linear_node_search;
+
+ private:
+  explicit IFNDEF_SWIG(constexpr) S1Angle(double radians) : radians_(radians) {}
+  double radians_;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline constexpr S1Angle S1Angle::Infinity() {
+  return S1Angle(std::numeric_limits<double>::infinity());
+}
+
+inline constexpr S1Angle S1Angle::Zero() {
+  return S1Angle(0);
+}
+
+inline constexpr double S1Angle::radians() const {
+  return radians_;
+}
+
+inline constexpr double S1Angle::degrees() const {
+  return (180 / M_PI) * radians_;
+}
+
+// Note that the E5, E6, and E7 conversion involve two multiplications rather
+// than one.  This is mainly for backwards compatibility (changing this would
+// break many tests), but it does have the nice side effect that conversions
+// between Degrees, E6, and E7 are exact when the arguments are integers.
+
+inline int32 S1Angle::e5() const {
+  return MathUtil::FastIntRound(1e5 * degrees());
+}
+
+inline int32 S1Angle::e6() const {
+  return MathUtil::FastIntRound(1e6 * degrees());
+}
+
+inline int32 S1Angle::e7() const {
+  return MathUtil::FastIntRound(1e7 * degrees());
+}
+
+inline S1Angle S1Angle::abs() const {
+  return S1Angle(std::fabs(radians_));
+}
+
+inline bool operator==(S1Angle x, S1Angle y) {
+  return x.radians() == y.radians();
+}
+
+inline bool operator!=(S1Angle x, S1Angle y) {
+  return x.radians() != y.radians();
+}
+
+inline bool operator<(S1Angle x, S1Angle y) {
+  return x.radians() < y.radians();
+}
+
+inline bool operator>(S1Angle x, S1Angle y) {
+  return x.radians() > y.radians();
+}
+
+inline bool operator<=(S1Angle x, S1Angle y) {
+  return x.radians() <= y.radians();
+}
+
+inline bool operator>=(S1Angle x, S1Angle y) {
+  return x.radians() >= y.radians();
+}
+
+inline S1Angle operator-(S1Angle a) {
+  return S1Angle::Radians(-a.radians());
+}
+
+inline S1Angle operator+(S1Angle a, S1Angle b) {
+  return S1Angle::Radians(a.radians() + b.radians());
+}
+
+inline S1Angle operator-(S1Angle a, S1Angle b) {
+  return S1Angle::Radians(a.radians() - b.radians());
+}
+
+inline S1Angle operator*(double m, S1Angle a) {
+  return S1Angle::Radians(m * a.radians());
+}
+
+inline S1Angle operator*(S1Angle a, double m) {
+  return S1Angle::Radians(m * a.radians());
+}
+
+inline S1Angle operator/(S1Angle a, double m) {
+  return S1Angle::Radians(a.radians() / m);
+}
+
+inline double operator/(S1Angle a, S1Angle b) {
+  return a.radians() / b.radians();
+}
+
+inline S1Angle& S1Angle::operator+=(S1Angle a) {
+  radians_ += a.radians();
+  return *this;
+}
+
+inline S1Angle& S1Angle::operator-=(S1Angle a) {
+  radians_ -= a.radians();
+  return *this;
+}
+
+inline S1Angle& S1Angle::operator*=(double m) {
+  radians_ *= m;
+  return *this;
+}
+
+inline S1Angle& S1Angle::operator/=(double m) {
+  radians_ /= m;
+  return *this;
+}
+
+inline double sin(S1Angle a) {
+  return sin(a.radians());
+}
+
+inline double cos(S1Angle a) {
+  return cos(a.radians());
+}
+
+inline double tan(S1Angle a) {
+  return tan(a.radians());
+}
+
+inline constexpr S1Angle S1Angle::Radians(double radians) {
+  return S1Angle(radians);
+}
+
+inline constexpr S1Angle S1Angle::Degrees(double degrees) {
+  return S1Angle((M_PI / 180) * degrees);
+}
+
+inline constexpr S1Angle S1Angle::E5(int32 e5) {
+  return Degrees(1e-5 * e5);
+}
+
+inline constexpr S1Angle S1Angle::E6(int32 e6) {
+  return Degrees(1e-6 * e6);
+}
+
+inline constexpr S1Angle S1Angle::E7(int32 e7) {
+  return Degrees(1e-7 * e7);
+}
+
+inline constexpr S1Angle S1Angle::UnsignedE6(uint32 e6) {
+  return E6(static_cast<int32>(e6));
+}
+
+inline constexpr S1Angle S1Angle::UnsignedE7(uint32 e7) {
+  return E7(static_cast<int32>(e7));
+}
+
+// Writes the angle in degrees with 7 digits of precision after the
+// decimal point, e.g. "17.3745904".
+std::ostream& operator<<(std::ostream& os, S1Angle a);
+
+#undef IFNDEF_SWIG
+
+#endif  // S2_S1ANGLE_H_

package/third_party/s2geometry/src/s2/s1angle_test.cc

@@ -0,0 +1,185 @@
+// 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.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s1angle.h"
+
+#include <gtest/gtest.h>
+
+#include "s2/base/integral_types.h"
+#include "s2/base/logging.h"
+#include "s2/s2latlng.h"
+#include "s2/s2testing.h"
+
+TEST(S1Angle, DefaultConstructor) {
+  // Check that the default constructor returns an angle of 0.
+  S1Angle a;
+  EXPECT_EQ(0, a.radians());
+}
+
+TEST(S1Angle, Infinity) {
+  EXPECT_LT(S1Angle::Radians(1e30), S1Angle::Infinity());
+  EXPECT_LT(-S1Angle::Infinity(), S1Angle::Zero());
+  EXPECT_EQ(S1Angle::Infinity(), S1Angle::Infinity());
+}
+
+TEST(S1Angle, Zero) {
+  EXPECT_EQ(S1Angle::Radians(0), S1Angle::Zero());
+}
+
+TEST(S1Angle, PiRadiansExactly180Degrees) {
+  // Check that the conversion between Pi radians and 180 degrees is exact.
+  EXPECT_EQ(M_PI, S1Angle::Radians(M_PI).radians());
+  EXPECT_EQ(180.0, S1Angle::Radians(M_PI).degrees());
+  EXPECT_EQ(M_PI, S1Angle::Degrees(180).radians());
+  EXPECT_EQ(180.0, S1Angle::Degrees(180).degrees());
+
+  EXPECT_EQ(90.0, S1Angle::Radians(M_PI_2).degrees());
+
+  // Check negative angles.
+  EXPECT_EQ(-90.0, S1Angle::Radians(-M_PI_2).degrees());
+  EXPECT_EQ(-M_PI_4, S1Angle::Degrees(-45).radians());
+}
+
+TEST(S1Angle, E5E6E7Representations) {
+  // Check that E5/E6/E7 representations work as expected.
+  EXPECT_DOUBLE_EQ(S1Angle::Degrees(-45).radians(),
+                   S1Angle::E5(-4500000).radians());
+  EXPECT_DOUBLE_EQ(S1Angle::Degrees(-60).radians(),
+                   S1Angle::E6(-60000000).radians());
+  EXPECT_DOUBLE_EQ(S1Angle::Degrees(75).radians(),
+                   S1Angle::E7(750000000).radians());
+  EXPECT_EQ(-17256123, S1Angle::Degrees(-172.56123).e5());
+  EXPECT_EQ(12345678, S1Angle::Degrees(12.345678).e6());
+  EXPECT_EQ(-123456789, S1Angle::Degrees(-12.3456789).e7());
+}
+
+TEST(S1Angle, E6E7RepresentationsUnsigned) {
+  // Check that unsigned E6/E7 representations work as expected.
+  EXPECT_DOUBLE_EQ(
+      S1Angle::Degrees(60).radians(),
+      S1Angle::UnsignedE6(static_cast<uint32>(60000000)).radians());
+  EXPECT_DOUBLE_EQ(
+      S1Angle::Degrees(-60).radians(),
+      S1Angle::UnsignedE6(static_cast<uint32>(-60000000)).radians());
+  EXPECT_DOUBLE_EQ(
+      S1Angle::Degrees(75).radians(),
+      S1Angle::UnsignedE7(static_cast<uint32>(750000000)).radians());
+  EXPECT_DOUBLE_EQ(
+      S1Angle::Degrees(-75).radians(),
+      S1Angle::UnsignedE7(static_cast<uint32>(-750000000)).radians());
+}
+
+TEST(S1Angle, NormalizeCorrectlyCanonicalizesAngles) {
+  EXPECT_DOUBLE_EQ(0.0, S1Angle::Degrees(360.0).Normalized().degrees());
+  EXPECT_DOUBLE_EQ(-90.0, S1Angle::Degrees(-90.0).Normalized().degrees());
+  EXPECT_DOUBLE_EQ(180.0, S1Angle::Degrees(-180.0).Normalized().degrees());
+  EXPECT_DOUBLE_EQ(180.0, S1Angle::Degrees(180.0).Normalized().degrees());
+  EXPECT_DOUBLE_EQ(180.0, S1Angle::Degrees(540.0).Normalized().degrees());
+  EXPECT_DOUBLE_EQ(90.0, S1Angle::Degrees(-270.0).Normalized().degrees());
+}
+
+TEST(S1Angle, ArithmeticOperationsOnAngles) {
+  EXPECT_DOUBLE_EQ(0.3, S1Angle::Radians(-0.3).abs().radians());
+  EXPECT_DOUBLE_EQ(-0.1, (-S1Angle::Radians(0.1)).radians());
+  EXPECT_DOUBLE_EQ(0.4,
+                   (S1Angle::Radians(0.1) + S1Angle::Radians(0.3)).radians());
+  EXPECT_DOUBLE_EQ(-0.2,
+                   (S1Angle::Radians(0.1) - S1Angle::Radians(0.3)).radians());
+  EXPECT_DOUBLE_EQ(0.6, (2 * S1Angle::Radians(0.3)).radians());
+  EXPECT_DOUBLE_EQ(0.6, (S1Angle::Radians(0.3) * 2).radians());
+  EXPECT_DOUBLE_EQ(0.15, (S1Angle::Radians(0.3) / 2).radians());
+  EXPECT_DOUBLE_EQ(0.5, (S1Angle::Radians(0.3) / S1Angle::Radians(0.6)));
+
+  S1Angle tmp = S1Angle::Radians(1.0);
+  tmp += S1Angle::Radians(0.5);
+  EXPECT_DOUBLE_EQ(1.5, tmp.radians());
+  tmp -= S1Angle::Radians(1.0);
+  EXPECT_DOUBLE_EQ(0.5, tmp.radians());
+  tmp *= 5;
+  EXPECT_DOUBLE_EQ(2.5, tmp.radians());
+  tmp /= 2;
+  EXPECT_DOUBLE_EQ(1.25, tmp.radians());
+}
+
+TEST(S1Angle, Trigonometry) {
+  // Spot check a few angles to ensure that the correct function is called.
+  EXPECT_DOUBLE_EQ(1, cos(S1Angle::Degrees(0)));
+  EXPECT_DOUBLE_EQ(1, sin(S1Angle::Degrees(90)));
+  EXPECT_DOUBLE_EQ(1, tan(S1Angle::Degrees(45)));
+}
+
+TEST(S1Angle, ConstructorsThatMeasureAngles) {
+  EXPECT_DOUBLE_EQ(M_PI_2,
+                   S1Angle(S2Point(1, 0, 0), S2Point(0, 0, 2)).radians());
+  EXPECT_DOUBLE_EQ(0.0, S1Angle(S2Point(1, 0, 0), S2Point(1, 0, 0)).radians());
+  EXPECT_NEAR(50.0,
+              S1Angle(S2LatLng::FromDegrees(20, 20),
+                      S2LatLng::FromDegrees(70, 20)).degrees(),
+              1e-13);
+}
+
+TEST(S1Angle, TestFormatting) {
+  std::ostringstream ss;
+  ss << S1Angle::Degrees(180.0);
+  EXPECT_EQ("180.0000000", ss.str());
+}
+
+// The current implementation guarantees exact conversions between
+// Degrees() and E6() when the Degrees() argument is an integer.
+TEST(S1Angle, DegreesVsE6) {
+  for (int i = 0; i <= 180; ++i) {
+    EXPECT_EQ(S1Angle::Degrees(i), S1Angle::E6(1000000 * i));
+  }
+}
+
+// The current implementation guarantees exact conversions between
+// Degrees() and E7() when the Degrees() argument is an integer.
+TEST(S1Angle, DegreesVsE7) {
+  for (int i = 0; i <= 180; ++i) {
+    EXPECT_EQ(S1Angle::Degrees(i), S1Angle::E7(10000000 * i));
+  }
+}
+
+// The current implementation guarantees exact conversions between
+// E6() and E7() when the E6() argument is an integer.
+TEST(S1Angle, E6VsE7) {
+  S2Testing::rnd.Reset(FLAGS_s2_random_seed);
+  for (int iter = 0; iter < 1000; ++iter) {
+    int i = S2Testing::rnd.Uniform(180000000);
+    EXPECT_EQ(S1Angle::E6(i), S1Angle::E7(10 * i));
+  }
+}
+
+// The current implementation guarantees certain exact conversions between
+// degrees and radians (see the header file for details).
+TEST(S1Angle, DegreesVsRadians) {
+  for (int k = -8; k <= 8; ++k) {
+    EXPECT_EQ(S1Angle::Degrees(45 * k), S1Angle::Radians(k * M_PI / 4));
+    EXPECT_EQ(45 * k, S1Angle::Degrees(45 * k).degrees());
+  }
+  for (int k = 0; k <= 30; ++k) {
+    int n = 1 << k;
+    EXPECT_EQ(S1Angle::Degrees(180. / n), S1Angle::Radians(M_PI / n));
+    EXPECT_EQ(S1Angle::Degrees(60. / n), S1Angle::Radians(M_PI / (3. * n)));
+    EXPECT_EQ(S1Angle::Degrees(36. / n), S1Angle::Radians(M_PI / (5. * n)));
+    EXPECT_EQ(S1Angle::Degrees(20. / n), S1Angle::Radians(M_PI / (9. * n)));
+    EXPECT_EQ(S1Angle::Degrees(4. / n), S1Angle::Radians(M_PI / (45. * n)));
+  }
+  // We also spot check a couple of non-identities.
+  EXPECT_NE(S1Angle::Degrees(3), S1Angle::Radians(M_PI / 60));
+  EXPECT_NE(60, S1Angle::Degrees(60).degrees());
+}

package/third_party/s2geometry/src/s2/s1chord_angle.cc

@@ -0,0 +1,159 @@
+// Copyright 2013 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.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s1chord_angle.h"
+
+#include <cfloat>
+#include <cmath>
+
+#include "s2/s1angle.h"
+#include "s2/s2pointutil.h"
+
+using std::max;
+using std::min;
+// Android with gnustl has ::nextafter but not std::nextafter.
+// https://github.com/android-ndk/ndk/issues/82
+// Check for gnustl with _GLIBCXX_CMATH, which is its cmath include
+// guard.
+#if !defined(__ANDROID__) || !defined(_GLIBCXX_CMATH)
+using std::nextafter;
+#endif
+
+static constexpr double kMaxLength2 = 4.0;
+
+S1ChordAngle::S1ChordAngle(S1Angle angle) {
+  if (angle.radians() < 0) {
+    *this = Negative();
+  } else if (angle == S1Angle::Infinity()) {
+    *this = Infinity();
+  } else {
+    // The chord length is 2 * sin(angle / 2).
+    double length = 2 * sin(0.5 * min(M_PI, angle.radians()));
+    length2_ = length * length;
+  }
+  S2_DCHECK(is_valid());
+}
+
+S1Angle S1ChordAngle::ToAngle() const {
+  if (is_negative()) return S1Angle::Radians(-1);
+  if (is_infinity()) return S1Angle::Infinity();
+  return S1Angle::Radians(2 * asin(0.5 * sqrt(length2_)));
+}
+
+bool S1ChordAngle::is_valid() const {
+  return (length2_ >= 0 && length2_ <= kMaxLength2) || is_special();
+}
+
+S1ChordAngle S1ChordAngle::Successor() const {
+  if (length2_ >= kMaxLength2) return Infinity();
+  if (length2_ < 0.0) return Zero();
+  return S1ChordAngle(nextafter(length2_, 10.0));
+}
+
+S1ChordAngle S1ChordAngle::Predecessor() const {
+  if (length2_ <= 0.0) return Negative();
+  if (length2_ > kMaxLength2) return Straight();
+  return S1ChordAngle(nextafter(length2_, -10.0));
+}
+
+S1ChordAngle S1ChordAngle::PlusError(double error) const {
+  // If angle is Negative() or Infinity(), don't change it.
+  // Otherwise clamp it to the valid range.
+  if (is_special()) return *this;
+  return S1ChordAngle(max(0.0, min(kMaxLength2, length2_ + error)));
+}
+
+double S1ChordAngle::GetS2PointConstructorMaxError() const {
+  // There is a relative error of 2.5 * DBL_EPSILON when computing the squared
+  // distance, plus a relative error of 2 * DBL_EPSILON and an absolute error
+  // of (16 * DBL_EPSILON**2) because the lengths of the input points may
+  // differ from 1 by up to (2 * DBL_EPSILON) each.  (This is the maximum
+  // length error in S2Point::Normalize.)
+  return 4.5 * DBL_EPSILON * length2_ + 16 * DBL_EPSILON * DBL_EPSILON;
+}
+
+double S1ChordAngle::GetS1AngleConstructorMaxError() const {
+  // Assuming that an accurate math library is being used, the sin() call and
+  // the multiply each have a relative error of 0.5 * DBL_EPSILON.
+  return DBL_EPSILON * length2_;
+}
+
+S1ChordAngle operator+(S1ChordAngle a, S1ChordAngle b) {
+  // Note that this method is much more efficient than converting the chord
+  // angles to S1Angles and adding those.  It requires only one square root
+  // plus a few additions and multiplications.
+  S2_DCHECK(!a.is_special());
+  S2_DCHECK(!b.is_special());
+
+  // Optimization for the common case where "b" is an error tolerance
+  // parameter that happens to be set to zero.
+  double a2 = a.length2(), b2 = b.length2();
+  if (b2 == 0) return a;
+
+  // Clamp the angle sum to at most 180 degrees.
+  if (a2 + b2 >= kMaxLength2) return S1ChordAngle::Straight();
+
+  // Let "a" and "b" be the (non-squared) chord lengths, and let c = a+b.
+  // Let A, B, and C be the corresponding half-angles (a = 2*sin(A), etc).
+  // Then the formula below can be derived from c = 2 * sin(A+B) and the
+  // relationships   sin(A+B) = sin(A)*cos(B) + sin(B)*cos(A)
+  //                 cos(X) = sqrt(1 - sin^2(X)) .
+
+  double x = a2 * (1 - 0.25 * b2);  // is_valid() => non-negative
+  double y = b2 * (1 - 0.25 * a2);  // is_valid() => non-negative
+  return S1ChordAngle(min(kMaxLength2, x + y + 2 * sqrt(x * y)));
+}
+
+S1ChordAngle operator-(S1ChordAngle a, S1ChordAngle b) {
+  // See comments in operator+().
+  S2_DCHECK(!a.is_special());
+  S2_DCHECK(!b.is_special());
+  double a2 = a.length2(), b2 = b.length2();
+  if (b2 == 0) return a;
+  if (a2 <= b2) return S1ChordAngle::Zero();
+  double x = a2 * (1 - 0.25 * b2);
+  double y = b2 * (1 - 0.25 * a2);
+  return S1ChordAngle(max(0.0, x + y - 2 * sqrt(x * y)));
+}
+
+double sin2(S1ChordAngle a) {
+  S2_DCHECK(!a.is_special());
+  // Let "a" be the (non-squared) chord length, and let A be the corresponding
+  // half-angle (a = 2*sin(A)).  The formula below can be derived from:
+  //   sin(2*A) = 2 * sin(A) * cos(A)
+  //   cos^2(A) = 1 - sin^2(A)
+  // This is much faster than converting to an angle and computing its sine.
+  return a.length2() * (1 - 0.25 * a.length2());
+}
+
+double sin(S1ChordAngle a) {
+  return sqrt(sin2(a));
+}
+
+double cos(S1ChordAngle a) {
+  // cos(2*A) = cos^2(A) - sin^2(A) = 1 - 2*sin^2(A)
+  S2_DCHECK(!a.is_special());
+  return 1 - 0.5 * a.length2();
+}
+
+double tan(S1ChordAngle a) {
+  return sin(a) / cos(a);
+}
+
+std::ostream& operator<<(std::ostream& os, S1ChordAngle a) {
+  return os << a.ToAngle();
+}