update pathops to circle sort

src/pathops/SkPathOpsTypes.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPathOpsTypes_DEFINED
 #define SkPathOpsTypes_DEFINED
 
 #include <float.h>  // for FLT_EPSILON
@@ skipping 67 matching lines @@
 int UlpsDistance(float a, float b);
 inline int UlpsDistance(double a, double b) {
     return UlpsDistance(SkDoubleToScalar(a), SkDoubleToScalar(b));
 }
 
 // FLT_EPSILON == 1.19209290E-07 == 1 / (2 ^ 23)
 // DBL_EPSILON == 2.22045e-16
 const double FLT_EPSILON_CUBED = FLT_EPSILON * FLT_EPSILON * FLT_EPSILON;
 const double FLT_EPSILON_HALF = FLT_EPSILON / 2;
 const double FLT_EPSILON_DOUBLE = FLT_EPSILON * 2;
+const double FLT_EPSILON_ORDERABLE_ERR = FLT_EPSILON * 16;
 const double FLT_EPSILON_SQUARED = FLT_EPSILON * FLT_EPSILON;
 const double FLT_EPSILON_SQRT = sqrt(FLT_EPSILON);
 const double FLT_EPSILON_INVERSE = 1 / FLT_EPSILON;
 const double DBL_EPSILON_ERR = DBL_EPSILON * 4;  // FIXME: tune -- allow a few bits of error
 const double DBL_EPSILON_SUBDIVIDE_ERR = DBL_EPSILON * 16;
 const double ROUGH_EPSILON = FLT_EPSILON * 64;
 const double MORE_ROUGH_EPSILON = FLT_EPSILON * 256;
 
 inline bool approximately_zero(double x) {
     return fabs(x) < FLT_EPSILON;
@@ skipping 16 matching lines @@
 }
 
 inline bool approximately_zero_half(double x) {
     return fabs(x) < FLT_EPSILON_HALF;
 }
 
 inline bool approximately_zero_double(double x) {
     return fabs(x) < FLT_EPSILON_DOUBLE;
 }
 
+inline bool approximately_zero_orderable(double x) {
+    return fabs(x) < FLT_EPSILON_ORDERABLE_ERR;
+}
+
 inline bool approximately_zero_squared(double x) {
     return fabs(x) < FLT_EPSILON_SQUARED;
 }
 
 inline bool approximately_zero_sqrt(double x) {
     return fabs(x) < FLT_EPSILON_SQRT;
 }
 
 inline bool roughly_zero(double x) {
     return fabs(x) < ROUGH_EPSILON;
 }
 
 inline bool approximately_zero_inverse(double x) {
     return fabs(x) > FLT_EPSILON_INVERSE;
 }
 
 // OPTIMIZATION: if called multiple times with the same denom, we want to pass 1/y instead
 inline bool approximately_zero_when_compared_to(double x, double y) {
-    return x == 0 || fabs(x / y) < FLT_EPSILON;
+    return x == 0 || fabs(x) < fabs(y * FLT_EPSILON);
 }
 
 // Use this for comparing Ts in the range of 0 to 1. For general numbers (larger and smaller) use
 // AlmostEqualUlps instead.
 inline bool approximately_equal(double x, double y) {
     return approximately_zero(x - y);
 }
 
 inline bool precisely_equal(double x, double y) {
     return precisely_zero(x - y);
 }
 
 inline bool precisely_subdivide_equal(double x, double y) {
     return precisely_subdivide_zero(x - y);
 }
 
 inline bool approximately_equal_half(double x, double y) {
     return approximately_zero_half(x - y);
 }
 
 inline bool approximately_equal_double(double x, double y) {
     return approximately_zero_double(x - y);
 }
 
+inline bool approximately_equal_orderable(double x, double y) {
+    return approximately_zero_orderable(x - y);
+}
+
 inline bool approximately_equal_squared(double x, double y) {
     return approximately_equal(x, y);
 }
 
 inline bool approximately_greater(double x, double y) {
     return x - FLT_EPSILON >= y;
 }
 
+inline bool approximately_greater_double(double x, double y) {
+    return x - FLT_EPSILON_DOUBLE >= y;
+}
+
+inline bool approximately_greater_orderable(double x, double y) {
+    return x - FLT_EPSILON_ORDERABLE_ERR >= y;
+}
+
 inline bool approximately_greater_or_equal(double x, double y) {
     return x + FLT_EPSILON > y;
 }
 
