MathPlume (plume-util 1.0.6 API)

java.lang.Object
- org.plumelib.util.MathPlume

public final class MathPlume
extends java.lang.Object

Mathematical utilities.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static int`	`bitwiseAnd(int x, int y)` Returns x & y, the bitwise and of its arguments.
`static long`	`bitwiseAnd(long x, long y)` Returns x & y, the bitwise and of its arguments.
`static int`	`bitwiseComplement(int a)` Returns ~a, the bitwise complement of its argument.
`static long`	`bitwiseComplement(long a)` Returns ~a, the bitwise complement of its argument.
`static int`	`bitwiseOr(int x, int y)` Returns x \| y, the bitwise or of its arguments.
`static long`	`bitwiseOr(long x, long y)` Returns x \| y, the bitwise or of its arguments.
`static int`	`bitwiseXor(int x, int y)` Returns x ^ y, the bitwise xor of its arguments.
`static long`	`bitwiseXor(long x, long y)` Returns x ^ y, the bitwise xor of its arguments.
`static double`	`div(double x, double y)` Divides its arguments.
`static int`	`div(int x, int y)` Divides its arguments.
`static long`	`div(long x, long y)` Divides its arguments.
`static double`	`gcd(double[] a)` Return the greatest common divisor of the elements of double array a.
`static double`	`gcd(double a, double b)` Return the greatest common divisor of the two arguments.
`static int`	`gcd(int[] a)` Return the greatest common divisor of the elements of int array a.
`static int`	`gcd(int a, int b)` Return the greatest common divisor of the two arguments.
`static long`	`gcd(long[] a)` Return the greatest common divisor of the elements of long array a.
`static long`	`gcd(long a, long b)` Return the greatest common divisor of the two arguments.
`static double`	`gcdDifferences(double[] a)` Return the gcd (greatest common divisor) of the differences between the elements of double array a.
`static int`	`gcdDifferences(int[] a)` Return the gcd (greatest common divisor) of the differences between the elements of int array a.
`static long`	`gcdDifferences(long[] a)` Return the gcd (greatest common divisor) of the differences between the elements of long array a.
`static int`	`logicalAnd(int x, int y)` Returns the logical and of its arguments.
`static long`	`logicalAnd(long x, long y)` Returns the logical and of its arguments.
`static int`	`logicalOr(int x, int y)` Returns the logical or of its arguments.
`static long`	`logicalOr(long x, long y)` Returns the logical or of its arguments.
`static int`	`logicalXor(int x, int y)` Returns the logical xor of its arguments.
`static long`	`logicalXor(long x, long y)` Returns the logical xor of its arguments.
`static int`	`lshift(int x, int y)` Returns x << y, the left-shift operation applied to its arguments.
`static long`	`lshift(long x, long y)` Returns x << y, the left-shift operation applied to its arguments.
`static int[]`	`missingNumbers(int[] nums)` Return an array containing all the numbers not in its argument array (which must be non-empty) but in the argument's range; that is, bigger than its argument's minimum value and smaller than its argument's maximum value.
`static long[]`	`missingNumbers(long[] nums)` Return an array containing all the numbers not in its argument array (which must be non-empty) but in the argument's range; that is, bigger than its argument's minimum value and smaller than its argument's maximum value.
`static int`	`mod(int x, int y)` Returns x % y, the modulus operation applied to its arguments.
`static long`	`mod(long x, long y)` Returns x % y, the modulus operation applied to its arguments.
`static int`	`modNonnegative(int x, int y)` Return z such that `(z == x mod y) && (0 <= z < abs(y))`.
`static long`	`modNonnegative(long x, long y)` Return z such that `(z == x mod y) && (0 <= z < abs(y))`.
`static int`	`modPositive(int x, int y)` Deprecated. use modNonnegative instead
`static long`	`modPositive(long x, long y)` Deprecated. use modNonnegative instead
`static int[]`	`modulus(int[] nums)` Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m).
`static long[]`	`modulus(long[] nums)` Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m).
`static int[]`	`modulusInt(java.util.Iterator<java.lang.Integer> itor)` The iterator produces Integer values.
`static long[]`	`modulusLong(java.util.Iterator<java.lang.Long> itor)` The iterator produces Long values.
`static int[]`	`modulusStrict(int[] nums, boolean nonstrictEnds)` Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m).
`static long[]`	`modulusStrict(long[] nums, boolean nonstrictEnds)` Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m).
`static int[]`	`modulusStrictInt(java.util.Iterator<java.lang.Integer> itor, boolean nonstrictEnds)` The iterator produces Integer values.
`static long[]`	`modulusStrictLong(java.util.Iterator<java.lang.Long> itor, boolean nonstrictEnds)` The iterator produces Long values.
`static double`	`mul(double x, double y)` Multiplies its arguments.
`static int`	`mul(int x, int y)` Multiplies its arguments.
`static long`	`mul(long x, long y)` Multiplies its arguments.
`static double`	`negate(double a)` Negates its argument.
`static int`	`negate(int a)` Negates its argument.
`static long`	`negate(long a)` Negates its argument.
`static int[]`	`nonmodulusNonstrict(int[] nums)` Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but for every number in NUMS, at least one is equal to every non-r remainder.
`static long[]`	`nonmodulusNonstrict(long[] nums)` Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but for every number in NUMS, at least one is equal to every non-r remainder.
`static int[]`	`nonmodulusStrict(int[] nums)` Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are.
`static long[]`	`nonmodulusStrict(long[] nums)` Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are.
`static int[]`	`nonmodulusStrictInt(java.util.Iterator<java.lang.Integer> nums)` Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are.
`static long[]`	`nonmodulusStrictLong(java.util.Iterator<java.lang.Long> nums)` Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are.
`static int`	`pow(int base, int expt)` Returns of value of the first argument raised to the power of the second argument.
`static long`	`pow(long base, long expt)` Returns of value of the first argument raised to the power of the second argument.
`static int`	`rshiftSigned(int x, int y)` Returns x >> y, the signed right-shift operation applied to its arguments.
`static long`	`rshiftSigned(long x, long y)` Returns x >> y, the signed right-shift operation applied to its arguments.
`static int`	`rshiftUnsigned(int x, int y)` Returns x >>> y, the unsigned right-shift operation applied to its arguments.
`static long`	`rshiftUnsigned(long x, long y)` Returns x >>> y, the unsigned right-shift operation applied to its arguments.
`static int`	`sign(int a)` Returns the sign of its argument.

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

- Method Detail
  - negate
```
@Pure
public static int negate(int a)
```
    Negates its argument.
    
    Parameters:
    
    a - value to negate
    
    Returns:
    
    negative of a
  - negate
```
@Pure
public static long negate(long a)
```
    Negates its argument.
    
    Parameters:
    
    a - value to negate
    
    Returns:
    
    negative of a
  - negate
```
@Pure
public static double negate(double a)
```
    Negates its argument.
    
    Parameters:
    
    a - value to negate
    
    Returns:
    
    negative of a
  - bitwiseComplement
```
@Pure
public static int bitwiseComplement(int a)
```
    Returns ~a, the bitwise complement of its argument.
    
    Parameters:
    
    a - value to bitwise-complement
    
    Returns:
    
    ~a, the bitwise complement of a
  - bitwiseComplement
```
@Pure
public static long bitwiseComplement(long a)
```
    Returns ~a, the bitwise complement of its argument.
    
    Parameters:
    
    a - value to bitwise-complement
    
    Returns:
    
    ~a, the bitwise complement of a
  - mul
```
@Pure
public static int mul(int x,
                            int y)
