ScriptMath2

java.lang.Object
- com.cohort.util.ScriptMath2

```
public class ScriptMath2
extends java.lang.Object
```
This class makes almost all of the static methods in com.cohort.Math2 accessible to JexlScript scripts as "Math2.name()" methods. This doesn't include the memory related and sleep related methods.
The underlying Math2 class is Copyright (c) 2005 Robert Simons (CoHortSoftware@gmail.com). See the MIT/X-like license in com/cohort/util/LICENSE.txt.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`Binary0` -2000
`static int`	`BinaryLimit` 980; //2^980 = ~1e295
`static long`	`BytesPerGB` BytesPerMB * (long)BytesPerKB
`static int`	`BytesPerKB` 1024
`static int`	`BytesPerMB` BytesPerKB * BytesPerKB
`static long`	`BytesPerPB` BytesPerTB * BytesPerKB;
`static long`	`BytesPerTB` BytesPerGB * BytesPerKB
`static double[]`	`COMMON_MV9` -99, -99.9, -99.99, -999, -999.9, -9999, -99999, -999999, -9999999, 99, 99.9, 99.99, 999, 999.9, 9999, 99999, 999999, 9999999
`static double`	`dEps` epsilon suitable for doubles = 1e-13.
`static float`	`fEps` Eps values define small values that are suitable for quick tests if the difference between two values is close to the precision of of the data type.
`static double[]`	`InverseTen` This defines inverse powers of ten.
`static double`	`kelvinToC` -273.15
`static double`	`kmPerMile` mPerMile * 0.001
`static double`	`ln10` Math.log(10.0); //2.302585092994046;
`static double`	`ln2` Math.log(2.0)
`static long`	`loAnd` ((long) Integer.MAX_VALUE * 2) + 1; //mask for low 32 bits
`static double`	`meterPerFoot` 1200.0 / 3927.0.
`static double`	`mPerMile` 5280 * meterPerFoot
`static double`	`OneRadian` 180.0 / Math.PI
`static double[]`	`Ten` This defines powers of ten.
`static int[]`	`Two` `two` defines powers of two, e.g., Two[0]=1, Two[1]=2, Two[2]=4, ...
`static double`	`TwoPi` 2 * Math.PI

Constructor Summary

Constructors
Constructor and Description

ScriptMath2()

