Class ExtraMath


  • public class ExtraMath
    extends java.lang.Object
    A static utility class with two additional math functions.
    • Field Summary

      Fields 
      Modifier and Type Field Description
      static double CLOSE  
      static double EPSILON  
    • Constructor Summary

      Constructors 
      Constructor Description
      ExtraMath()  
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static boolean close​(double v, double w)  
      static boolean close​(double v, double w, double tol)
      Are v and w "close" to each other?
      static double closeFloor​(double v)
      Returns floor(v) except when v is very close to the next number, when it returns ceil(v);
      static double round​(double x, int n)
      Round the argument x to n decimal places.
      • Methods inherited from class java.lang.Object

        equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • EPSILON

        public static double EPSILON
      • CLOSE

        public static double CLOSE
    • Constructor Detail

      • ExtraMath

        public ExtraMath()
    • Method Detail

      • close

        public static boolean close​(double v,
                                    double w,
                                    double tol)
        Are v and w "close" to each other? Uses a scaled tolerance.
      • close

        public static boolean close​(double v,
                                    double w)
      • closeFloor

        public static double closeFloor​(double v)
        Returns floor(v) except when v is very close to the next number, when it returns ceil(v);
      • round

        public static double round​(double x,
                                   int n)
        Round the argument x to n decimal places. (Rounding is half-up in Python 2.) The method uses BigDecimal, to compute r(x*10n)*10-n, where r() round to the nearest integer. It takes some short-cuts for extreme values.

        For sufficiently small x*10n, the rounding is to zero, and the return value is a signed zero (same sign as x). Suppose x = a*2b, where the significand we must have a<2. Sufficiently small means such that n log210 < -(b+2).

        For sufficiently large x*10n, the adjustment of rounding is too small to affect the least significant bit. That is a*2b represents an amount greater than one, and rounding no longer affects the value, and the return is x. Since the matissa has 52 fractional bits, sufficiently large means such that n log210 > 52-b.

        Parameters:
        x - to round
        n - decimal places
        Returns:
        x rounded.