```
    Multiplies its arguments.
    
    Parameters:
    
    x - first multiplicand
    
    y - second multiplicand
    
    Returns:
    
    x * y
  - mul
```
@Pure
public static long mul(long x,
                             long y)
```
    Multiplies its arguments.
    
    Parameters:
    
    x - first multiplicand
    
    y - second multiplicand
    
    Returns:
    
    x * y
  - mul
```
@Pure
public static double mul(double x,
                               double y)
```
    Multiplies its arguments.
    
    Parameters:
    
    x - first multiplicand
    
    y - second multiplicand
    
    Returns:
    
    x * y
  - div
```
@Pure
public static int div(int x,
                            int y)
```
    Divides its arguments.
    
    Parameters:
    
    x - dividend
    
    y - divisor
    
    Returns:
    
    x / y
  - div
```
@Pure
public static long div(long x,
                             long y)
```
    Divides its arguments.
    
    Parameters:
    
    x - dividend
    
    y - divisor
    
    Returns:
    
    x / y
  - div
```
@Pure
public static double div(double x,
                               double y)
```
    Divides its arguments.
    
    Parameters:
    
    x - dividend
    
    y - divisor
    
    Returns:
    
    x / y
  - mod
```
@Pure
public static int mod(int x,
                            int y)
```
    Returns x % y, the modulus operation applied to its arguments.
    
    Parameters:
    
    x - valued to be modded
    
    y - modulus
    
    Returns:
    
    x % y
  - mod
```
@Pure
public static long mod(long x,
                             long y)