Constructors
Constructor and Description
`ScriptMath2()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`almost0(double d)` This quickly tests if `d` is almost 0 (Math.abs(d)<dEps).
`static boolean`	`almostEqual(int nSignificantDigits, double d1, double d2)` This tests if the numbers are equal to at least n significant digits.
`static boolean`	`almostEqual(int nSignificantDigits, float f1, float f2)` This tests if two floats are equal to at least n significant digits.
`static double`	`angle02Pi(double radians)` This converts an angle (in radians) into the range >=0 to <2PI.
`static double`	`angle0360(double degrees)` This converts an angle (in degrees) into the range >=0 to <360.
`static double`	`anglePM180(double degrees)` This converts an angle (in degrees) into the range >=-180 to <180 (180 becomes -180).
`static double`	`bigger(double d)` This increases the value (nicely).
`static double`	`bigger15(double d)` This increases the value (nicely) so the mantissa is 1 or 5.
`static double`	`biggerAngle(double d)` This increases the double degrees value (nicely), and returns it as a string.
`static double`	`biggerDouble(double def, double mult, double max, double d)` This increases d to the next multiple of mult.
`static int`	`binaryExponent(double d)` This returns the binary exponent of a double: usually +-1023.
`static int`	`binaryFindClosest(double[] dar, double x)` Find the closest element to x in an ascending sorted array.
`static int`	`binaryFindFirstGAE(double[] dar, double x, int precision)` Find the first element which is >x or almostEqual(precision, x) in an ascending sorted array.
`static int`	`binaryFindFirstGE(double[] dar, double x)` Find the first element which is >= x in an ascending sorted array.
`static int`	`binaryFindLastLAE(double[] dar, double x, int precision)` Find the last element which is <x or almostEqual(5, x) in an ascending sorted array.
`static int`	`binaryFindLastLE(double[] dar, double x)` Find the last element which is <= x in an ascending sorted array.
`static char`	`byteToChar(int b)` Safely converts a byte (-128..127) to char (0..255).
`static double`	`compassToMathDegrees(double compass)` This converts a compass heading (usually 0..360, where North is 0, East is 90...) to Math-style degrees (East is 0, North is 90, ...).
`static float`	`doubleToFloatNaN(double d)` Safely converts a double to a float (including the non-standard conversion of large values to Float.NaN, not Float.POSITIVE_INFINITY).
`static boolean`	`equalsIncludingNanOrInfinite(double a, double b)` This returns true if a == b.
`static boolean`	`equalsIncludingNanOrInfinite(float a, float b)` This returns true if a == b.
`static double`	`exponent(double d)` This returns the double exponent of a double (e.g., -0.0175 returns 0.01 since -0.0175=-1.75*0.01).
`static double`	`finiteMax(double a, double b)` This returns the greater value.
`static double`	`finiteMin(double a, double b)` This returns the lesser value.
`static double`	`floatToDouble(double f)` Safely converts a float to a double.
`static double`	`floatToDoubleNaN(double f)` Crudely (not nicely) converts a float to a double (including the non-standard conversion of INFINITY values to NaN).
`static int`	`floorDiv(int num, int den)` A div where the implied mod is always >=0.
`static long`	`floorDiv(long num, long den)` A div where the implied mod is always >=0.
`static double`	`frac(double d)` This returns the fraction part of a double.
`static int`	`gcd(int n, int d)` Finds the greatest common divisor.
`static double`	`getSmallIncrement(double range)` This returns a small increment roughly 1/100th the range (e.g., .1, 1, 10, ....).
`static boolean`	`greaterThanAE(int nSignificantDigits, double d1, double d2)` This tests if d1 is greater than or almostEqual9 d2.
`static void`	`guessFrac(double r, int[] int3)` Looks for a fraction very close to some decimal value.
`static java.lang.String`	`guessFracString(double d)` This creates a String based on the results of guessFrac()
`static int`	`hiDiv(int num, int den)` A div that rounds up if den>0.
`static long`	`hiDiv(long num, long den)` A div that rounds up if den>0.
`static int`	`intExponent(double d)` This returns the integer exponent of a double (-0.0175 returns -2 since -0.0175=-1.75*10^-2).
`static boolean`	`lessThanAE(int nSignificantDigits, double d1, double d2)` This tests if d1 is less than or almostEqual d2.
`static double`	`longToDoubleNaN(long tl)` This converts a long to a double (Long.MAX_VALUE becomes NaN).
`static double`	`looserAngle0360(double degrees)` This converts an angle (in degrees) into the range >= 0 to <=360 (note 360 is valid).
`static double`	`looserAnglePM180(double degrees)` This converts an angle (in degrees) into the range >=-180 to <=180 (note 180 is valid).
`static double`	`mantissa(double d)` This returns the mantissa of a double (-0.0175 returns -1.75 since -0.0175=-1.75*10^-2).
`static double`	`mathToCompassDegrees(double math)` This converts a Math-style degrees (East is 0, North is 90, ...) to a compass heading (where North is 0, East is 90, ...).
`static double`	`minMax(double min, double max, double current)` This forces a double into a range defined by min..max.
`static int`	`minMax(int min, int max, int current)` This forces a int into a range defined by min..max.
`static double`	`minMaxDef(double min, double max, double def, double current)` This forces a double into a range defined by min..max.
`static int`	`minMaxDef(int min, int max, int def, int current)` This forces an int into a range defined by min..max.
`static double`	`NaNCheck(double d)` Checks if the value is NaN or infinite: returns Double.NaN if so; otherwise returns the original value.
`static byte`	`narrowToByte(int i)` Safely narrows an int to a byte.
`static byte`	`narrowToByte(long i)` Safely narrows a long to a byte.
`static char`	`narrowToChar(int i)` Safely narrows an int to a char.
`static char`	`narrowToChar(long i)` Safely narrows a long to a char.
`static int`	`narrowToInt(long i)` Safely narrows a long to an int.
`static short`	`narrowToShort(int i)` Safely narrows an int to a short.
`static short`	`narrowToShort(long i)` Safely narrows a long to a short.
`static double`	`niceDouble(double d, int nDigits)` Safely tries to un-bruise a double (8.999999999 -> 9.0, or 1.000000001 -> 1.0).
`static boolean`	`odd(int i)` Indicates if i is odd.
`static double`	`oneDigitBigger(double max, double def, double d)` This increases the first digit of d (for example, .8, .9, 1, 2, 3, ..., 9, 10, 20, 30, ...).
`static double`	`oneDigitSmaller(double min, double def, double d)` This decreases the first digit of d (for example, 30, 20, 10, 9, ..., 3, 2, 1, .9, .8, ...).
`static int`	`random(int max)` This returns a random integer between 0 and max-1.
`static java.lang.String`	`reduceHashCode(int hashCode)` This reduces a hash code (currently to a 10 digit unsigned number -- no loss of information).
`static int`	`roundDiv(int num, int den)` A div that rounds.
`static double`	`roundTo(double d, int nPlaces)` Rounds the value to the specified number of decimal places.
`static byte`	`roundToByte(double d)` Safely rounds a double to a byte.
`static char`	`roundToChar(double d)` Safely rounds a double to a char (treated as unsigned short).
`static double`	`roundToDouble(double d)` Safely rounds a double to the nearest integer (stored as a double).
`static int`	`roundToInt(double d)` Safely rounds a double to an int.
`static long`	`roundToLong(double d)` Safely rounds a double to a long.
`static short`	`roundToShort(double d)` Safely rounds a double to a short.
`static void`	`setSeed(long seed)` This sets the seed for the next call to random().
`static int`	`sign1(int i)` This returns 1 for positive i's, -1 for negative i's, and 1 if i is 0 (i.e., 0 is treated as a positive number).
`static double`	`smaller(double d)` This decreases the value (nicely).
`static double`	`smaller15(double d)` This gets the double value from the string, decreases it (nicely), so the mantissa is 1 or 5.
`static double`	`smallerAngle(double d)` This decreases the double degree value (nicely).
`static double`	`smallerDouble(double def, double mult, double min, double d)` This decreases d to the previous multiple of mult.
`static double[]`	`suggestDivisions(double range)` This suggests the division distance along an axis so that there will be about 5-7 primary divisions and 10-25 secondary.
`static double[]`	`suggestLowHigh(double low, double high)` This returns a nice bounding range (e.g., for an axis) which includes low and high.
`static double`	`suggestMaxDivisions(double range, int maxDivisions)` This suggests the division distance along an axis so that there will be between maxDivisions/2 and maxDivisions.
`static double`	`ten(int toThe)` This returns an integer power of ten.
`static double`	`trunc(double d)` This returns the truncated part of a double.
`static int`	`truncToInt(double d)` This returns the truncated part of a double, stored as an int.
`static int`	`unsignedByte(int b)` Safely converts a signed byte (-128..127) to an unsigned byte (0..255).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - fEps
```
public static final float fEps
```
    Eps values define small values that are suitable for quick tests if the difference between two values is close to the precision of of the data type. epsilon for floats=fEps=1e-5f
  - dEps
```
public static final double dEps
```
    epsilon suitable for doubles = 1e-13.
  - OneRadian
```
public static final double OneRadian
```
    180.0 / Math.PI
  - TwoPi
```
public static final double TwoPi
```
    2 * Math.PI
  - ln10
```
public static final double ln10
```
    Math.log(10.0); //2.302585092994046;
  - ln2
```
public static final double ln2
```
    Math.log(2.0)
  - kelvinToC
```
public static final double kelvinToC
```
    -273.15
  - Binary0
```
public static final int Binary0
```
    -2000
  - BinaryLimit
```
public static final int BinaryLimit
```
    980; //2^980 = ~1e295
  - BytesPerKB
```
public static final int BytesPerKB
```
    1024
  - BytesPerMB
```
public static final int BytesPerMB
```
    BytesPerKB * BytesPerKB
  - BytesPerGB
```
public static final long BytesPerGB
```
    BytesPerMB * (long)BytesPerKB
  - BytesPerTB
```
public static final long BytesPerTB
```
    BytesPerGB * BytesPerKB
  - BytesPerPB
```
public static final long BytesPerPB
```
    BytesPerTB * BytesPerKB;
  - loAnd
```
public static final long loAnd
```
    ((long) Integer.MAX_VALUE * 2) + 1; //mask for low 32 bits
  - meterPerFoot
```
public static final double meterPerFoot
```
    1200.0 / 3927.0. udunits says: US_survey_footS (1200/3937) meter# exact US_survey_feetS US_survey_foot# alias US_survey_mileP 5280 US_survey_feet# exact US_statute_mileP US_survey_mile# alias so convert nMiles * 5280 ft/mile * 1200/3927 m/ft * .001 km/m -> km
  - mPerMile
```
public static final double mPerMile
```
    5280 * meterPerFoot
  - kmPerMile
```
public static final double kmPerMile
```
    mPerMile * 0.001
  - Two
```
public static final int[] Two
```
    two defines powers of two, e.g., Two[0]=1, Two[1]=2, Two[2]=4, ... Two[31].
  - Ten
```
public static final double[] Ten
```
    This defines powers of ten. e.g., Ten[0]=1, Ten[1]=10, Ten[2]=100... Ten[18]
  - InverseTen
```
public static final double[] InverseTen
```
    This defines inverse powers of ten. e.g., InverseTen[0]=1, InverseTen[1]=.01, InverseTen[2]=.001... InverseTen[18]
  - COMMON_MV9
```
public static final double[] COMMON_MV9
```
    -99, -99.9, -99.99, -999, -999.9, -9999, -99999, -999999, -9999999, 99, 99.9, 99.99, 999, 999.9, 9999, 99999, 999999, 9999999
- Constructor Detail
  - ScriptMath2
```
public ScriptMath2()
```
- Method Detail
  - trunc
```
public static double trunc(double d)
```
    This returns the truncated part of a double.
    
    Parameters:
    
    d - a double value
    
    Returns:
    
    d truncated. The return value will be the same sign as d. !isFinite(d), this returns NaN. d=trunc(d)+frac(d);
  - truncToInt
```
public static int truncToInt(double d)
```
    This returns the truncated part of a double, stored as an int.
    
    Parameters:
    
    d - any double
    
    Returns:
    
    the truncated version of d (or NaN if trouble)
    
    See Also:
    
    Math2.trunc(double)
  - frac
```
public static double frac(double d)
```
    This returns the fraction part of a double. The return value will be the same sign as d. d=trunc(d)+frac(d);
    
    Parameters:
    
    d - a double
    
    Returns:
    
    the fractional part of d
  - sign1
```
public static int sign1(int i)
```
    This returns 1 for positive i's, -1 for negative i's, and 1 if i is 0 (i.e., 0 is treated as a positive number).
    
    Parameters:
    
    i - an int
    
    Returns:
    
    1 for positive i's, -1 for negative i's, and 1 if i is 0 (i.e., 0 is treated as a positive number).
  - intExponent
```
public static int intExponent(double d)
```
    This returns the integer exponent of a double (-0.0175 returns -2 since -0.0175=-1.75*10^-2). It handles 0, +, and - numbers. 0 and NaN returns Integer.MAX_VALUE. WARNING: round off problems cause 100 -> 10 *10^1, not 1*10^2!
    See the similar String2.toRational()
    
    Parameters:
    
    d - a double value
    
    Returns:
    
    the integer exponent of the number. If !isFinite(d), this returns Integer.MAX_VALUE d=0 returns 0.
  - exponent
```
public static double exponent(double d)
```
    This returns the double exponent of a double (e.g., -0.0175 returns 0.01 since -0.0175=-1.75*0.01). It handles 0, +, and - numbers. WARNING: round off problems cause 100 -> 10 *10^1, not 1*10^2!
    
    Parameters:
    
    d - a double value
    
    Returns:
    
    the exponent of the number. d=0 returns 1. If !isFinite(d), this returns NaN.
  - mantissa
```
public static double mantissa(double d)
```
    This returns the mantissa of a double (-0.0175 returns -1.75 since -0.0175=-1.75*10^-2). It handles 0, +, and - numbers. WARNING: round off problems can cause (for example) 100 to be treated 10 *10^1, not 1*10^2!
    See the similar String2.toRational()
    
    Parameters:
    
    d - any double
    
    Returns:
    
    d / exponent(d) (or 0 if d=0, or NaN if !finite(d))
  - NaNCheck
```
public static double NaNCheck(double d)
```
    Checks if the value is NaN or infinite: returns Double.NaN if so; otherwise returns the original value.
    
    Parameters:
    
    d - and double value
    
    Returns:
    
    d (or NaN if !isFinite(d))
  - odd
```
public static boolean odd(int i)
```
    Indicates if i is odd.
    
    Parameters:
    
    i - any int
    
    Returns:
    
    true if i is an odd number
  - ten
```
public static double ten(int toThe)
```
    This returns an integer power of ten. It uses Ten[] when possible for increased speed. It is protected against errors. It returns Double.POSITIVE_INFINITY if trouble.
    
    Parameters:
    
    toThe - the number that ten is to be raised to the power of
    
    Returns:
    
    10^toThe
  - binaryExponent
```
public static int binaryExponent(double d)
```
    This returns the binary exponent of a double: usually +-1023.
    
    Parameters:
    
    d - any double
    
    Returns:
    
    the binary exponent of d. If d = 0, this returns Binary0 (which is a flag, not a real value). If !isFinite(d), this return BinaryLimit (which is a flag, not a real value).
  - almost0
```
public static final boolean almost0(double d)
```
    This quickly tests if d is almost 0 (Math.abs(d)<dEps).
    - If you are working with small numbers, this test may be inappropriate.
    - This is very fast, since it only involves one comparison.
    - Use almost0(d) instead of almostEqual5 or almostEqual9.
    Parameters:
    
    d - any double
    
    Returns:
    
    true if Math.abs(d) < dEps. NaN and Infinity correctly return false.
  - lessThanAE
```
public static boolean lessThanAE(int nSignificantDigits,
                                 double d1,
                                 double d2)