+inline bool approximately_greater_or_equal_double(double x, double y) {
+    return x + FLT_EPSILON_DOUBLE > y;
+}
+
+inline bool approximately_greater_or_equal_orderable(double x, double y) {
+    return x + FLT_EPSILON_ORDERABLE_ERR > y;
+}
+
 inline bool approximately_lesser(double x, double y) {
     return x + FLT_EPSILON <= y;
 }
 
+inline bool approximately_lesser_double(double x, double y) {
+    return x + FLT_EPSILON_DOUBLE <= y;
+}
+
+inline bool approximately_lesser_orderable(double x, double y) {
+    return x + FLT_EPSILON_ORDERABLE_ERR <= y;
+}
+
 inline bool approximately_lesser_or_equal(double x, double y) {
     return x - FLT_EPSILON < y;
 }
 
+inline bool approximately_lesser_or_equal_double(double x, double y) {
+    return x - FLT_EPSILON_DOUBLE < y;
+}
+
+inline bool approximately_lesser_or_equal_orderable(double x, double y) {
+    return x - FLT_EPSILON_ORDERABLE_ERR < y;
+}
+
 inline bool approximately_greater_than_one(double x) {
     return x > 1 - FLT_EPSILON;
 }
 
 inline bool precisely_greater_than_one(double x) {
     return x > 1 - DBL_EPSILON_ERR;
 }
 
 inline bool approximately_less_than_zero(double x) {
     return x < FLT_EPSILON;
 }
 
 inline bool precisely_less_than_zero(double x) {
     return x < DBL_EPSILON_ERR;
 }
 
 inline bool approximately_negative(double x) {
     return x < FLT_EPSILON;
 }
 
+inline bool approximately_negative_orderable(double x) {
+    return x < FLT_EPSILON_ORDERABLE_ERR;
+}
+
 inline bool precisely_negative(double x) {
     return x < DBL_EPSILON_ERR;
 }
 
 inline bool approximately_one_or_less(double x) {
     return x < 1 + FLT_EPSILON;
 }
 
+inline bool approximately_one_or_less_double(double x) {
+    return x < 1 + FLT_EPSILON_DOUBLE;
+}
+
 inline bool approximately_positive(double x) {
     return x > -FLT_EPSILON;
 }
 
 inline bool approximately_positive_squared(double x) {
     return x > -(FLT_EPSILON_SQUARED);
 }
 
 inline bool approximately_zero_or_more(double x) {
     return x > -FLT_EPSILON;
 }
 
+inline bool approximately_zero_or_more_double(double x) {
+    return x > -FLT_EPSILON_DOUBLE;
+}
+
+inline bool approximately_between_orderable(double a, double b, double c) {
+    return a <= c
+            ? approximately_negative_orderable(a - b) && approximately_negative_orderable(b - c)
+            : approximately_negative_orderable(b - a) && approximately_negative_orderable(c - b);
+}
+
 inline bool approximately_between(double a, double b, double c) {
     return a <= c ? approximately_negative(a - b) && approximately_negative(b - c)
             : approximately_negative(b - a) && approximately_negative(c - b);
 }
 
 inline bool precisely_between(double a, double b, double c) {
     return a <= c ? precisely_negative(a - b) && precisely_negative(b - c)
             : precisely_negative(b - a) && precisely_negative(c - b);
 }
 
@@ skipping 67 matching lines @@
 /* Returns 1 if negative, 2 if zero, 4 if positive
 */
 inline int SkDSideBit(double x) {
     return 1 << SKDSide(x);
 }
 
 inline double SkPinT(double t) {
     return precisely_less_than_zero(t) ? 0 : precisely_greater_than_one(t) ? 1 : t;
 }
 
-#ifdef SK_DEBUG
-inline void DebugDumpDouble(double x) {
-    if (x == floor(x)) {
-        SkDebugf("%.0f", x);
-    } else {
-        SkDebugf("%1.17g", x);
-    }
-}
-
-inline void DebugDumpFloat(float x) {
-    if (x == floorf(x)) {
-        SkDebugf("%.0f", x);
-    } else {
-        SkDebugf("%1.9gf", x);
-    }
-}
 #endif
-
-#endif