```
    Returns x % y, the modulus operation applied to its arguments.
    
    Parameters:
    
    x - valued to be modded
    
    y - modulus
    
    Returns:
    
    x % y
  - lshift
```
@Pure
public static int lshift(int x,
                               int y)
```
    Returns x << y, the left-shift operation applied to its arguments.
    
    Parameters:
    
    x - valued to be left-shifted
    
    y - magnitude of the left-shift
    
    Returns:
    
    x << y
  - lshift
```
@Pure
public static long lshift(long x,
                                long y)
```
    Returns x << y, the left-shift operation applied to its arguments.
    
    Parameters:
    
    x - valued to be left-shifted
    
    y - magnitude of the left-shift
    
    Returns:
    
    x << y
  - rshiftSigned
```
@Pure
public static int rshiftSigned(int x,
                                     int y)
```
    Returns x >> y, the signed right-shift operation applied to its arguments.
    
    Parameters:
    
    x - valued to be right-shifted
    
    y - magnitude of the right-shift
    
    Returns:
    
    x >> y
  - rshiftSigned
```
@Pure
public static long rshiftSigned(long x,
                                      long y)
```
    Returns x >> y, the signed right-shift operation applied to its arguments.
    
    Parameters:
    
    x - valued to be right-shifted
    
    y - magnitude of the right-shift
    
    Returns:
    
    x >> y
  - rshiftUnsigned
```
@Pure
public static int rshiftUnsigned(int x,
                                       int y)
```
    Returns x >>> y, the unsigned right-shift operation applied to its arguments.
    
    Parameters:
    
    x - valued to be right-shifted
    
    y - magnitude of the right-shift
    
    Returns:
    
    x >>> y
  - rshiftUnsigned
```
@Pure
public static long rshiftUnsigned(long x,
                                        long y)
```
    Returns x >>> y, the unsigned right-shift operation applied to its arguments.
    
    Parameters:
    
    x - valued to be right-shifted
    
    y - magnitude of the right-shift
    
    Returns:
    
    x >>> y
  - bitwiseAnd
```
@Pure
public static int bitwiseAnd(int x,
                                   int y)
```
    Returns x & y, the bitwise and of its arguments.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    x & y
  - bitwiseAnd
```
@Pure
public static long bitwiseAnd(long x,
                                    long y)
```
    Returns x & y, the bitwise and of its arguments.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    x & y
  - logicalAnd
```
@Pure
public static int logicalAnd(int x,
                                   int y)
```
    Returns the logical and of its arguments. The result is always 0 or 1.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    the logical and of x and y; the result is always 0 or 1
  - logicalAnd
```
@Pure
public static long logicalAnd(long x,
                                    long y)
```
    Returns the logical and of its arguments. The result is always 0 or 1.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    the logical and of x and y; the result is always 0 or 1
  - bitwiseXor
```
@Pure
public static int bitwiseXor(int x,
                                   int y)