```
    This tests if d1 is less than or almostEqual d2.
    
    Parameters:
    
    nSignificantDigits - 0 to 18 are allowed; 5, 9, and 14 are common
    
    d1 - the first number
    
    d2 - the second number
    
    Returns:
    
    true if d1 is less than or almostEqual d2. If isNaN(d1) || isNaN(d2), this returns false.
  - greaterThanAE
```
public static boolean greaterThanAE(int nSignificantDigits,
                                    double d1,
                                    double d2)
```
    This tests if d1 is greater than or almostEqual9 d2.
    
    Parameters:
    
    nSignificantDigits - 0 to 18 are allowed; 5, 9, and 14 are common
    
    d1 - the first number
    
    d2 - the second number
    
    Returns:
    
    true if d1 is greater than or almostEqual9 d2. If isNaN(d1) || isNaN(d2), this returns false.
  - almostEqual
```
public static boolean almostEqual(int nSignificantDigits,
                                  double d1,
                                  double d2)
```
    This tests if the numbers are equal to at least n significant digits.
    - Numbers must match to 1 part in 10^n to ensure that rounding to n-1 digits is identical.
    - If d1 and d2 are almost0, this returns true.
    - This is slow compared to almost0.
    Parameters:
    
    nSignificantDigits - 0 to 18 are allowed; 5, 9, and 14 are common
    
    d1 - any double
    
    d2 - any double
    
    Returns:
    
    true if the numbers are equal to at least n significant digits (or are both almost0). If either number is NaN or Infinity, this returns false.
  - almostEqual
```
public static boolean almostEqual(int nSignificantDigits,
                                  float f1,
                                  float f2)
