pathops work in progress

src/pathops/SkPathOpsTypes.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkFloatBits.h"
 #include "SkPathOpsTypes.h"
 
 static bool arguments_denormalized(float a, float b, int epsilon) {
-    float denomalizedCheck = FLT_EPSILON * epsilon / 2;
-    return fabsf(a) <= denomalizedCheck && fabsf(b) <= denomalizedCheck;
+    float denormalizedCheck = FLT_EPSILON * epsilon / 2;
+    return fabsf(a) <= denormalizedCheck && fabsf(b) <= denormalizedCheck;
 }
 
 // from http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
 // FIXME: move to SkFloatBits.h
-static bool equal_ulps(float a, float b, int epsilon) {
+static bool equal_ulps(float a, float b, int epsilon, int depsilon) {
     if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
         return false;
     }
-    if (arguments_denormalized(a, b, epsilon)) {
+    if (arguments_denormalized(a, b, depsilon)) {
         return true;
     }
     int aBits = SkFloatAs2sCompliment(a);
     int bBits = SkFloatAs2sCompliment(b);
     // Find the difference in ULPs.
     return aBits < bBits + epsilon && bBits < aBits + epsilon;
 }
 
 static bool d_equal_ulps(float a, float b, int epsilon) {
     if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
@@ skipping 50 matching lines @@
     }
     int aBits = SkFloatAs2sCompliment(a);
     int bBits = SkFloatAs2sCompliment(b);
     // Find the difference in ULPs.
     return aBits < bBits + epsilon;
 }
 
 // equality using the same error term as between
 bool AlmostBequalUlps(float a, float b) {
     const int UlpsEpsilon = 2;
-    return equal_ulps(a, b, UlpsEpsilon);
+    return equal_ulps(a, b, UlpsEpsilon, UlpsEpsilon);
+}
+
+bool AlmostPequalUlps(float a, float b) {
+    const int UlpsEpsilon = 8;
+    return equal_ulps(a, b, UlpsEpsilon, UlpsEpsilon);
 }
 
 bool AlmostDequalUlps(float a, float b) {
     const int UlpsEpsilon = 16;
     return d_equal_ulps(a, b, UlpsEpsilon);
 }
 
 bool AlmostEqualUlps(float a, float b) {
     const int UlpsEpsilon = 16;
-    return equal_ulps(a, b, UlpsEpsilon);
+    return equal_ulps(a, b, UlpsEpsilon, UlpsEpsilon);
 }
 
 bool NotAlmostEqualUlps(float a, float b) {
     const int UlpsEpsilon = 16;
     return not_equal_ulps(a, b, UlpsEpsilon);
 }
 
 bool NotAlmostDequalUlps(float a, float b) {
     const int UlpsEpsilon = 16;
     return d_not_equal_ulps(a, b, UlpsEpsilon);
 }
 
 bool RoughlyEqualUlps(float a, float b) {
     const int UlpsEpsilon = 256;
-    return equal_ulps(a, b, UlpsEpsilon);
+    const int DUlpsEpsilon = 1024;
+    return equal_ulps(a, b, UlpsEpsilon, DUlpsEpsilon);
 }
 
 bool AlmostBetweenUlps(float a, float b, float c) {
     const int UlpsEpsilon = 2;
     return a <= c ? less_or_equal_ulps(a, b, UlpsEpsilon) && less_or_equal_ulps(b, c, UlpsEpsilon)
         : less_or_equal_ulps(b, a, UlpsEpsilon) && less_or_equal_ulps(c, b, UlpsEpsilon);
 }
 
 bool AlmostLessUlps(float a, float b) {
     const int UlpsEpsilon = 16;
@@ skipping 50 matching lines @@
 double SkDCubeRoot(double x) {
     if (approximately_zero_cubed(x)) {
         return 0;
     }
     double result = halley_cbrt3d(fabs(x));
     if (x < 0) {
         result = -result;
     }
     return result;
 }