```
    Returns x ^ y, the bitwise xor of its arguments.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    x ^ y
  - bitwiseXor
```
@Pure
public static long bitwiseXor(long x,
                                    long y)
```
    Returns x ^ y, the bitwise xor of its arguments.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    x ^ y
  - logicalXor
```
@Pure
public static int logicalXor(int x,
                                   int y)
```
    Returns the logical xor of its arguments. The result is always 0 or 1.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    the logical xor of x and y; the result is always 0 or 1
  - logicalXor
```
@Pure
public static long logicalXor(long x,
                                    long y)
```
    Returns the logical xor of its arguments. The result is always 0 or 1.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    the logical xor of x and y; the result is always 0 or 1
  - bitwiseOr
```
@Pure
public static int bitwiseOr(int x,
                                  int y)
```
    Returns x | y, the bitwise or of its arguments.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    x | y
  - bitwiseOr
```
@Pure
public static long bitwiseOr(long x,
                                   long y)
```
    Returns x | y, the bitwise or of its arguments.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    x | y
  - logicalOr
```
@Pure
public static int logicalOr(int x,
                                  int y)
```
    Returns the logical or of its arguments. The result is always 0 or 1.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    the logical or of x and y; the result is always 0 or 1
  - logicalOr
```
@Pure
public static long logicalOr(long x,
                                   long y)
```
    Returns the logical or of its arguments. The result is always 0 or 1.
    
    Parameters:
    
    x - first operand
    
    y - second operand
    
    Returns:
    
    the logical or of x and y; the result is always 0 or 1
  - sign
```
@Pure
public static int sign(int a)
```
    Returns the sign of its argument. The result is always -1, 0, or 1.
    
    Parameters:
    
    a - value to have its sign taken
    
    Returns:
    
    the sign of a: -1, 0, or 1
  - pow
```
@Pure
public static int pow(int base,
                            int expt)
                     throws java.lang.ArithmeticException
```
    Returns of value of the first argument raised to the power of the second argument. The arguments are integers.
    
    Parameters:
    
    base - the base
    
    expt - the exponent
    
    Returns:
    
    base to the expt power
    
    Throws:
    
    java.lang.ArithmeticException
    
    See Also:
    
    Math.pow(double, double)
  - pow
```
@Pure
public static long pow(long base,
                             long expt)
                      throws java.lang.ArithmeticException
```
    Returns of value of the first argument raised to the power of the second argument.
    
    Parameters:
    
    base - the base
    
    expt - the exponent
    
    Returns:
    
    base to the expt power
    
    Throws:
    
    java.lang.ArithmeticException
    
    See Also:
    
    Math.pow(double, double)
  - gcd
```
@Pure
public static int gcd(int a,
                            int b)
```
    Return the greatest common divisor of the two arguments.
    
    Parameters:
    
    a - first operand
    
    b - second operand
    
    Returns:
    
    greatest common divisor of a and b
  - gcd
```
@Pure
public static int gcd(int[] a)
```
    Return the greatest common divisor of the elements of int array a.
    
    Parameters:
    
    a - array of operands
    
    Returns:
    
    greatest common divisor of the elements of a
  - gcdDifferences
```
@Pure
public static int gcdDifferences(int[] a)
```
    Return the gcd (greatest common divisor) of the differences between the elements of int array a.
    
    Parameters:
    
    a - array of operands
    
    Returns:
    
    greatest common divisor of the differences between the elements of a
  - gcd
```
@Pure
public static long gcd(long a,
                             long b)
```
    Return the greatest common divisor of the two arguments.
    
    Parameters:
    
    a - first operand
    
    b - second operand
    
    Returns:
    
    greatest common divisor of a and b
  - gcd
```
@Pure
public static long gcd(long[] a)
```
    Return the greatest common divisor of the elements of long array a.
    
    Parameters:
    
    a - array of operands
    
    Returns:
    
    greatest common divisor of the elements of a
  - gcdDifferences
```
@Pure
public static long gcdDifferences(long[] a)
```
    Return the gcd (greatest common divisor) of the differences between the elements of long array a.
    
    Parameters:
    
    a - array of operands
    
    Returns:
    
    greatest common divisor of the differences between the elements of a
  - gcd
```
@Pure
public static double gcd(double a,
                               double b)
