rangeOfMatchingFloatingPointNumbers function

Tuple2<double, double> rangeOfMatchingFloatingPointNumbers(double value, int maxNumbersBetween)

Determines the range of floating point numbers that will match the specified value with the given tolerance.

Implementation

Tuple2<double, double> rangeOfMatchingFloatingPointNumbers(
    double value, int maxNumbersBetween) {
  // Make sure ulpDifference is non-negative
  if (maxNumbersBetween < 1) {
    throw ArgumentError.value(
        maxNumbersBetween, 'maxNumbersBetween', messages.argumentPositive);
  }

  // If the value is infinity (positive or negative) just
  // return the same infinity for the range.
  if (value.isInfinite) {
    return Tuple2<double, double>(value, value);
  }

  // If the value is a NaN then the range is a NaN too.
  if (value.isNaN) {
    return Tuple2<double, double>(double.nan, double.nan);
  }

  // Translate the bit pattern of the double to an integer.
  // Note that this leads to:
  // double > 0 --> long > 0, growing as the double value grows
  // double < 0 --> long < 0, increasing in absolute magnitude as the double
  //                          gets closer to zero!
  //                          i.e. 0 - double.epsilon will give the largest long value!
  var bytes = ByteData(8);
  bytes.setFloat64(0, value);
  int intValue = bytes.getInt64(0);

  // We need to protect against over- and under-flow of the intValue when
  // we start to add the ulpsDifference.
  if (intValue < 0) {
    // Note that long.MinValue has the same bit pattern as
    // -0.0. Therefore we're working in opposite direction (i.e. add if we want to
    // go more negative and subtract if we want to go less negative)
    var topRangeEnd = (int64MinValue - intValue).abs() < maxNumbersBetween
        // Got underflow, which can be fixed by splitting the calculation into two bits
        // first get the remainder of the intValue after subtracting it from the long.MinValue
        // and add that to the ulpsDifference. That way we'll turn positive without underflow
        ? int64BitsToDouble(maxNumbersBetween + (int64MinValue - intValue))
        // No problems here, move along.
        : int64BitsToDouble(intValue - maxNumbersBetween);

    var bottomRangeEnd = intValue.abs() < maxNumbersBetween
        // Underflow, which means we'd have to go further than a long would allow us.
        // Also we couldn't translate it back to a double, so we'll return -Double.MaxValue
        ? -double.maxFinite
        // intValue is negative. Adding the positive ulpsDifference means that it gets less negative.
        // However due to the conversion way this means that the actual double value gets more negative :-S
        : int64BitsToDouble(intValue + maxNumbersBetween);

    return Tuple2<double, double>(bottomRangeEnd, topRangeEnd);
  } else {
    // IntValue is positive
    var topRangeEnd = int64MaxValue - intValue < maxNumbersBetween
        // Overflow, which means we'd have to go further than a long would allow us.
        // Also we couldn't translate it back to a double, so we'll return Double.MaxValue
        ? double.maxFinite
        // No troubles here
        : int64BitsToDouble(intValue + maxNumbersBetween);

    // Check the bottom range end for underflows
    var bottomRangeEnd = intValue > maxNumbersBetween
        // No problems here. IntValue is larger than ulpsDifference so we'll end up with a
        // positive number.
        ? int64BitsToDouble(intValue - maxNumbersBetween)
        // Int value is bigger than zero but smaller than the ulpsDifference. So we'll need to deal with
        // the reversal at the negative end
        : int64BitsToDouble(int64MinValue + (maxNumbersBetween - intValue));

    return Tuple2<double, double>(bottomRangeEnd, topRangeEnd);
  }
}