NumbersUtils

java.lang.Object
- org.math.plot.utils.NumbersUtils

```
public final class NumbersUtils
extends Object
```
Class containing various basic utility methods to deal with numbers. This class is meant to be light (no big look-up tables or such). Check methods return boolean if success, for it allows to use them in assertions. toString methods use capital letters, unlike JDK's toStrings, for it is more readable (especially, "l" and "1" can easily be confused with one another). Some methods have an int version additionally to the long version, even though long version could be used instead, for performance reasons, either for the methods themselves (if they do computations with ints instead of longs), or to be used in an int use case (like methods checking whether or not a signed int can fit in such number of bits).

Constructor Summary

Constructors
Constructor and Description

NumbersUtils()

Constructors
Constructor and Description
`NumbersUtils()`

Method Summary

Methods
Modifier and Type	Method and Description
`static int`	`abs(int a)` Possibly faster than java.lang.Math.abs(int).
`static long`	`abs(long a)` Possibly faster than java.lang.Math.abs(long).
`static byte`	`asByte(int a)` Not defining an asByte(long) method, since asByte((int)aLong) works.
`static int`	`asInt(long a)`
`static int`	`bitSizeForSignedValue(int value)`
`static int`	`bitSizeForSignedValue(long value)`
`static int`	`bitSizeForUnsignedValue(int value)`
`static int`	`bitSizeForUnsignedValue(long value)`
`static short`	`byteAsUnsigned(byte value)`
`static int`	`ceilingPowerOfTwo(int a)`
`static long`	`ceilingPowerOfTwo(long a)`
`static boolean`	`checkBitPositionsByte(int firstBitPos, int lastBitPosExcl)`
`static boolean`	`checkBitPositionsInt(int firstBitPos, int lastBitPosExcl)`
`static boolean`	`checkBitPositionsLong(int firstBitPos, int lastBitPosExcl)`
`static boolean`	`checkBitPositionsShort(int firstBitPos, int lastBitPosExcl)`
`static boolean`	`checkBitSizeForSignedInt(int bitSize)`
`static boolean`	`checkBitSizeForSignedLong(int bitSize)`
`static boolean`	`checkBitSizeForUnsignedInt(int bitSize)`
`static boolean`	`checkBitSizeForUnsignedLong(int bitSize)`
`static boolean`	`checkIsInRange(double min, double max, double a)`
`static boolean`	`checkIsInRange(float min, float max, float a)`
`static boolean`	`checkIsInRange(int min, int max, int a)`
`static boolean`	`checkIsInRange(long min, long max, long a)`
`static boolean`	`checkIsInRangeSigned(int a, int bitSize)`
`static boolean`	`checkIsInRangeSigned(long a, int bitSize)`
`static boolean`	`checkIsInRangeUnsigned(int a, int bitSize)`
`static boolean`	`checkIsInRangeUnsigned(long a, int bitSize)`
`static boolean`	`checkRadix(int radix)`
`static int`	`computeNbrOfChars(int value, int radix)`
`static int`	`computeNbrOfChars(int value, int radix, int paddingUpTo)`
`static int`	`computeNbrOfChars(long value, int radix)`
`static int`	`computeNbrOfChars(long value, int radix, int paddingUpTo)`
`static int`	`computeNbrOfDigits(int value, int radix)`
`static int`	`computeNbrOfDigits(int value, int radix, int paddingUpTo)`
`static int`	`computeNbrOfDigits(long value, int radix)`
`static int`	`computeNbrOfDigits(long value, int radix, int paddingUpTo)`
`static boolean`	`equal(double a, double b)`
`static boolean`	`equal(float a, float b)`
`static int`	`floorPowerOfTwo(int a)`
`static long`	`floorPowerOfTwo(long a)`
`static boolean`	`haveSameEvenness(int a, int b)`
`static boolean`	`haveSameEvenness(long a, long b)`
`static boolean`	`haveSameSign(int a, int b)`
`static boolean`	`haveSameSign(long a, long b)`
`static long`	`intAsUnsigned(int value)`
`static int`	`intHash(long a)` If the specified value is in int range, the returned value is identical.
`static int`	`intMaskLSBits0(int bitSize)`
`static int`	`intMaskLSBits1(int bitSize)`
`static int`	`intMaskMSBits0(int bitSize)`
`static int`	`intMaskMSBits1(int bitSize)`
`static boolean`	`isEven(int a)`
`static boolean`	`isEven(long a)`
`static boolean`	`isInRange(double min, double max, double a)` Returns false if any value is NaN.
`static boolean`	`isInRange(float min, float max, float a)` Returns false if any value is NaN.
`static boolean`	`isInRange(int min, int max, int a)`
`static boolean`	`isInRange(long min, long max, long a)`
`static boolean`	`isInRangeSigned(int a, int bitSize)`
`static boolean`	`isInRangeSigned(long a, int bitSize)`
`static boolean`	`isInRangeUnsigned(int a, int bitSize)`
`static boolean`	`isInRangeUnsigned(long a, int bitSize)`
`static boolean`	`isNaNOrInfinite(double a)`
`static boolean`	`isNaNOrInfinite(float a)`
`static boolean`	`isOdd(int a)`
`static boolean`	`isOdd(long a)`
`static boolean`	`isPowerOfTwo(int a)`
`static boolean`	`isPowerOfTwo(long a)`
`static boolean`	`isSignedPowerOfTwo(int a)`
`static boolean`	`isSignedPowerOfTwo(long a)`
`static boolean`	`isValidBitSizeForSignedInt(int bitSize)`
`static boolean`	`isValidBitSizeForSignedLong(int bitSize)`
`static boolean`	`isValidBitSizeForUnsignedInt(int bitSize)`
`static boolean`	`isValidBitSizeForUnsignedLong(int bitSize)`
`static int`	`log2(int value)`
`static int`	`log2(long value)`
`static long`	`longMaskLSBits0(int bitSize)`
`static long`	`longMaskLSBits1(int bitSize)`
`static long`	`longMaskMSBits0(int bitSize)`
`static long`	`longMaskMSBits1(int bitSize)`
`static int`	`maxSignedIntForBitSize(int bitSize)`
`static long`	`maxSignedLongForBitSize(int bitSize)`
`static int`	`maxUnsignedIntForBitSize(int bitSize)`
`static long`	`maxUnsignedLongForBitSize(int bitSize)`
`static int`	`meanLow(int a, int b)`
`static long`	`meanLow(long a, long b)`
`static int`	`meanSml(int a, int b)`
`static long`	`meanSml(long a, long b)`
`static int`	`minSignedIntForBitSize(int bitSize)`
`static long`	`minSignedLongForBitSize(int bitSize)`
`static int`	`minusBounded(int a, int b)`
`static long`	`minusBounded(long a, long b)`
`static int`	`minusExact(int a, int b)`
`static long`	`minusExact(long a, long b)`
`static int`	`moduloSignedPowerOfTwo(int value, int spot)` This treatment being designed for optimization, the fact that spot is a signed power of two is only checked if assertions are enabled.
`static long`	`moduloSignedPowerOfTwo(long value, long spot)` This treatment being designed for optimization, the fact that spot is a signed power of two is only checked if assertions are enabled.
`static int`	`negHalfWidth(int min, int max)` Useful because a positive int value could not represent half the width of full int range width, which is mathematically Integer.MAX_VALUE+1.
`static long`	`negHalfWidth(long min, long max)` Useful because a positive long value could not represent half the width of full long range width, which is mathematically Long.MAX_VALUE+1.
`static int`	`plusBounded(int a, int b)`
`static long`	`plusBounded(long a, long b)`
`static int`	`plusExact(int a, int b)`
`static long`	`plusExact(long a, long b)`
`static double`	`pow2(double a)`
`static float`	`pow2(float a)`
`static int`	`pow2(int a)`
`static long`	`pow2(long a)`
`static double`	`pow3(double a)`
`static float`	`pow3(float a)`
`static int`	`pow3(int a)`
`static long`	`pow3(long a)`
`static int`	`shortAsUnsigned(short value)`
`static int`	`signum(int a)`
`static int`	`signum(long a)`
`static int`	`timesBounded(int a, int b)`
`static long`	`timesBounded(long a, long b)`
`static int`	`timesExact(int a, int b)`
`static long`	`timesExact(long a, long b)`
`static int`	`toInt(long a)`
`static double`	`toRange(double min, double max, double a)`
`static float`	`toRange(float min, float max, float a)`
`static int`	`toRange(int min, int max, int a)`
`static long`	`toRange(long min, long max, long a)`
`static String`	`toString(int value)` This method just delegates to Integer.toString(int), but is defined here to complete the API.
`static String`	`toString(int value, int radix)`
`static String`	`toString(int value, int radix, int paddingUpTo)`
`static String`	`toString(long value)` This method just delegates to Long.toString(long), but is defined here to complete the API.
`static String`	`toString(long value, int radix)`
`static String`	`toString(long value, int radix, int paddingUpTo)`
`static String`	`toStringBits(byte bits)`
`static String`	`toStringBits(byte bits, int firstBitPos, int lastBitPosExcl, boolean bigEndian, boolean padding)`
`static String`	`toStringBits(int bits)`
`static String`	`toStringBits(int bits, int firstBitPos, int lastBitPosExcl, boolean bigEndian, boolean padding)`
`static String`	`toStringBits(long bits)`
`static String`	`toStringBits(long bits, int firstBitPos, int lastBitPosExcl, boolean bigEndian, boolean padding)`
`static String`	`toStringBits(short bits)`
`static String`	`toStringBits(short bits, int firstBitPos, int lastBitPosExcl, boolean bigEndian, boolean padding)`
`static double`	`twoPow(int power)` net.jodk.FastMath class has a typically faster version of this method, using look-up tables.

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