```
    Return the greatest common divisor of the two arguments.
    
    Parameters:
    
    a - first operand
    
    b - second operand
    
    Returns:
    
    greatest common divisor of a and b
  - gcd
```
@Pure
public static double gcd(double[] a)
```
    Return the greatest common divisor of the elements of double array a.
    
    Parameters:
    
    a - array of operands
    
    Returns:
    
    greatest common divisor of the elements of a
  - gcdDifferences
```
@Pure
public static double gcdDifferences(double[] a)
```
    Return the gcd (greatest common divisor) of the differences between the elements of double array a.
    
    Parameters:
    
    a - array of operands
    
    Returns:
    
    greatest common divisor of the differences between the elements of a
  - modPositive
```
@Deprecated
 @Pure
public static int modPositive(int x,
                                                 int y)
```
    Deprecated. use modNonnegative instead
    
    Return z such that (z == x mod y) && (0 <= z < abs(y)). This should really be named modNonnegative rather than modPositive.
    
    Parameters:
    
    x - value to be modded
    
    y - modulus
    
    Returns:
    
    x % y, where the result is constrained to be non-negative
  - modNonnegative
```
@Pure
public static int modNonnegative(int x,
                                       int y)
```
    Return z such that (z == x mod y) && (0 <= z < abs(y)).
    
    Parameters:
    
    x - value to be modded
    
    y - modulus
    
    Returns:
    
    x % y, where the result is constrained to be non-negative
  - modulus
```
@Pure
public static int[] modulus(int[] nums)
```
    Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m). The largest possible modulus is used, and the trivial constraint that all integers are equal to 0 mod 1 is not returned (null is returned instead). Also, return null if the array is less than 3 elements long.
    
    Parameters:
    
    nums - array of operands
    
    Returns:
    
    an array of two integers (r,m) such that each number in NUMS is equal to r (mod m), or null if no such exists or the iterator contains fewer than 3 elements
  - modulusInt
```
public static int[] modulusInt(java.util.Iterator<java.lang.Integer> itor)
```
    The iterator produces Integer values. This can be more efficient than modulus(int[]) if the int[] doesn't already exist, because this does not necessarily examine every value produced by its iterator.
    
    Parameters:
    
    itor - iterator of operands
    
    Returns:
    
    an array of two integers (r,m) such that each number in itor is equal to r (mod m), or null if no such exists or the iterator contains fewer than 3 elements
    
    See Also:
    
    modulus(int[])
  - modulusStrict
```
@Pure
public static int[] modulusStrict(int[] nums,
                                        boolean nonstrictEnds)
```
    Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m). The largest possible modulus is used, and the trivial constraint that all integers are equal to 0 mod 1 is not returned (null is returned instead).
    This "Strict" version requires its input to be sorted, and no element may be missing.
    This "Strict" version differs from the regular modulus by requiring that the argument be dense: that is, every pair of numbers in the argument array is separated by exactly the modulus.
    The endpoints can be treated in two different ways: Either exactly like other numbers in the input, or they can merely be checked for the condition without the strict density requirement.
    
    Parameters:
    
    nums - array of operands
    
    nonstrictEnds - whether endpoints are NOT subject to the strict density requirement
    
    Returns:
    
    an array of two integers (r,m) such that each number in NUMS is equal to r (mod m), or null if no such exists or the array contains fewer than 3 elements
  - modulusStrictInt
```
public static int[] modulusStrictInt(java.util.Iterator<java.lang.Integer> itor,
                                     boolean nonstrictEnds)