```
    This tests if two floats are equal to at least n significant digits.
    
    Parameters:
    
    nSignificantDigits - 0 to 18 are allowed; 5, 9, and 14 are common
    
    f1 - any float
    
    f2 - any float
    
    Returns:
    
    true if the numbers are equal to at least n significant digits (or are both almost0). If either number is NaN or Infinity, this returns false.
  - roundDiv
```
public static int roundDiv(int num,
                           int den)
```
    A div that rounds. Positive numbers only. e.g., 1/4 goes to 0; 3/4 goes to 1; den = 0 throws an exception.
    
    Parameters:
    
    num - the numerator (a positive number)
    
    den - the denominator (a positive number)
    
    Returns:
    
    num/den, but rounded to the next larger (abs) int
  - hiDiv
```
public static int hiDiv(int num,
                        int den)
```
    A div that rounds up if den>0. e.g., 1/4 goes to 1; 4/4 goes to 1; den = 0 throws an exception.
    
    Parameters:
    
    num - the numerator (a positive number)
    
    den - the denominator (a positive number)
    
    Returns:
    
    num/den, but rounded to the next larger (abs) int
  - hiDiv
```
public static long hiDiv(long num,
                         long den)
```
    A div that rounds up if den>0. e.g., 1/4 goes to 1; 4/4 goes to 1; den = 0 throws an exception.
    
    Parameters:
    
    num - the numerator (a positive number)
    
    den - the denominator (a positive number)
    
    Returns:
    
    num/den, but rounded to the next larger (abs) int
  - floorDiv
```
public static int floorDiv(int num,
                           int den)
```
    A div where the implied mod is always >=0. This is a consistent div for positive and negative numerators. For example, with regular division 1/2=0 and -1/2=0. But floorDiv(-1,2)=-1. den = 0 throws an exception.
    
    Parameters:
    
    num - the numerator (a positive or negative number)
    
    den - the denominator (a positive number)
    
    Returns:
    
    num/den, but is consistent for positive and negative numbers
  - floorDiv
```
public static long floorDiv(long num,
                            long den)
```
    A div where the implied mod is always >=0. This is a consistent div for positive and negative numerators. For example, with regular division 1/2=0 and -1/2=0. But floorDiv(-1,2)=-1. den = 0 throws an exception.
    
    Parameters:
    
    num - the numerator (a positive or negative number)
    
    den - the denominator (a positive number)
    
    Returns:
    
    num/den, but is consistent for positive and negative numbers
  - minMax
```
public static final int minMax(int min,
                               int max,
                               int current)
```
    This forces a int into a range defined by min..max.
    
    Parameters:
    
    min - the minimum allowed value
    
    max - the maximum allowed value
    
    current - the current value
    
    Returns:
    
    min if current is less than min; or max if current is greater than max; else it returns the current value.
  - minMax
```
public static final double minMax(double min,
                                  double max,
                                  double current)