- Constructor Detail
  - NumbersUtils
```
public NumbersUtils()
```
- Method Detail
  - equal
```
public static boolean equal(float a,
            float b)
```
    Returns:
    True if the specified values are equal or both NaN, false otherwise.
  - equal
```
public static boolean equal(double a,
            double b)
```
    Returns:
    True if the specified values are equal or both NaN, false otherwise.
  - isInRange
```
public static boolean isInRange(int min,
                int max,
                int a)
```
    Returns:
    True if the specified value is in the specified range (inclusive), false otherwise.
  - isInRange
```
public static boolean isInRange(long min,
                long max,
                long a)
```
    Returns:
    True if the specified value is in the specified range (inclusive), false otherwise.
  - isInRange
```
public static boolean isInRange(float min,
                float max,
                float a)
```
    Returns false if any value is NaN.
    
    Returns:
    True if the specified value is in the specified range (inclusive), false otherwise.
  - isInRange
```
public static boolean isInRange(double min,
                double max,
                double a)
```
    Returns false if any value is NaN.
    
    Returns:
    True if the specified value is in the specified range (inclusive), false otherwise.
  - checkIsInRange
```
public static boolean checkIsInRange(int min,
                     int max,
                     int a)
```
    Throws:
    
    IllegalArgumentException - if the specified value is not in the specified range (inclusive).
    
    Returns:
    True if does not throw.
  - checkIsInRange