```
    The iterator produces Integer values. This can be more efficient than modulus(int[]) if the int[] doesn't already exist, because this does not necessarily examine every value produced by its iterator.
    For documentation, see modulusStrict(int[], boolean).
    
    Parameters:
    
    itor - iterator of operands
    
    nonstrictEnds - whether endpoints are NOT subject to the strict density requirement
    
    Returns:
    
    an array of two integers (r,m) such that each number in NUMS is equal to r (mod m), or null if no such exists or the iterator contains fewer than 3 elements
    
    See Also:
    
    modulusStrict(int[], boolean)
  - modPositive
```
@Deprecated
 @Pure
public static long modPositive(long x,
                                                  long y)
```
    Deprecated. use modNonnegative instead
    
    Return z such that (z == x mod y) && (0 <= z < abs(y)). This should really be named modNonnegative rather than modPositive.
    
    Parameters:
    
    x - value to be modded
    
    y - modulus
    
    Returns:
    
    x % y, where the result is constrained to be non-negative
  - modNonnegative
```
@Pure
public static long modNonnegative(long x,
                                        long y)
```
    Return z such that (z == x mod y) && (0 <= z < abs(y)).
    
    Parameters:
    
    x - value to be modded
    
    y - modulus
    
    Returns:
    
    x % y, where the result is constrained to be non-negative
  - modulus
```
@Pure
public static long[] modulus(long[] nums)
```
    Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m). The largest possible modulus is used, and the trivial constraint that all integers are equal to 0 mod 1 is not returned (null is returned instead). Also, return null if the array is less than 3 elements long.
    
    Parameters:
    
    nums - array of operands
    
    Returns:
    
    an array of two integers (r,m) such that each number in NUMS is equal to r (mod m), or null if no such exists or the iterator contains fewer than 3 elements
  - modulusLong
```
public static long[] modulusLong(java.util.Iterator<java.lang.Long> itor)
```
    The iterator produces Long values. This can be more efficient than modulus(long[]) if the long[] doesn't already exist, because this does not necessarily examine every value produced by its iterator.
    
    Parameters:
    
    itor - iterator of operands
    
    Returns:
    
    an array of two integers (r,m) such that each number in itor is equal to r (mod m), or null if no such exists or the iterator contains fewer than 3 elements
    
    See Also:
    
    modulus(long[])
  - modulusStrict
```
@Pure
public static long[] modulusStrict(long[] nums,
                                         boolean nonstrictEnds)
```
    Return an array of two integers (r,m) such that each number in NUMS is equal to r (mod m). The largest possible modulus is used, and the trivial constraint that all integers are equal to 0 mod 1 is not returned (null is returned instead).
    This "Strict" version requires its input to be sorted, and no element may be missing.
    This "Strict" version differs from the regular modulus by requiring that the argument be dense: that is, every pair of numbers in the argument array is separated by exactly the modulus.
    The endpoints can be treated in two different ways: Either exactly like other numbers in the input, or they can merely be checked for the condition without the strict density requirement.
    
    Parameters:
    
    nums - array of operands
    
    nonstrictEnds - whether endpoints are NOT subject to the strict density requirement
    
    Returns:
    
    an array of two integers (r,m) such that each number in NUMS is equal to r (mod m), or null if no such exists or the array contains fewer than 3 elements
  - modulusStrictLong
```
public static long[] modulusStrictLong(java.util.Iterator<java.lang.Long> itor,
                                       boolean nonstrictEnds)
