only call scalar finite when necessary

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 "SkOpCoincidence.h"
 #include "SkPathOpsTypes.h"
 
 static bool arguments_denormalized(float a, float b, int epsilon) {
     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, int depsilon) {
+    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 equal_ulps_pin(float a, float b, int epsilon, int depsilon) {

[reed1, 2015/12/15 14:17:21]

Just an idea, may not be any clearer...

To avoid the copy/paste here and in no_equal_ulps[_pin], we could use a template
arg...

template <bool CheckIsFinite> equal_ulps(float a, float b, ...) {
    if (CheckIsFinite) {
        if (...) {
        }
    }
    ...

     if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
         return false;
     }
     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)) {
-        return false;
-    }
     int aBits = SkFloatAs2sCompliment(a);
     int bBits = SkFloatAs2sCompliment(b);
     // Find the difference in ULPs.
     return aBits < bBits + epsilon && bBits < aBits + epsilon;
 }
 
 static bool not_equal_ulps(float a, float b, int epsilon) {
+    if (arguments_denormalized(a, b, epsilon)) {
+        return false;
+    }
+    int aBits = SkFloatAs2sCompliment(a);
+    int bBits = SkFloatAs2sCompliment(b);
+    // Find the difference in ULPs.
+    return aBits >= bBits + epsilon || bBits >= aBits + epsilon;
+}
+
+static bool not_equal_ulps_pin(float a, float b, int epsilon) {
     if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
         return false;
     }
     if (arguments_denormalized(a, b, epsilon)) {
         return false;
     }
     int aBits = SkFloatAs2sCompliment(a);
     int bBits = SkFloatAs2sCompliment(b);
     // Find the difference in ULPs.
     return aBits >= bBits + epsilon || bBits >= aBits + epsilon;
 }
 
 static bool d_not_equal_ulps(float a, float b, int epsilon) {
-    if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
-        return false;
-    }
     int aBits = SkFloatAs2sCompliment(a);
     int bBits = SkFloatAs2sCompliment(b);
     // Find the difference in ULPs.
     return aBits >= bBits + epsilon || bBits >= aBits + epsilon;
 }
 
 static bool less_ulps(float a, float b, int epsilon) {
-    if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
-        return false;
-    }
     if (arguments_denormalized(a, b, epsilon)) {
         return a <= b - FLT_EPSILON * epsilon;
     }
     int aBits = SkFloatAs2sCompliment(a);
     int bBits = SkFloatAs2sCompliment(b);
     // Find the difference in ULPs.
     return aBits <= bBits - epsilon;
 }
 
 static bool less_or_equal_ulps(float a, float b, int epsilon) {
-    if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
-        return false;
-    }
     if (arguments_denormalized(a, b, epsilon)) {
         return a < b + FLT_EPSILON * epsilon;
     }
     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, 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 AlmostDequalUlps(double a, double b) {
-    if (SkScalarIsFinite(a) || SkScalarIsFinite(b)) {
-        return AlmostDequalUlps(SkDoubleToScalar(a), SkDoubleToScalar(b));
-    }
-    return fabs(a - b) / SkTMax(fabs(a), fabs(b)) < FLT_EPSILON * 16;
+    return AlmostDequalUlps(SkDoubleToScalar(a), SkDoubleToScalar(b));
 }
 
 bool AlmostEqualUlps(float a, float b) {
     const int UlpsEpsilon = 16;
     return equal_ulps(a, b, UlpsEpsilon, UlpsEpsilon);
 }
 
+bool AlmostEqualUlps_Pin(float a, float b) {
+    const int UlpsEpsilon = 16;
+    return equal_ulps_pin(a, b, UlpsEpsilon, UlpsEpsilon);
+}
+
 bool NotAlmostEqualUlps(float a, float b) {
     const int UlpsEpsilon = 16;
     return not_equal_ulps(a, b, UlpsEpsilon);
 }
 
+bool NotAlmostEqualUlps_Pin(float a, float b) {
+    const int UlpsEpsilon = 16;
+    return not_equal_ulps_pin(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;
     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;
     return less_ulps(a, b, UlpsEpsilon);
 }
 
 bool AlmostLessOrEqualUlps(float a, float b) {
     const int UlpsEpsilon = 16;
     return less_or_equal_ulps(a, b, UlpsEpsilon);
 }
 
 int UlpsDistance(float a, float b) {
-    if (!SkScalarIsFinite(a) || !SkScalarIsFinite(b)) {
-        return SK_MaxS32;
-    }
     SkFloatIntUnion floatIntA, floatIntB;
     floatIntA.fFloat = a;
     floatIntB.fFloat = b;
     // Different signs means they do not match.
     if ((floatIntA.fSignBitInt < 0) != (floatIntB.fSignBitInt < 0)) {
         // Check for equality to make sure +0 == -0
         return a == b ? 0 : SK_MaxS32;
     }
     // Find the difference in ULPs.
     return SkTAbs(floatIntA.fSignBitInt - floatIntB.fSignBitInt);
@@ skipping 52 matching lines @@
     SkDEBUGPARAMS(fSegmentID(0))
     SkDEBUGPARAMS(fSpanID(0)) {
     if (coincidence) {
         coincidence->debugSetGlobalState(this);
     }
 #if DEBUG_T_SECT_LOOP_COUNT
     debugResetLoopCounts();
 #endif
 }