minor changes for performance

cdm/core/src/main/java/ucar/nc2/filter/ConvertMissing.java

@@ -8,10 +8,12 @@
 import ucar.nc2.dataset.VariableDS;
 import ucar.nc2.util.Misc;
 
+import java.util.Arrays;
+
 public class ConvertMissing {
 
   private boolean hasValidMin, hasValidMax;
-  private double validMin, validMax;
+  private double validMin, validMax, fuzzyValidMin, fuzzyValidMax;
 
   private boolean hasFillValue;
   private double fillValue; // LOOK: making it double not really correct. What about CHAR?
@@ -142,7 +144,9 @@ public ConvertMissing(boolean fillValueIsMissing, boolean invalidDataIsMissing,
     this.hasValidMin = hasValidMin;
     this.hasValidMax = hasValidMax;
     this.validMin = validMin;
+    this.fuzzyValidMin = validMin - Misc.defaultMaxRelativeDiffFloat;
     this.validMax = validMax;
+    this.fuzzyValidMax = validMax + Misc.defaultMaxRelativeDiffFloat;
     this.hasFillValue = hasFillValue;
     this.fillValue = fillValue;
     this.hasMissingValue = hasMissingValue;
@@ -162,15 +166,9 @@ public double getValidMax() {
   }
 
   public boolean isInvalidData(double val) {
-    // valid_min and valid_max may have been multiplied by scale_factor, which could be a float, not a double.
-    // That potential loss of precision means that we cannot do the nearlyEquals() comparison with
-    // Misc.defaultMaxRelativeDiffDouble.
-    boolean greaterThanOrEqualToValidMin =
-        Misc.nearlyEquals(val, validMin, Misc.defaultMaxRelativeDiffFloat) || val > validMin;
-    boolean lessThanOrEqualToValidMax =
-        Misc.nearlyEquals(val, validMax, Misc.defaultMaxRelativeDiffFloat) || val < validMax;
-
-    return (hasValidMin && !greaterThanOrEqualToValidMin) || (hasValidMax && !lessThanOrEqualToValidMax);
+    if (val > fuzzyValidMax) { return true; }
+    if (val < fuzzyValidMin) { return true; }
+    return false;
   }
 
   public boolean hasFillValue() {
@@ -189,12 +187,7 @@ public boolean isMissingValue(double val) {
     if (!hasMissingValue) {
       return false;
     }
-    for (double aMissingValue : missingValue) {
-      if (Misc.nearlyEquals(val, aMissingValue, Misc.defaultMaxRelativeDiffFloat)) {
-        return true;
-      }
-    }
-    return false;
+    return Arrays.stream(missingValue).anyMatch(mVal -> Misc.nearlyEquals(val, mVal, Misc.defaultMaxRelativeDiffFloat));
   }
 
   public double[] getMissingValues() {
@@ -214,8 +207,8 @@ public boolean isMissing(double val) {
     if (Double.isNaN(val)) {
       return true;
     } else {
-      return (missingDataIsMissing && isMissingValue(val)) || (fillValueIsMissing && isFillValue(val))
-          || (invalidDataIsMissing && isInvalidData(val));
+      return (missingDataIsMissing && hasMissingValue && isMissingValue(val)) || (fillValueIsMissing && hasFillValue && isFillValue(val))
+          || (invalidDataIsMissing && hasValidData() && isInvalidData(val));
     }
   }
 

cdm/core/src/main/java/ucar/nc2/util/Misc.java

@@ -9,6 +9,8 @@
 import java.util.Collection;
 import java.util.Formatter;
 import java.util.List;
+
+import com.google.common.math.DoubleMath;
 import ucar.ma2.DataType;
 
 /** Miscellaneous static routines. */
@@ -96,7 +98,7 @@ public static boolean nearlyEquals(float a, float b) {
 
   /** RelativeDifference is less than maxRelDiff. */
   public static boolean nearlyEquals(float a, float b, float maxRelDiff) {
-    return relativeDifference(a, b) < maxRelDiff;
+    return DoubleMath.fuzzyEquals(a, b, maxRelDiff);
   }
 
   /** RelativeDifference is less than {@link #defaultMaxRelativeDiffDouble}. */
@@ -106,7 +108,7 @@ public static boolean nearlyEquals(double a, double b) {
 
   /** RelativeDifference is less than maxRelDiff. */
   public static boolean nearlyEquals(double a, double b, double maxRelDiff) {
-    return relativeDifference(a, b) < maxRelDiff;
+    return DoubleMath.fuzzyEquals(a, b, maxRelDiff);
   }
 
   /** AbsoluteDifference is less than maxAbsDiff. */