```
    The iterator produces Long values. This can be more efficient than modulus(long[]) if the long[] doesn't already exist, because this does not necessarily examine every value produced by its iterator.
    For documentation, see modulusStrict(long[], boolean).
    
    Parameters:
    
    itor - iterator of operands
    
    nonstrictEnds - whether endpoints are NOT subject to the strict density requirement
    
    Returns:
    
    an array of two integers (r,m) such that each number in NUMS is equal to r (mod m), or null if no such exists or the iterator contains fewer than 3 elements
    
    See Also:
    
    modulusStrict(int[], boolean)
  - missingNumbers
```
@Pure
public static int[] missingNumbers(int[] nums)
```
    Return an array containing all the numbers not in its argument array (which must be non-empty) but in the argument's range; that is, bigger than its argument's minimum value and smaller than its argument's maximum value. The result contains no duplicates and is in order.
    
    Parameters:
    
    nums - numbers to be excluded; length > 0; may contain duplicates
    
    Returns:
    
    the set: [min(nums)..max(nums)] - nums
  - nonmodulusStrict
```
@Pure
public static int[] nonmodulusStrict(int[] nums)
```
    Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are. Returns null if the input array has 0 length.
    
    Parameters:
    
    nums - the list of operands
    
    Returns:
    
    a (remainder, modulus) pair that fails to match elements of nums
  - nonmodulusStrictInt
```
public static int[] nonmodulusStrictInt(java.util.Iterator<java.lang.Integer> nums)
```
    Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are.
    
    Parameters:
    
    nums - the list of operands
    
    Returns:
    
    a (remainder, modulus) pair that fails to match elements of nums
  - nonmodulusNonstrict
```
@Pure
public static int[] nonmodulusNonstrict(int[] nums)
```
    Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but for every number in NUMS, at least one is equal to every non-r remainder. The modulus is chosen as small as possible, but no greater than half the range of the input numbers (else null is returned).
    
    Parameters:
    
    nums - the list of operands
    
    Returns:
    
    a (remainder, modulus) pair that fails to match elements of nums
  - missingNumbers
```
@Pure
public static long[] missingNumbers(long[] nums)
```
    Return an array containing all the numbers not in its argument array (which must be non-empty) but in the argument's range; that is, bigger than its argument's minimum value and smaller than its argument's maximum value. The result contains no duplicates and is in order.
    
    Parameters:
    
    nums - numbers to be excluded; length > 0; may contain duplicates
    
    Returns:
    
    the set: [min(nums)..max(nums)] - nums
  - nonmodulusStrict
```
@Pure
public static long[] nonmodulusStrict(long[] nums)
```
    Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are. Returns null if the input array has 0 length.
    
    Parameters:
    
    nums - the list of operands
    
    Returns:
    
    a (remainder, modulus) pair that fails to match elements of nums
  - nonmodulusStrictLong
```
public static long[] nonmodulusStrictLong(java.util.Iterator<java.lang.Long> nums)
```
    Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but all missing numbers in their range are.
    
    Parameters:
    
    nums - the list of operands
    
    Returns:
    
    a (remainder, modulus) pair that fails to match elements of nums
  - nonmodulusNonstrict
```
@Pure
public static long[] nonmodulusNonstrict(long[] nums)
```
    Return a tuple of (r,m) where no number in NUMS is equal to r (mod m) but for every number in NUMS, at least one is equal to every non-r remainder. The modulus is chosen as small as possible, but no greater than half the range of the input numbers (else null is returned).
    
    Parameters:
    
    nums - the list of operands
    
    Returns:
    
    a (remainder, modulus) pair that fails to match elements of nums

Class MathPlume

Method Summary

Methods inherited from class java.lang.Object

Method Detail

negate

negate

negate

bitwiseComplement

bitwiseComplement

mul

mul

mul

div

div

div

mod

mod

lshift

lshift

rshiftSigned

rshiftSigned

rshiftUnsigned

rshiftUnsigned

bitwiseAnd

bitwiseAnd

logicalAnd

logicalAnd

bitwiseXor

bitwiseXor

logicalXor

logicalXor

bitwiseOr

bitwiseOr

logicalOr

logicalOr

sign

pow

pow

gcd

gcd

gcdDifferences

gcd

gcd

gcdDifferences

gcd

gcd

gcdDifferences

modPositive

modNonnegative

modulus

modulusInt

modulusStrict

modulusStrictInt

modPositive

modNonnegative

modulus

modulusLong

modulusStrict

modulusStrictLong

missingNumbers

nonmodulusStrict

nonmodulusStrictInt

nonmodulusNonstrict

missingNumbers

nonmodulusStrict

nonmodulusStrictLong

nonmodulusNonstrict