```
    This forces a double into a range defined by min..max.
    
    Parameters:
    
    min - the minimum allowed value
    
    max - the maximum allowed value
    
    current - the current value
    
    Returns:
    
    min if current is less than min; or max if current is greater than max; else it returns the current value.
  - minMaxDef
```
public static final int minMaxDef(int min,
                                  int max,
                                  int def,
                                  int current)
```
    This forces an int into a range defined by min..max.
    
    Parameters:
    
    min - the minimum allowed value
    
    max - the maximum allowed value
    
    def - the default value
    
    current - the current value
    
    Returns:
    
    def if current is less than min; or def if current is greater than max; else it returns the current value.
  - minMaxDef
```
public static final double minMaxDef(double min,
                                     double max,
                                     double def,
                                     double current)
```
    This forces a double into a range defined by min..max.
    
    Parameters:
    
    min - the minimum allowed value
    
    max - the maximum allowed value
    
    def - the default value
    
    current - the current value
    
    Returns:
    
    def if current is less than min; or def if current is greater than max; else it returns the current value.
  - roundToByte
```
public static final byte roundToByte(double d)
```
    Safely rounds a double to a byte.
    
    Parameters:
    
    d - any double
    
    Returns:
    
    Byte.MAX_VALUE if d is too small, too big, or NaN; otherwise d, rounded to the nearest byte. Undesirable: d.5 rounds up for positive numbers, down for negative.
  - roundToChar
```
public static final char roundToChar(double d)
```
    Safely rounds a double to a char (treated as unsigned short).
    
    Parameters:
    
    d - any double
    
    Returns:
    
    Character.MAX_VALUE if d is too small, too big, or NaN; otherwise d, rounded to the nearest char. Undesirable: d.5 rounds up for positive numbers, down for negative.
  - roundToShort
```
public static final short roundToShort(double d)
```
    Safely rounds a double to a short.
    
    Parameters:
    
    d - any double
    
    Returns:
    
    Short.MAX_VALUE if d is too small, too big, or NaN; otherwise d, rounded to the nearest short. Undesirable: d.5 rounds up for positive numbers, down for negative.
  - roundToInt
```
public static final int roundToInt(double d)
```
    Safely rounds a double to an int. (Math.round but rounds to a long and not safely.)
    
    Parameters:
    
    d - any double
    
    Returns:
    
    Integer.MAX_VALUE if d is too small, too big, or NaN; otherwise d, rounded to the nearest int. Undesirable: d.5 rounds up for positive numbers, down for negative.
  - roundToLong
```
public static final long roundToLong(double d)
```
    Safely rounds a double to a long.
    
    Parameters:
    
    d - any double
    
    Returns:
    
    Long.MAX_VALUE if d is too small, too big, or NaN; otherwise d, rounded to the nearest int. Undesirable: d.5 rounds up for positive numbers, down for negative.
  - roundToDouble
```
public static final double roundToDouble(double d)
```
    Safely rounds a double to the nearest integer (stored as a double).
    
    Parameters:
    
    d - any double
    
    Returns:
    
    Double.NaN if d is !finite; otherwise d, rounded to the nearest int. Undesirable: d.5 rounds up for positive numbers, down for negative. But this rounds d.5 in a way that is often more useful than Math.rint (which rounds to nearest even number).
  - roundTo
```
public static final double roundTo(double d,
                                   int nPlaces)
```
    Rounds the value to the specified number of decimal places.
    
    Parameters:
    
    d - any double
    
    nPlaces - the desired number of digits to the right of the decimal point
  - narrowToByte
```
public static final byte narrowToByte(int i)
```
    Safely narrows an int to a byte.
    
    Parameters:
    
    i - any int
    
    Returns:
    
    Byte.MAX_VALUE if i is too small or too big; otherwise i.
  - narrowToByte
```
public static final byte narrowToByte(long i)
```
    Safely narrows a long to a byte.
    
    Parameters:
    
    i - any long
    
    Returns:
    
    Byte.MAX_VALUE if i is too small or too big; otherwise i.
  - narrowToChar
```
public static final char narrowToChar(int i)
```
    Safely narrows an int to a char.
    
    Parameters:
    
    i - any int
    
    Returns:
    
    Character.MAX_VALUE if i is too small or too big; otherwise i.
  - narrowToChar
```
public static final char narrowToChar(long i)
```
    Safely narrows a long to a char.
    
    Parameters:
    
    i - any long
    
    Returns:
    
    Character.MAX_VALUE if i is too small or too big; otherwise i.
  - narrowToShort
```
public static final short narrowToShort(int i)
```
    Safely narrows an int to a short.
    
    Parameters:
    
    i - any int
    
    Returns:
    
    Short.MAX_VALUE if i is too small or too big; otherwise i.
  - narrowToShort
```
public static final short narrowToShort(long i)
```
    Safely narrows a long to a short.
    
    Parameters:
    
    i - any long
    
    Returns:
    
    Short.MAX_VALUE if i is too small or too big; otherwise i.
  - narrowToInt
```
public static final int narrowToInt(long i)
```
    Safely narrows a long to an int.
    
    Parameters:
    
    i - any long
    
    Returns:
    
    Integer.MAX_VALUE if i is too small or too big; otherwise i.
  - byteToChar
```
public static final char byteToChar(int b)
```
    Safely converts a byte (-128..127) to char (0..255). Note that reverse is easy: (byte)ch works (for 0..255) because narrowing just saves the low order bits, so >127 becomes negative bytes.
    
    Parameters:
    
    b - a byte (-128 .. 127) (or char, short, or int where you just want the lower 8 bits stored as 0..255)
    
    Returns:
    
    a char (0..255)
  - unsignedByte
```
public static final int unsignedByte(int b)
```
    Safely converts a signed byte (-128..127) to an unsigned byte (0..255). Note that reverse is easy: (byte)ch works (for 0..255) because narrowing just saves the low order bits, so >127 becomes negative bytes.
    
    Parameters:
    
    b - a byte (-128 .. 127) (or char, short, or int where you just want the lower 8 bits stored as 0..255)
    
    Returns:
    
    an int (0..255)
  - angle0360
```
public static final double angle0360(double degrees)
```
    This converts an angle (in degrees) into the range >=0 to <360.
    - If isMV(angle), it returns 0.
  - looserAngle0360
```
public static final double looserAngle0360(double degrees)
```
    This converts an angle (in degrees) into the range >= 0 to <=360 (note 360 is valid).
    
    Parameters:
    
    degrees - an angle (in degrees)
    
    Returns:
    
    the angle (in degrees) in the range >=0 to <=360. A non-finite degrees returns the original value.
  - compassToMathDegrees
```
public static final double compassToMathDegrees(double compass)
```
    This converts a compass heading (usually 0..360, where North is 0, East is 90...) to Math-style degrees (East is 0, North is 90, ...).
    
    Parameters:
    
    compass -
    
    Returns:
    
    degrees always >=0 and <360 (compass=NaN -> 0).
  - mathToCompassDegrees
```
public static final double mathToCompassDegrees(double math)
```
    This converts a Math-style degrees (East is 0, North is 90, ...) to a compass heading (where North is 0, East is 90, ...).
    
    Parameters:
    
    math -
    
    Returns:
    
    degrees always >=0 and <360 (compass=NaN -> 0).
  - anglePM180
```
public static final double anglePM180(double degrees)
```
    This converts an angle (in degrees) into the range >=-180 to <180 (180 becomes -180).
    
    Parameters:
    
    degrees - an angle (in degrees)
    
    Returns:
    
    the angle (in degrees) in the range >=-180 to <180. If isMV(angle), it returns 0.
  - looserAnglePM180
```
public static final double looserAnglePM180(double degrees)
```
    This converts an angle (in degrees) into the range >=-180 to <=180 (note 180 is valid).
    
    Parameters:
    
    degrees - an angle (in degrees)
    
    Returns:
    
    the angle (in degrees) in the range >=-180 to <=180. A non-finite degrees returns the original value.
  - angle02Pi
```
public static final double angle02Pi(double radians)
```
    This converts an angle (in radians) into the range >=0 to <2PI.
    - If !Double.isFinite(angle), it returns 0.
  - gcd
```
public static int gcd(int n,
                      int d)