```
public static boolean checkIsInRange(long min,
                     long max,
                     long a)
```
    Throws:
    
    IllegalArgumentException - if the specified value is not in the specified range (inclusive).
    
    Returns:
    True if does not throw.
  - checkIsInRange
```
public static boolean checkIsInRange(float min,
                     float max,
                     float a)
```
    Throws:
    
    IllegalArgumentException - if the specified value is not in the specified range (inclusive) or any parameter is NaN.
    
    Returns:
    True if does not throw.
  - checkIsInRange
```
public static boolean checkIsInRange(double min,
                     double max,
                     double a)
```
    Throws:
    
    IllegalArgumentException - if the specified value is not in the specified range (inclusive) or any parameter is NaN.
    
    Returns:
    True if does not throw.
  - isInRangeSigned
```
public static boolean isInRangeSigned(int a,
                      int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is not in [1,32].
    Parameters:
    bitSize - A number of bits, in [1,32].
    
    Returns:
    True if the specified value fits as a signed integer over the specified number of bits, false otherwise.
  - isInRangeSigned
```
public static boolean isInRangeSigned(long a,
                      int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is not in [1,64].
    Parameters:
    bitSize - A number of bits, in [1,64].
    
    Returns:
    True if the specified value fits as a signed integer over the specified number of bits, false otherwise.
  - isInRangeUnsigned
```
public static boolean isInRangeUnsigned(int a,
                        int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is not in [1,31].
    Parameters:
    bitSize - A number of bits, in [1,31].
    
    Returns:
    True if the specified value fits as an unsigned integer over the specified number of bits, false otherwise.
  - isInRangeUnsigned
```
public static boolean isInRangeUnsigned(long a,
                        int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is not in [1,63].
    Parameters:
    bitSize - A number of bits, in [1,63].
    
    Returns:
    True if the specified value fits as an unsigned integer over the specified number of bits, false otherwise.
  - checkIsInRangeSigned
```
public static boolean checkIsInRangeSigned(int a,
                           int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified value does not fit as a signed integer over the specified number of bits.
    Parameters:
    bitSize - A number of bits, in [1,32].
    
    Returns:
    True if does not throw.
  - checkIsInRangeSigned
```
public static boolean checkIsInRangeSigned(long a,
                           int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified value does not fit as a signed integer over the specified number of bits.
    Parameters:
    bitSize - A number of bits, in [1,64].
    
    Returns:
    True if does not throw.
  - checkIsInRangeUnsigned
```
public static boolean checkIsInRangeUnsigned(int a,
                             int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified value does not fit as an unsigned integer over the specified number of bits.
    Parameters:
    bitSize - A number of bits, in [1,31].
    
    Returns:
    True if does not throw.
  - checkIsInRangeUnsigned
```
public static boolean checkIsInRangeUnsigned(long a,
                             int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified value does not fit as an unsigned integer over the specified number of bits.
    Parameters:
    bitSize - A number of bits, in [1,63].
    
    Returns:
    True if does not throw.
  - intMaskMSBits0
```
public static int intMaskMSBits0(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,32].
    
    Returns:
    Mask with the specified number of left bits set with 0, and other bits set with 1.
  - intMaskMSBits1
```
public static int intMaskMSBits1(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,32].
    
    Returns:
    Mask with the specified number of left bits set with 1, and other bits set with 0.
  - intMaskLSBits0
```
public static int intMaskLSBits0(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,32].
    
    Returns:
    Mask with the specified number of right bits set with 0, and other bits set with 1.
  - intMaskLSBits1
```
public static int intMaskLSBits1(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,32].
    
    Returns:
    Mask with the specified number of right bits set with 1, and other bits set with 0.
  - longMaskMSBits0
```
public static long longMaskMSBits0(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,64].
    
    Returns:
    Mask with the specified number of left bits set with 0, and other bits set with 1.
  - longMaskMSBits1
```
public static long longMaskMSBits1(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,64].
    
    Returns:
    Mask with the specified number of left bits set with 1, and other bits set with 0.
  - longMaskLSBits0
```
public static long longMaskLSBits0(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,64].
    
    Returns:
    Mask with the specified number of right bits set with 0, and other bits set with 1.
  - longMaskLSBits1
```
public static long longMaskLSBits1(int bitSize)
```
    Parameters:
    bitSize - A number of bits, in [0,64].
    
    Returns:
    Mask with the specified number of right bits set with 1, and other bits set with 0.
  - byteAsUnsigned
```
public static short byteAsUnsigned(byte value)
```
    Returns:
    Unsigned value corresponding to bits of the specified byte.
  - shortAsUnsigned
```
public static int shortAsUnsigned(short value)
```
    Returns:
    Unsigned value corresponding to bits of the specified short.
  - intAsUnsigned
```
public static long intAsUnsigned(int value)
```
    Returns:
    Unsigned value corresponding to bits of the specified int.
  - isValidBitSizeForSignedInt
```
public static boolean isValidBitSizeForSignedInt(int bitSize)
```
    Returns:
    True if a signed int value can be read over the specified number of bits, i.e. if it is in [1,32], false otherwise.
  - isValidBitSizeForSignedLong
```
public static boolean isValidBitSizeForSignedLong(int bitSize)
```
    Returns:
    True if a signed long value can be read over the specified number of bits, i.e. if it is in [1,64], false otherwise.
  - isValidBitSizeForUnsignedInt
```
public static boolean isValidBitSizeForUnsignedInt(int bitSize)
```
    Returns:
    True if an unsigned int value can be read over the specified number of bits, i.e. if it is in [1,31], false otherwise.
  - isValidBitSizeForUnsignedLong
```
public static boolean isValidBitSizeForUnsignedLong(int bitSize)
```
    Returns:
    True if an unsigned long value can be read over the specified number of bits, i.e. if it is in [1,63], false otherwise.
  - checkBitSizeForSignedInt
```
public static boolean checkBitSizeForSignedInt(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if a signed int value can't be read over the specified number of bits, i.e. if it is not in [1,32].
    
    Returns:
    True if does not throw.
  - checkBitSizeForSignedLong
```
public static boolean checkBitSizeForSignedLong(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if a signed long value can't be read over the specified number of bits, i.e. if it is not in [1,64].
    
    Returns:
    True if does not throw.
  - checkBitSizeForUnsignedInt
```
public static boolean checkBitSizeForUnsignedInt(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if an unsigned int value can't be read over the specified number of bits, i.e. if it is not in [1,31].
    
    Returns:
    True if does not throw.
  - checkBitSizeForUnsignedLong
```
public static boolean checkBitSizeForUnsignedLong(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if an unsigned long value can't be read over the specified number of bits, i.e. if it is not in [1,63].
    
    Returns:
    True if does not throw.
  - minSignedIntForBitSize
```
public static int minSignedIntForBitSize(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is out of range.
    Parameters:
    bitSize - A number of bits in [1,32].
    
    Returns:
    The min signed int value that can be stored over the specified number of bits.
  - minSignedLongForBitSize
```
public static long minSignedLongForBitSize(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is out of range.
    Parameters:
    bitSize - A number of bits in [1,64].
    
    Returns:
    The min signed long value that can be stored over the specified number of bits.
  - maxSignedIntForBitSize
```
public static int maxSignedIntForBitSize(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is out of range.
    Parameters:
    bitSize - A number of bits in [1,32].
    
    Returns:
    The max signed int value that can be stored over the specified number of bits.
  - maxSignedLongForBitSize
```
public static long maxSignedLongForBitSize(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is out of range.
    Parameters:
    bitSize - A number of bits in [1,64].
    
    Returns:
    The max signed long value that can be stored over the specified number of bits.
  - maxUnsignedIntForBitSize
```
public static int maxUnsignedIntForBitSize(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is out of range.
    Parameters:
    bitSize - A number of bits in [1,31].
    
    Returns:
    The max unsigned int value that can be stored over the specified number of bits.
  - maxUnsignedLongForBitSize
```
public static long maxUnsignedLongForBitSize(int bitSize)
```
    Throws:
    
    IllegalArgumentException - if the specified number of bits is out of range.
    Parameters:
    bitSize - A number of bits in [1,63].
    
    Returns:
    The max unsigned long value that can be stored over the specified number of bits.
  - bitSizeForSignedValue
```
public static int bitSizeForSignedValue(int value)
```
    Returns:
    The number of bits required to store the specified value as a signed integer, i.e. a result in [1,32].
  - bitSizeForSignedValue
```
public static int bitSizeForSignedValue(long value)
```
    Returns:
    The number of bits required to store the specified value as a signed integer, i.e. a result in [1,64].
  - bitSizeForUnsignedValue
```
public static int bitSizeForUnsignedValue(int value)
```
    Throws:
    
    IllegalArgumentException - if the specified value is < 0.
    Parameters:
    value - An integer value in [0,Integer.MAX_VALUE].
    
    Returns:
    The number of bits required to store the specified value as an unsigned integer, i.e. a result in [1,31].
  - bitSizeForUnsignedValue
```
public static int bitSizeForUnsignedValue(long value)
```
    Throws:
    
    IllegalArgumentException - if the specified value is < 0.
    Parameters:
    value - An integer value in [0,Long.MAX_VALUE].
    
    Returns:
    The number of bits required to store the specified value as an unsigned integer, i.e. a result in [1,63].
  - signum
```
public static int signum(int a)
```
    Returns:
    1 if the specified value is > 0, 0 if it is 0, -1 otherwise.
  - signum
```
public static int signum(long a)
```
    Returns:
    1 if the specified value is > 0, 0 if it is 0, -1 otherwise.
  - isEven
```
public static boolean isEven(int a)
```
    Returns:
    True if the specified value is even, false otherwise.
  - isEven
```
public static boolean isEven(long a)
```
    Returns:
    True if the specified value is even, false otherwise.
  - isOdd
```
public static boolean isOdd(int a)
```
    Returns:
    True if the specified value is odd, false otherwise.
  - isOdd
```
public static boolean isOdd(long a)
```
    Returns:
    True if the specified value is odd, false otherwise.
  - haveSameEvenness
```
public static boolean haveSameEvenness(int a,
                       int b)
```
    Returns:
    True if the specified values are both even or both odd, false otherwise.
  - haveSameEvenness
```
public static boolean haveSameEvenness(long a,
                       long b)
```
    Returns:
    True if the specified values are both even or both odd, false otherwise.
  - haveSameSign
```
public static boolean haveSameSign(int a,
                   int b)
```
    Returns:
    True if the specified values are both >= 0 or both < 0, false otherwise.
  - haveSameSign
```
public static boolean haveSameSign(long a,
                   long b)
```
    Returns:
    True if the specified values are both >= 0 or both < 0, false otherwise.
  - isPowerOfTwo
```
public static boolean isPowerOfTwo(int a)
```
    Returns:
    True if the specified value is a power of two, i.e. a value of the form 2^k, with k >= 0.
  - isPowerOfTwo
```
public static boolean isPowerOfTwo(long a)
```
    Returns:
    True if the specified value is a power of two, i.e. a value of the form 2^k, with k >= 0.
  - isSignedPowerOfTwo
```
public static boolean isSignedPowerOfTwo(int a)
```
    Returns:
    True if the specified value is a signed power of two, i.e. a value of the form +-2^k, with k >= 0.
  - isSignedPowerOfTwo
```
public static boolean isSignedPowerOfTwo(long a)
```
    Returns:
    True if the specified value is a signed power of two, i.e. a value of the form +-2^k, with k >= 0.
  - floorPowerOfTwo
```
public static int floorPowerOfTwo(int a)
```
    Parameters:
    a - A value in [1,Integer.MAX_VALUE].
    
    Returns:
    The highest power of two <= a.
  - floorPowerOfTwo
```
public static long floorPowerOfTwo(long a)
```
    Parameters:
    a - A value in [1,Long.MAX_VALUE].
    
    Returns:
    The highest power of two <= a.
  - ceilingPowerOfTwo
```
public static int ceilingPowerOfTwo(int a)
```
    Parameters:
    a - A value in [0,2^30].
    
    Returns:
    The lowest power of two >= a.
  - ceilingPowerOfTwo
```
public static long ceilingPowerOfTwo(long a)
```
    Parameters:
    a - A value in [0,2^62].
    
    Returns:
    The lowest power of two >= a.
  - meanLow
```
public static int meanLow(int a,
          int b)
```
    Returns:
    Mean without overflow, rounded to the lowest value (i.e. mathematical floor((a+b)/2), using floating point division).
  - meanLow
```
public static long meanLow(long a,
           long b)
```
    Returns:
    Mean without overflow, rounded to the lowest value (i.e. mathematical floor((a+b)/2), using floating point division).
  - meanSml
```
public static int meanSml(int a,
          int b)
```
    Returns:
    Mean without overflow, rounded to the value of smallest magnitude (i.e. mathematical (a+b)/2, using integer division).
  - meanSml
```
public static long meanSml(long a,
           long b)
```
    Returns:
    Mean without overflow, rounded to the value of smallest magnitude (i.e. mathematical (a+b)/2, using integer division).
  - negHalfWidth
```
public static int negHalfWidth(int min,
               int max)
```
    Useful because a positive int value could not represent half the width of full int range width, which is mathematically Integer.MAX_VALUE+1.
    
    Throws:
    
    IllegalArgumentException - if min > max.
    
    Returns:
    Minus half the range width (inclusive, and rounded to the value of smaller magnitude) between the specified bounds.
  - negHalfWidth
```
public static long negHalfWidth(long min,
                long max)
```
    Useful because a positive long value could not represent half the width of full long range width, which is mathematically Long.MAX_VALUE+1.
    
    Throws:
    
    IllegalArgumentException - if min > max.
    
    Returns:
    Minus half the range width (inclusive, and rounded to the value of smaller magnitude) between the specified bounds.
  - moduloSignedPowerOfTwo
```
public static int moduloSignedPowerOfTwo(int value,
                         int spot)
```
    This treatment being designed for optimization, the fact that spot is a signed power of two is only checked if assertions are enabled.
    
    Parameters:
    value - A value.
    spot - A signed power of two (i.e. a value of the form +-2^k, k >= 0).
    
    Returns:
    value % spot, i.e. a value in ]-|spot|,|spot|[.
  - moduloSignedPowerOfTwo
```
public static long moduloSignedPowerOfTwo(long value,
                          long spot)
```
    This treatment being designed for optimization, the fact that spot is a signed power of two is only checked if assertions are enabled.
    
    Parameters:
    value - A value.
    spot - A signed power of two (i.e. a value of the form +-2^k, k >= 0).
    
    Returns:
    value % spot, i.e. a value in ]-|spot|,|spot|[.
  - log2
```
public static int log2(int value)
```
    Throws:
    
    IllegalArgumentException - if the specified value is <= 0.
    Parameters:
    value - An integer value > 0.
    
    Returns:
    The integer part of the logarithm, in base 2, of the specified value, i.e. a result in [0,30]
  - log2
```
public static int log2(long value)
```
    Throws:
    
    IllegalArgumentException - if the specified value is <= 0.
    Parameters:
    value - An integer value > 0.
    
    Returns:
    The integer part of the logarithm, in base 2, of the specified value, i.e. a result in [0,62]
  - abs
```
public static int abs(int a)
```
    Possibly faster than java.lang.Math.abs(int).
    
    Returns:
    The absolute value, except if value is Integer.MIN_VALUE, for which it returns Integer.MIN_VALUE.
  - abs
```
public static long abs(long a)
```
    Possibly faster than java.lang.Math.abs(long).
    
    Returns:
    The absolute value, except if value is Long.MIN_VALUE, for which it returns Long.MIN_VALUE.
  - twoPow
```
public static double twoPow(int power)
```
    net.jodk.FastMath class has a typically faster version of this method, using look-up tables. Returns the exact result, provided it's in double range, i.e. if power is in [-1074,1023].
    
    Parameters:
    power - A power.
    
    Returns:
    2^power.
  - intHash
```
public static int intHash(long a)
```
    If the specified value is in int range, the returned value is identical.
    
    Returns:
    An int hash of the specified value.
  - asByte
```
public static byte asByte(int a)
```
    Not defining an asByte(long) method, since asByte((int)aLong) works.
    
    Throws:
    
    ArithmeticException - if the specified value is not in [Byte.MIN_VALUE,Byte.MAX_VALUE] range.
    Parameters:
    a - An int value.
    
    Returns:
    The specified value as byte.
  - asInt
```
public static int asInt(long a)
```
    Throws:
    
    ArithmeticException - if the specified value is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    a - A long value.
    
    Returns:
    The specified value as int.
  - toInt
```
public static int toInt(long a)
```
    Parameters:
    a - A long value.
    
    Returns:
    The closest int value in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
  - plusExact
```
public static int plusExact(int a,
            int b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a+b is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The mathematical result of a+b.
  - plusExact
```
public static long plusExact(long a,
             long b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a+b is not in [Long.MIN_VALUE,Long.MAX_VALUE] range.
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The mathematical result of a+b.
  - plusBounded
```
public static int plusBounded(int a,
              int b)
```
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The int value of [Integer.MIN_VALUE,Integer.MAX_VALUE] range which is the closest to mathematical result of a+b.
  - plusBounded
```
public static long plusBounded(long a,
               long b)
```
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The long value of [Long.MIN_VALUE,Long.MAX_VALUE] range which is the closest to mathematical result of a+b.
  - minusExact
```
public static int minusExact(int a,
             int b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a-b is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The mathematical result of a-b.
  - minusExact
```
public static long minusExact(long a,
              long b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a-b is not in [Long.MIN_VALUE,Long.MAX_VALUE] range.
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The mathematical result of a-b.
  - minusBounded
```
public static int minusBounded(int a,
               int b)
```
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The int value of [Integer.MIN_VALUE,Integer.MAX_VALUE] range which is the closest to mathematical result of a-b.
  - minusBounded
```
public static long minusBounded(long a,
                long b)
```
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The long value of [Long.MIN_VALUE,Long.MAX_VALUE] range which is the closest to mathematical result of a-b.
  - timesExact
```
public static int timesExact(int a,
             int b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a*b is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The mathematical result of a*b.
  - timesExact
```
public static long timesExact(long a,
              long b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a*b is not in [Long.MIN_VALUE,Long.MAX_VALUE] range.
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The mathematical result of a*b.
  - timesBounded
```
public static int timesBounded(int a,
               int b)
```
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The int value of [Integer.MIN_VALUE,Integer.MAX_VALUE] range which is the closest to mathematical result of a*b.
  - timesBounded
```
public static long timesBounded(long a,
                long b)
```
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The long value of [Long.MIN_VALUE,Long.MAX_VALUE] range which is the closest to mathematical result of a*b.
  - isNaNOrInfinite
```
public static boolean isNaNOrInfinite(float a)
```
    Returns:
    True if the specified value is NaN, positive of negative infinity, false otherwise.
  - isNaNOrInfinite
```
public static boolean isNaNOrInfinite(double a)
```
    Returns:
    True if the specified value is NaN, positive of negative infinity, false otherwise.
  - pow2
```
public static int pow2(int a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a.
  - pow2
```
public static long pow2(long a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a.
  - pow2
```
public static float pow2(float a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a.
  - pow2
```
public static double pow2(double a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a.
  - pow3
```
public static int pow3(int a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a*a.
  - pow3
```
public static long pow3(long a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a*a.
  - pow3
```
public static float pow3(float a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a*a.
  - pow3
```
public static double pow3(double a)
```
    Parameters:
    a - A value.
    
    Returns:
    a*a*a.
  - toRange
```
public static int toRange(int min,
          int max,
          int a)
```
    Parameters:
    min - A value.
    max - A value.
    a - A value.
    
    Returns:
    min if a <= min, else max if a >= max, else a.
  - toRange
```
public static long toRange(long min,
           long max,
           long a)
```
    Parameters:
    min - A value.
    max - A value.
    a - A value.
    
    Returns:
    min if a <= min, else max if a >= max, else a.
  - toRange
```
public static float toRange(float min,
            float max,
            float a)
```
    Parameters:
    min - A value.
    max - A value.
    a - A value.
    
    Returns:
    min if a <= min, else max if a >= max, else a.
  - toRange
```
public static double toRange(double min,
             double max,
             double a)
```
    Parameters:
    min - A value.
    max - A value.
    a - A value.
    
    Returns:
    min if a <= min, else max if a >= max, else a.
  - checkRadix
```
public static boolean checkRadix(int radix)
```
    Throws:
    
    IllegalArgumentException - if the specified radix is not in [2,36].
    Parameters:
    radix - Radix to be checked.
    
    Returns:
    True if does not throw.
  - computeNbrOfChars
```
public static int computeNbrOfChars(int value,
                    int radix)
```
    Parameters:
    radix - A radix in [2,36].
    
    Returns:
    Number of characters (minus sign included) to represent the specified value in the specified radix.
  - computeNbrOfChars
```
public static int computeNbrOfChars(long value,
                    int radix)
```
    Parameters:
    radix - A radix in [2,36].
    
    Returns:
    Number of characters (minus sign included) to represent the specified value in the specified radix.
  - computeNbrOfChars
```
public static int computeNbrOfChars(int value,
                    int radix,
                    int paddingUpTo)
```
    Parameters:
    radix - A radix in [2,36].
    paddingUpTo - Number of digits (sign excluded) up to which left-padding with zeros is done.
    
    Returns:
    Number of characters (minus sign included) to represent the specified value in the specified radix.
  - computeNbrOfChars
```
public static int computeNbrOfChars(long value,
                    int radix,
                    int paddingUpTo)
```
    Parameters:
    radix - A radix in [2,36].
    paddingUpTo - Number of digits (sign excluded) up to which left-padding with zeros is done.
    
    Returns:
    Number of characters (minus sign included) to represent the specified value in the specified radix.
  - computeNbrOfDigits
```
public static int computeNbrOfDigits(int value,
                     int radix)
```
    Parameters:
    radix - A radix in [2,36].
    
    Returns:
    Number of digits of the specified value in the specified radix.
  - computeNbrOfDigits
```
public static int computeNbrOfDigits(long value,
                     int radix)
```
    Parameters:
    radix - A radix in [2,36].
    
    Returns:
    Number of digits of the specified value in the specified radix.
  - computeNbrOfDigits
```
public static int computeNbrOfDigits(int value,
                     int radix,
                     int paddingUpTo)
```
    Parameters:
    radix - A radix in [2,36].
    paddingUpTo - Number of digits (sign excluded) up to which left-padding with zeros is done.
    
    Returns:
    Number of digits of the specified value in the specified radix, including the specified padding.
  - computeNbrOfDigits
```
public static int computeNbrOfDigits(long value,
                     int radix,
                     int paddingUpTo)
```
    Parameters:
    radix - A radix in [2,36].
    paddingUpTo - Number of digits (sign excluded) up to which left-padding with zeros is done.
    
    Returns:
    Number of digits of the specified value in the specified radix, including the specified padding.
  - toString
```
public static String toString(int value)
```
    This method just delegates to Integer.toString(int), but is defined here to complete the API.
    
    Returns:
    String representation of the specified value in base 10.
  - toString
```
public static String toString(long value)
```
    This method just delegates to Long.toString(long), but is defined here to complete the API.
    
    Returns:
    String representation of the specified value in base 10.
  - toString
```
public static String toString(int value,
              int radix)
```
    Throws:
    
    IllegalArgumentException - if the specified radix is out of range.
    Parameters:
    radix - A radix in [2,36].
    
    Returns:
    String representation of the specified value in the specified radix.
  - toString
```
public static String toString(long value,
              int radix)
```
    Throws:
    
    IllegalArgumentException - if the specified radix is out of range.
    Parameters:
    radix - A radix in [2,36].
    
    Returns:
    String representation of the specified value in the specified radix.
  - toString
```
public static String toString(int value,
              int radix,
              int paddingUpTo)
```
    Throws:
    
    IllegalArgumentException - if the specified radix is out of range.
    Parameters:
    radix - A radix in [2,36].
    paddingUpTo - Number of digits (sign excluded) up to which left-padding with zeros is done.
    
    Returns:
    String representation of the specified value in the specified radix.
  - toString
```
public static String toString(long value,
              int radix,
              int paddingUpTo)
```
    Throws:
    
    IllegalArgumentException - if the specified radix is out of range.
    Parameters:
    radix - A radix in [2,36].
    paddingUpTo - Number of digits (sign excluded) up to which left-padding with zeros is done.
    
    Returns:
    String representation of the specified value in the specified radix.
  - checkBitPositionsByte
```
public static boolean checkBitPositionsByte(int firstBitPos,
                            int lastBitPosExcl)
```
    Throws:
    
    IllegalArgumentException - if the specified bit range does not fit in a byte.
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    
    Returns:
    True if does not throw.
  - checkBitPositionsShort
```
public static boolean checkBitPositionsShort(int firstBitPos,
                             int lastBitPosExcl)
```
    Throws:
    
    IllegalArgumentException - if the specified bit range does not fit in a short.
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    
    Returns:
    True if does not throw.
  - checkBitPositionsInt
```
public static boolean checkBitPositionsInt(int firstBitPos,
                           int lastBitPosExcl)
```
    Throws:
    
    IllegalArgumentException - if the specified bit range does not fit in an int.
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    
    Returns:
    True if does not throw.
  - checkBitPositionsLong
```
public static boolean checkBitPositionsLong(int firstBitPos,
                            int lastBitPosExcl)
```
    Throws:
    
    IllegalArgumentException - if the specified bit range does not fit in a long.
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    
    Returns:
    True if does not throw.
  - toStringBits
```
public static String toStringBits(byte bits)
```
    Returns:
    String representation of specified bits, in big endian.
  - toStringBits
```
public static String toStringBits(short bits)
```
    Returns:
    String representation of specified bits, in big endian.
  - toStringBits
```
public static String toStringBits(int bits)
```
    Returns:
    String representation of specified bits, in big endian.
  - toStringBits
```
public static String toStringBits(long bits)
```
    Returns:
    String representation of specified bits, in big endian.
  - toStringBits
```
public static String toStringBits(byte bits,
                  int firstBitPos,
                  int lastBitPosExcl,
                  boolean bigEndian,
                  boolean padding)
```
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    bigEndian - True for bits to be added in big endian order (MSBit to LSBit) false for little endian order.
    padding - True if underscores must be added instead of out-of-range bits, false to just add characters corresponding to in-range bits.
    
    Returns:
    String representation of specified bits.
  - toStringBits
```
public static String toStringBits(short bits,
                  int firstBitPos,
                  int lastBitPosExcl,
                  boolean bigEndian,
                  boolean padding)
```
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    bigEndian - True for bits to be added in big endian order (MSBit to LSBit) false for little endian order.
    padding - True if underscores must be added instead of out-of-range bits, false to just add characters corresponding to in-range bits.
    
    Returns:
    String representation of specified bits.
  - toStringBits
```
public static String toStringBits(int bits,
                  int firstBitPos,
                  int lastBitPosExcl,
                  boolean bigEndian,
                  boolean padding)
```
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    bigEndian - True for bits to be added in big endian order (MSBit to LSBit) false for little endian order.
    padding - True if underscores must be added instead of out-of-range bits, false to just add characters corresponding to in-range bits.
    
    Returns:
    String representation of specified bits.
  - toStringBits
```
public static String toStringBits(long bits,
                  int firstBitPos,
                  int lastBitPosExcl,
                  boolean bigEndian,
                  boolean padding)
```
    Parameters:
    firstBitPos - First bit position (inclusive).
    lastBitPosExcl - Last bit position (exclusive).
    bigEndian - True for bits to be added in big endian order (MSBit to LSBit) false for little endian order.
    padding - True if underscores must be added instead of out-of-range bits, false to just add characters corresponding to in-range bits.
    
    Returns:
    String representation of specified bits.

Class NumbersUtils

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

NumbersUtils

Method Detail

equal

equal

isInRange

isInRange

isInRange

isInRange

checkIsInRange

checkIsInRange

checkIsInRange

checkIsInRange

isInRangeSigned

isInRangeSigned

isInRangeUnsigned

isInRangeUnsigned

checkIsInRangeSigned

checkIsInRangeSigned

checkIsInRangeUnsigned

checkIsInRangeUnsigned

intMaskMSBits0

intMaskMSBits1

intMaskLSBits0

intMaskLSBits1

longMaskMSBits0

longMaskMSBits1

longMaskLSBits0

longMaskLSBits1

byteAsUnsigned

shortAsUnsigned

intAsUnsigned

isValidBitSizeForSignedInt

isValidBitSizeForSignedLong

isValidBitSizeForUnsignedInt

isValidBitSizeForUnsignedLong

checkBitSizeForSignedInt

checkBitSizeForSignedLong

checkBitSizeForUnsignedInt

checkBitSizeForUnsignedLong

minSignedIntForBitSize

minSignedLongForBitSize

maxSignedIntForBitSize

maxSignedLongForBitSize

maxUnsignedIntForBitSize

maxUnsignedLongForBitSize

bitSizeForSignedValue

bitSizeForSignedValue

bitSizeForUnsignedValue

bitSizeForUnsignedValue

signum

signum

isEven

isEven

isOdd

isOdd

haveSameEvenness

haveSameEvenness

haveSameSign

haveSameSign

isPowerOfTwo

isPowerOfTwo

isSignedPowerOfTwo

isSignedPowerOfTwo

floorPowerOfTwo

floorPowerOfTwo

ceilingPowerOfTwo

ceilingPowerOfTwo

meanLow

meanLow

meanSml

meanSml

negHalfWidth

negHalfWidth

moduloSignedPowerOfTwo

moduloSignedPowerOfTwo