```
    Finds the greatest common divisor.
    - Euclidean greatest common divisor algorithm.
    - If either is 0, it returns 1.
    - For example, gcd(18,30) returns 6.
  - guessFrac
```
public static void guessFrac(double r,
                             int[] int3)
```
    Looks for a fraction very close to some decimal value.
    - Tries denominators 1..1000. So answer is at least accurate to within 1/1000th. For example, .33333 -> 1/3.
    - For example: -1.75 -> whole=-1, numerator=-3 denominator=4
    - Results stored in int3[0=whole, 1=num, 2=den].
    - Slow if no good match found, but this does a good approximate job that gcd() might miss.
      int ar[]=new int[3]; double d=-1.75; int whole=guessFrac(d,ar); //results: ar[0]=-1, ar[1]=-3, ar[2]=4
  - guessFracString
```
public static java.lang.String guessFracString(double d)
```
    This creates a String based on the results of guessFrac()
  - longToDoubleNaN
```
public static final double longToDoubleNaN(long tl)
```
    This converts a long to a double (Long.MAX_VALUE becomes NaN).
    
    Parameters:
    
    tl -
    
    Returns:
    
    a double. If f is NaN or +-INFINITY, this returns Double.NaN.
  - floatToDouble
```
public static final double floatToDouble(double f)
```
    Safely converts a float to a double.
    
    Parameters:
    
    f - a double or float
    
    Returns:
    
    an unbruised double (not xxxx999999 or xxxx000001). If f is NaN, this returns Double.NaN. If f is +-INFINITY, this returns Double.+-INFINITY.
  - floatToDoubleNaN
```
public static final double floatToDoubleNaN(double f)
```
    Crudely (not nicely) converts a float to a double (including the non-standard conversion of INFINITY values to NaN). See floatToDouble.
    
    Parameters:
    
    f - a float or double
    
    Returns:
    
    a double. If f is NaN or +-INFINITY, this returns Double.NaN.
  - doubleToFloatNaN
```
public static final float doubleToFloatNaN(double d)
```
    Safely converts a double to a float (including the non-standard conversion of large values to Float.NaN, not Float.POSITIVE_INFINITY).
    
    Parameters:
    
    d - a double
    
    Returns:
    
    a float. If f is not finite or greater than Float.MAX_VALUE, this returns Float.NaN.
  - niceDouble
```
public static final double niceDouble(double d,
                                      int nDigits)
```
    Safely tries to un-bruise a double (8.999999999 -> 9.0, or 1.000000001 -> 1.0).
    - nDigits specifies how many digits. Use 7 for converting float to double. Use 11 for converting 6byte real to double.
    - nGoodDigits afterward is ~ 22-nDigits.
    Parameters:
    
    d - a double (often bruised)
    
    nDigits - the desired number of significant digits
  - setSeed
```
public static void setSeed(long seed)
```
    This sets the seed for the next call to random(). You can use this for testing purposes if you need to get repeatable results from random().
    
    Parameters:
    
    seed - the new seed -- be sure that it is randomly chosen from the full range of longs
  - random
```
public static int random(int max)
```
    This returns a random integer between 0 and max-1. For testing purposes, you can call Math2.setSeed(long seed) to get repeatable results.
    
    Parameters:
    
    max - a int greater than 0
    
    Returns:
    
    a "random" number in the range 0 .. max-1
  - bigger
```
public static double bigger(double d)
```
    This increases the value (nicely).
    
    Parameters:
    
    d - a double
    
    Returns:
    
    a number slightly larger than d. If !Double.isFinite(d), it returns d. If almost 0, it returns 0.01.
  - smaller
```
public static double smaller(double d)
```
    This decreases the value (nicely).
    
    Parameters:
    
    d - a double
    
    Returns:
    
    a number slightly smaller than d. If !Double.isFinite(d), it returns d. If almost 0, it returns -0.01.
  - oneDigitBigger
```
public static double oneDigitBigger(double max,
                                    double def,
                                    double d)
```
    This increases the first digit of d (for example, .8, .9, 1, 2, 3, ..., 9, 10, 20, 30, ...). It rounds to nearest single digit mantissa, then changes it. If !Double.isFinite(d), it returns def. If d = 0, it returns 1.
    
    Parameters:
    
    max - the maximum value which may be returned
    
    def - the default value, to be used if !isFinite
    
    d - the initial value
    
    Returns:
    
    d, rounded to a single digit mantissa and with the initial digit increased
  - oneDigitSmaller
```
public static double oneDigitSmaller(double min,
                                     double def,
                                     double d)
```
    This decreases the first digit of d (for example, 30, 20, 10, 9, ..., 3, 2, 1, .9, .8, ...). It rounds to nearest single digit mantissa, then changes it. If !Double.isFinite(d), it returns def. If d = 0, it returns -1.
    
    Parameters:
    
    min - the minimum value which may be returned
    
    def - the default value, to be used if !isFinite
    
    d - the initial value
    
    Returns:
    
    d, rounded to a single digit mantissa and with the initial digit decreased
  - getSmallIncrement
```
public static double getSmallIncrement(double range)
```
    This returns a small increment roughly 1/100th the range (e.g., .1, 1, 10, ....).
    
    Parameters:
    
    range -
    
    Returns:
    
    an appropriate increment for the range
  - biggerDouble
```
public static double biggerDouble(double def,
                                  double mult,
                                  double max,
                                  double d)
```
    This increases d to the next multiple of mult.
    
    Parameters:
    
    def - the default value
    
    mult - the multiple
    
    max - the maximum value
    
    d - the initial value
    
    Returns:
    
    the next multiple of mult bigger than d. It rounds to nearest mult, then changes it. If !Double.isFinite(d), it returns def.
  - smallerDouble
```
public static double smallerDouble(double def,
                                   double mult,
                                   double min,
                                   double d)
```
    This decreases d to the previous multiple of mult.
    
    Parameters:
    
    def - the default value
    
    mult - the multiple
    
    min - the minimum value
    
    d - the initial value
    
    Returns:
    
    the next multiple of mult smaller than d. It rounds to nearest mult, then changes it. If !Double.isFinite(d), it returns def.
  - biggerAngle
```
public static double biggerAngle(double d)
```
    This increases the double degrees value (nicely), and returns it as a string.
    
    Parameters:
    
    d - the initial value
    
    Returns:
    
    the next multiple 15. It rounds to nearest mult, then changes it. If !Double.isFinite(d), it returns d.
  - smallerAngle
```
public static double smallerAngle(double d)
```
    This decreases the double degree value (nicely).
    
    Parameters:
    
    d - the initial value
    
    Returns:
    
    the previous multiple 15. It rounds to nearest mult, then changes it. If !Double.isFinite(d), it returns d.
  - bigger15
```
public static double bigger15(double d)
```
    This increases the value (nicely) so the mantissa is 1 or 5.
    
    Parameters:
    
    d - the initial value
    
    Returns:
    
    the next 1 or 5 * 10^x. It rounds to nearest 1 or 5, then changes it. If !Double.isFinite(d), it returns d. If almost0(d), it returns 0.01.
  - smaller15
```
public static double smaller15(double d)
```
    This gets the double value from the string, decreases it (nicely), so the mantissa is 1 or 5.
    
    Parameters:
    
    d - the initial value
    
    Returns:
    
    the next 1 or 5 * 10^x. It rounds to nearest 1 or 5, then changes it. If !Double.isFinite(d), it returns d. If almost0(d), it returns 0.01.
  - suggestLowHigh
```
public static double[] suggestLowHigh(double low,
                                      double high)
```
    This returns a nice bounding range (e.g., for an axis) which includes low and high.
    
    Parameters:
    
    low - the low end of the range
    
    high - the high end of the range
    
    Returns:
    
    returnLowHigh an array with 2 elements. The resulting bounds are stored as [0]=low and [1]=high. If low and high are not finite, this returns 0,1. In all other cases, this returns an appropriate wider range.
  - suggestDivisions
```
public static double[] suggestDivisions(double range)
```
    This suggests the division distance along an axis so that there will be about 5-7 primary divisions and 10-25 secondary.
    
    Parameters:
    
    range - the range of the axis, e.g., an axis spanning 30 - 50 would have a range of 20
    
    Returns:
    
    a double[2] with [0]=suggested major division distance and [1]=suggested minor division distance. If range isn't finite, this returns 2 Double.NaN's. If range == 0, this returns 1 and .5. If range < 0, this uses Math.abs(range).
  - suggestMaxDivisions
```
public static double suggestMaxDivisions(double range,
                                         int maxDivisions)
```
    This suggests the division distance along an axis so that there will be between maxDivisions/2 and maxDivisions.
    
    Parameters:
    
    range - the range of the axis, e.g., an axis spanning 30 - 50 would have a range of 20
    
    maxDivisions - the maximum number of divisions (segments). If you have maxNValues, use maxNValues-1 to call this method.
    
    Returns:
    
    a double with the suggested division distance. If range isn't finite, this returns NaN. If range == 0, this returns 1. If range < 0, this the result will be negative. If maxDivisions == 0, this returns range. If maxDivisions < 0, this uses Math.abs(maxDivisions).
  - binaryFindLastLE
```
public static int binaryFindLastLE(double[] dar,
                                   double x)
```
    Find the last element which is <= x in an ascending sorted array.
    If firstGE > lastLE, there are no matching elements (because the requested range is less than or greater than all the values, or between two adjacent values).
    
    Parameters:
    
    dar - an ascending sorted double[] which may have duplicate values
    
    x -
    
    Returns:
    
    the index of the last element which is <= x in an ascending sorted array. If x < the smallest element, this returns -1 (no element is appropriate). If x > the largest element, this returns dar.length-1. If x is NaN, this is currently undefined.
  - binaryFindLastLAE
```
public static int binaryFindLastLAE(double[] dar,
                                    double x,
                                    int precision)
```
    Find the last element which is <x or almostEqual(5, x) in an ascending sorted array.
    If firstGE > lastLE, there are no matching elements (because the requested range is less than or greater than all the values, or between two adjacent values).
    
    Parameters:
    
    dar - an ascending sorted double[] which may have duplicate values
    
    x -
    
    precision - e.g., 5 for floats and 9 for doubles
    
    Returns:
    
    the index of the last element which is <= x in an ascending sorted array. If x < the smallest element, this returns -1 (no element is appropriate). If x > the largest element, this returns dar.length-1. If x is NaN, this is currently undefined.
  - binaryFindFirstGE
```
public static int binaryFindFirstGE(double[] dar,
                                    double x)
```
    Find the first element which is >= x in an ascending sorted array.
    If firstGE > lastLE, there are no matching elements (because the requested range is less than or greater than all the values, or between two adjacent values).
    
    Parameters:
    
    dar - an ascending sorted double[] which currently may not have duplicate values
    
    x -
    
    Returns:
    
    the index of the first element which is >= x in an ascending sorted array. If x < the smallest element, this returns 0. If x > the largest element, this returns dar.length (no element is appropriate). If x is NaN, this is currently undefined.
  - binaryFindFirstGAE
```
public static int binaryFindFirstGAE(double[] dar,
                                     double x,
                                     int precision)
```
    Find the first element which is >x or almostEqual(precision, x) in an ascending sorted array.
    If firstGE > lastLE, there are no matching elements (because the requested range is less than or greater than all the values, or between two adjacent values).
    
    Parameters:
    
    dar - an ascending sorted double[] which currently may not have duplicate values
    
    x -
    
    precision - e.g., 5 for floats and 9 for doubles
    
    Returns:
    
    the index of the first element which is >= x in an ascending sorted array. If x < the smallest element, this returns 0. If x > the largest element, this returns dar.length (no element is appropriate). If x is NaN, this is currently undefined.
  - binaryFindClosest
```
public static int binaryFindClosest(double[] dar,
                                    double x)
```
    Find the closest element to x in an ascending sorted array.
    
    Parameters:
    
    dar - an ascending sorted double[]. It the array has duplicates and x equals one of them, it isn't specified which duplicate's index will be returned.
    
    x -
    
    Returns:
    
    the index of the index of the element closest to x. If x is NaN, this returns -1.
  - reduceHashCode
```
public static java.lang.String reduceHashCode(int hashCode)
```
    This reduces a hash code (currently to a 10 digit unsigned number -- no loss of information). For much stronger than hashCode, use String2.md5Hex or even String2.md5Hex12.
    
    Parameters:
    
    hashCode -
    
    Returns:
    
    the reduced version
  - finiteMin
```
public static double finiteMin(double a,
                               double b)
```
    This returns the lesser value. If one is NaN and the other isn't, this returns the other.
  - finiteMax
```
public static double finiteMax(double a,
                               double b)
```
    This returns the greater value. If one is NaN and the other isn't, this returns the other.
  - equalsIncludingNanOrInfinite
```
public static boolean equalsIncludingNanOrInfinite(double a,
                                                   double b)
```
    This returns true if a == b. This treats as true: NaN=NaN (which Java says is false), NEGATIVE_INFINITY=NEGATIVE_INFINITY, and POSITIVE_INFINITY=POSITIVE_INFINITY.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
    
    true if a == b.
  - equalsIncludingNanOrInfinite
```
public static boolean equalsIncludingNanOrInfinite(float a,
                                                   float b)
```
    This returns true if a == b. This treats as true: NaN=NaN (which Java says is false), NEGATIVE_INFINITY=NEGATIVE_INFINITY, and POSITIVE_INFINITY=POSITIVE_INFINITY.
    
    Parameters:
    
    a -
    
    b -
    
    Returns:
    
    true if a == b.

Class ScriptMath2

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

fEps

dEps

OneRadian

TwoPi

ln10

ln2

kelvinToC

Binary0

BinaryLimit

BytesPerKB

BytesPerMB

BytesPerGB

BytesPerTB

BytesPerPB

loAnd

meterPerFoot

mPerMile

kmPerMile

Two

Ten

InverseTen

COMMON_MV9

Constructor Detail

ScriptMath2

Method Detail

trunc

truncToInt

frac

sign1

intExponent

exponent

mantissa

NaNCheck

odd

ten

binaryExponent

almost0

lessThanAE

greaterThanAE

almostEqual

almostEqual

roundDiv

hiDiv

hiDiv

floorDiv

floorDiv

minMax

minMax

minMaxDef

minMaxDef

roundToByte

roundToChar

roundToShort

roundToInt

roundToLong

roundToDouble

roundTo

narrowToByte

narrowToByte

narrowToChar

narrowToChar

narrowToShort

narrowToShort

narrowToInt

byteToChar

unsignedByte

angle0360

looserAngle0360

compassToMathDegrees

mathToCompassDegrees

anglePM180

looserAnglePM180

angle02Pi

gcd