Argument (Avail 1.5.0 API)

java.lang.Object
- com.frostphyr.avail.Argument

```
public final class Argument
extends Object
```
Utility class containing methods to check for valid argument conditions.

Since:

1.0

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static byte`	`checkGreaterThan(byte value, byte number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkGreaterThan(byte value, byte number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkGreaterThan(char value, char number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkGreaterThan(char value, char number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThan(double value, double number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThan(double value, double number, double epsilon)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThan(double value, double number, double epsilon, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThan(double value, double number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThan(float value, float number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThan(float value, float number, float epsilon)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThan(float value, float number, float epsilon, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThan(float value, float number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkGreaterThan(int value, int number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkGreaterThan(int value, int number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkGreaterThan(long value, long number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkGreaterThan(long value, long number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkGreaterThan(short value, short number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkGreaterThan(short value, short number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkGreaterThanOrEqual(byte value, byte number)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkGreaterThanOrEqual(byte value, byte number, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkGreaterThanOrEqual(char value, char number)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkGreaterThanOrEqual(char value, char number, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThanOrEqual(double value, double number)` Returns the specified `value` if it is greater than or equal to the specified `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThanOrEqual(double value, double number, double epsilon)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThanOrEqual(double value, double number, double epsilon, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkGreaterThanOrEqual(double value, double number, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThanOrEqual(float value, float number)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThanOrEqual(float value, float number, float epsilon)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThanOrEqual(float value, float number, float epsilon, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkGreaterThanOrEqual(float value, float number, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkGreaterThanOrEqual(int value, int number)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkGreaterThanOrEqual(int value, int number, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkGreaterThanOrEqual(long value, long number)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkGreaterThanOrEqual(long value, long number, String name)` Returns `value` if it is greater than `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkGreaterThanOrEqual(short value, short number)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkGreaterThanOrEqual(short value, short number, String name)` Returns `value` if it is greater than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkInsideRange(byte value, byte min, byte max)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static byte`	`checkInsideRange(byte value, byte min, byte max, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static char`	`checkInsideRange(char value, char min, char max)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static char`	`checkInsideRange(char value, char min, char max, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static double`	`checkInsideRange(double value, double min, double max)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static double`	`checkInsideRange(double value, double min, double max, double epsilon)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static double`	`checkInsideRange(double value, double min, double max, double epsilon, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static double`	`checkInsideRange(double value, double min, double max, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static float`	`checkInsideRange(float value, float min, float max)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static float`	`checkInsideRange(float value, float min, float max, float epsilon)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static float`	`checkInsideRange(float value, float min, float max, float epsilon, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static float`	`checkInsideRange(float value, float min, float max, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static int`	`checkInsideRange(int value, int min, int max)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static int`	`checkInsideRange(int value, int min, int max, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static long`	`checkInsideRange(long value, long min, long max)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static long`	`checkInsideRange(long value, long min, long max, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static short`	`checkInsideRange(short value, short min, short max)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static short`	`checkInsideRange(short value, short min, short max, String name)` Returns `value` if it is inside the specified range, which means greater than or equal to `min` and less than or equal to `max`.
`static boolean[]`	`checkLength(boolean[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static boolean[]`	`checkLength(boolean[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static byte[]`	`checkLength(byte[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static byte[]`	`checkLength(byte[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static char[]`	`checkLength(char[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static char[]`	`checkLength(char[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static double[]`	`checkLength(double[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static double[]`	`checkLength(double[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static float[]`	`checkLength(float[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static float[]`	`checkLength(float[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static int[]`	`checkLength(int[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static int[]`	`checkLength(int[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static long[]`	`checkLength(long[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static long[]`	`checkLength(long[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static short[]`	`checkLength(short[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static short[]`	`checkLength(short[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static <T> T[]`	`checkLength(T[] array, int length)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static <T> T[]`	`checkLength(T[] array, int length, String name)` Returns `array` if it's not `null` and its length equals `length`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkLessThan(byte value, byte number)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkLessThan(byte value, byte number, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkLessThan(char value, char number)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkLessThan(char value, char number, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThan(double value, double number)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThan(double value, double number, double epsilon)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThan(double value, double number, double epsilon, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThan(double value, double number, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThan(float value, float number)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThan(float value, float number, float epsilon)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThan(float value, float number, float epsilon, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThan(float value, float number, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkLessThan(int value, int number)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkLessThan(int value, int number, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkLessThan(long value, long number)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkLessThan(long value, long number, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkLessThan(short value, short number)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkLessThan(short value, short number, String name)` Returns `value` if it is less than `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkLessThanOrEqual(byte value, byte number)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkLessThanOrEqual(byte value, byte number, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkLessThanOrEqual(char value, char number)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static char`	`checkLessThanOrEqual(char value, char number, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThanOrEqual(double value, double number)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThanOrEqual(double value, double number, double epsilon)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThanOrEqual(double value, double number, double epsilon, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static double`	`checkLessThanOrEqual(double value, double number, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThanOrEqual(float value, float number)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThanOrEqual(float value, float number, float epsilon)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThanOrEqual(float value, float number, float epsilon, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static float`	`checkLessThanOrEqual(float value, float number, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkLessThanOrEqual(int value, int number)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static int`	`checkLessThanOrEqual(int value, int number, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkLessThanOrEqual(long value, long number)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static long`	`checkLessThanOrEqual(long value, long number, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkLessThanOrEqual(short value, short number)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static short`	`checkLessThanOrEqual(short value, short number, String name)` Returns `value` if it is less than or equal to `number`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkNegative(byte value)` Returns `value` if it is negative, which means less than 0.
`static byte`	`checkNegative(byte value, String name)` Returns `value` if it is negative, which means less than 0.
`static double`	`checkNegative(double value)` Returns `value` if it is negative, which means less than 0.
`static double`	`checkNegative(double value, double epsilon)` Returns `value` if it is negative, which means less than 0.
`static double`	`checkNegative(double value, double epsilon, String name)` Returns `value` if it is negative, which means less than 0.
`static double`	`checkNegative(double value, String name)` Returns `value` if it is negative, which means less than 0.
`static float`	`checkNegative(float value)` Returns `value` if it is negative, which means less than 0.
`static float`	`checkNegative(float value, float epsilon)` Returns `value` if it is negative, which means less than 0.
`static float`	`checkNegative(float value, float epsilon, String name)` Returns `value` if it is negative, which means less than 0.
`static float`	`checkNegative(float value, String name)` Returns `value` if it is negative, which means less than 0.
`static int`	`checkNegative(int value)` Returns `value` if it is negative, which means less than 0.
`static int`	`checkNegative(int value, String name)` Returns `value` if it is negative, which means less than 0.
`static long`	`checkNegative(long value)` Returns `value` if it is negative, which means less than 0.
`static long`	`checkNegative(long value, String name)` Returns `value` if it is negative, which means less than 0.
`static short`	`checkNegative(short value)` Returns `value` if it is negative, which means less than 0.
`static short`	`checkNegative(short value, String name)` Returns `value` if it is negative, which means less than 0.
`static <T> T`	`checkNotNull(T value)` Returns `value` if it is not `null`, otherwise throws `IllegalArgumentException`.
`static <T> T`	`checkNotNull(T value, String name)` Returns `value` if it is not `null`, otherwise throws `IllegalArgumentException`.
`static byte`	`checkPercent(byte value)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static byte`	`checkPercent(byte value, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static double`	`checkPercent(double value)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static double`	`checkPercent(double value, double epsilon)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static double`	`checkPercent(double value, double epsilon, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static double`	`checkPercent(double value, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static float`	`checkPercent(float value)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static float`	`checkPercent(float value, float epsilon)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static float`	`checkPercent(float value, float epsilon, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static float`	`checkPercent(float value, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static int`	`checkPercent(int value)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static int`	`checkPercent(int value, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static long`	`checkPercent(long value)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static long`	`checkPercent(long value, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static short`	`checkPercent(short value)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static short`	`checkPercent(short value, String name)` Returns `value` if it is a valid percent, which means between 0 and 100 (inclusive).
`static byte`	`checkPositive(byte value)` Returns `value` if it is positive, which means greater than or equal to 0.
`static byte`	`checkPositive(byte value, String name)` Returns `value` if it is positive, which means greater than or equal to 0.
`static double`	`checkPositive(double value)` Returns `value` if it is positive, which means greater than or equal to 0.
`static double`	`checkPositive(double value, double epsilon)` Returns `value` if it is positive, which means greater than or equal to 0.
`static double`	`checkPositive(double value, double epsilon, String name)` Returns `value` if it is positive, which means greater than or equal to 0.
`static double`	`checkPositive(double value, String name)` Returns `value` if it is positive, which means greater than or equal to 0.
`static float`	`checkPositive(float value)` Returns `value` if it is positive, which means greater than or equal to 0.
`static float`	`checkPositive(float value, float epsilon)` Returns `value` if it is positive, which means greater than or equal to 0.
`static float`	`checkPositive(float value, float epsilon, String name)` Returns `value` if it is positive, which means greater than or equal to 0.
`static float`	`checkPositive(float value, String name)` Returns `value` if it is positive, which means greater than or equal to 0.
`static int`	`checkPositive(int value)` Returns `value` if it is positive, which means greater than or equal to 0.
`static int`	`checkPositive(int value, String name)` Returns `value` if it is positive, which means greater than or equal to 0.
`static long`	`checkPositive(long value)` Returns `value` if it is positive, which means greater than or equal to 0.
`static long`	`checkPositive(long value, String name)` Returns `value` if it is positive, which means greater than or equal to 0.
`static short`	`checkPositive(short value)` Returns `value` if it is positive, which means greater than or equal to 0.
`static short`	`checkPositive(short value, String name)` Returns `value` if it is positive, which means greater than or equal to 0.

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

- Method Detail
  - checkNotNull
```
public static <T> T checkNotNull(T value,
                                 String name)
```
    Returns value if it is not null, otherwise throws IllegalArgumentException.
    
    Type Parameters:
    
    T - the type of the value
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkNotNull
```
public static <T> T checkNotNull(T value)
```
    Returns value if it is not null, otherwise throws IllegalArgumentException.
    
    Type Parameters:
    
    T - the type of the value
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkGreaterThan
```
public static byte checkGreaterThan(byte value,
                                    byte number,
                                    String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThan
```
public static byte checkGreaterThan(byte value,
                                    byte number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    Returns:
    
    the same value
  - checkGreaterThan
```
public static short checkGreaterThan(short value,
                                     short number,
                                     String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThan
```
public static short checkGreaterThan(short value,
                                     short number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    Returns:
    
    the same value
  - checkGreaterThan
```
public static int checkGreaterThan(int value,
                                   int number,
                                   String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThan
```
public static int checkGreaterThan(int value,
                                   int number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    Returns:
    
    the same value
  - checkGreaterThan
```
public static long checkGreaterThan(long value,
                                    long number,
                                    String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThan
```
public static long checkGreaterThan(long value,
                                    long number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    Returns:
    
    the same value
  - checkGreaterThan
```
public static float checkGreaterThan(float value,
                                     float number,
                                     float epsilon,
                                     String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThan(float, float, float)
  - checkGreaterThan
```
public static float checkGreaterThan(float value,
                                     float number,
                                     float epsilon)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThan(float, float, float)
  - checkGreaterThan
```
public static float checkGreaterThan(float value,
                                     float number,
                                     String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThan(float, float)
  - checkGreaterThan
```
public static float checkGreaterThan(float value,
                                     float number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThan(float, float)
  - checkGreaterThan
```
public static double checkGreaterThan(double value,
                                      double number,
                                      double epsilon,
                                      String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThan(double, double, double)
  - checkGreaterThan
```
public static double checkGreaterThan(double value,
                                      double number,
                                      double epsilon)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThan(double, double, double)
  - checkGreaterThan
```
public static double checkGreaterThan(double value,
                                      double number,
                                      String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThan(double, double)
  - checkGreaterThan
```
public static double checkGreaterThan(double value,
                                      double number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThan(double, double)
  - checkGreaterThan
```
public static char checkGreaterThan(char value,
                                    char number,
                                    String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThan
```
public static char checkGreaterThan(char value,
                                    char number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than
    
    Returns:
    
    the same value
  - checkGreaterThanOrEqual
```
public static byte checkGreaterThanOrEqual(byte value,
                                           byte number,
                                           String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThanOrEqual
```
public static byte checkGreaterThanOrEqual(byte value,
                                           byte number)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    Returns:
    
    the same value
  - checkGreaterThanOrEqual
```
public static short checkGreaterThanOrEqual(short value,
                                            short number,
                                            String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThanOrEqual
```
public static short checkGreaterThanOrEqual(short value,
                                            short number)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    Returns:
    
    the same value
  - checkGreaterThanOrEqual
```
public static int checkGreaterThanOrEqual(int value,
                                          int number,
                                          String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThanOrEqual
```
public static int checkGreaterThanOrEqual(int value,
                                          int number)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    Returns:
    
    the same value
  - checkGreaterThanOrEqual
```
public static long checkGreaterThanOrEqual(long value,
                                           long number,
                                           String name)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThanOrEqual
```
public static long checkGreaterThanOrEqual(long value,
                                           long number)
```
    Returns value if it is greater than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    Returns:
    
    the same value
  - checkGreaterThanOrEqual
```
public static float checkGreaterThanOrEqual(float value,
                                            float number,
                                            float epsilon,
                                            String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float)
  - checkGreaterThanOrEqual
```
public static float checkGreaterThanOrEqual(float value,
                                            float number,
                                            float epsilon)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float)
  - checkGreaterThanOrEqual
```
public static float checkGreaterThanOrEqual(float value,
                                            float number,
                                            String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float)
  - checkGreaterThanOrEqual
```
public static float checkGreaterThanOrEqual(float value,
                                            float number)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float)
  - checkGreaterThanOrEqual
```
public static double checkGreaterThanOrEqual(double value,
                                             double number,
                                             double epsilon,
                                             String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double)
  - checkGreaterThanOrEqual
```
public static double checkGreaterThanOrEqual(double value,
                                             double number,
                                             double epsilon)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double)
  - checkGreaterThanOrEqual
```
public static double checkGreaterThanOrEqual(double value,
                                             double number,
                                             String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double)
  - checkGreaterThanOrEqual
```
public static double checkGreaterThanOrEqual(double value,
                                             double number)
```
    Returns the specified value if it is greater than or equal to the specified number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double)
  - checkGreaterThanOrEqual
```
public static char checkGreaterThanOrEqual(char value,
                                           char number,
                                           String name)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkGreaterThanOrEqual
```
public static char checkGreaterThanOrEqual(char value,
                                           char number)
```
    Returns value if it is greater than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be greater than or equal to
    
    Returns:
    
    the same value
  - checkLessThan
```
public static byte checkLessThan(byte value,
                                 byte number,
                                 String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThan
```
public static byte checkLessThan(byte value,
                                 byte number)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    Returns:
    
    the same value
  - checkLessThan
```
public static short checkLessThan(short value,
                                  short number,
                                  String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThan
```
public static short checkLessThan(short value,
                                  short number)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    Returns:
    
    the same value
  - checkLessThan
```
public static int checkLessThan(int value,
                                int number,
                                String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThan
```
public static int checkLessThan(int value,
                                int number)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    Returns:
    
    the same value
  - checkLessThan
```
public static long checkLessThan(long value,
                                 long number,
                                 String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThan
```
public static long checkLessThan(long value,
                                 long number)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    Returns:
    
    the same value
  - checkLessThan
```
public static float checkLessThan(float value,
                                  float number,
                                  float epsilon,
                                  String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(float, float, float)
  - checkLessThan
```
public static float checkLessThan(float value,
                                  float number,
                                  float epsilon)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(float, float, float)
  - checkLessThan
```
public static float checkLessThan(float value,
                                  float number,
                                  String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.lessThan(float, float)
  - checkLessThan
```
public static float checkLessThan(float value,
                                  float number)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.lessThan(float, float)
  - checkLessThan
```
public static double checkLessThan(double value,
                                   double number,
                                   double epsilon,
                                   String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(double, double, double)
  - checkLessThan
```
public static double checkLessThan(double value,
                                   double number,
                                   double epsilon)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(double, double, double)
  - checkLessThan
```
public static double checkLessThan(double value,
                                   double number,
                                   String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.lessThan(double, double)
  - checkLessThan
```
public static double checkLessThan(double value,
                                   double number)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.lessThan(double, double)
  - checkLessThan
```
public static char checkLessThan(char value,
                                 char number,
                                 String name)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThan
```
public static char checkLessThan(char value,
                                 char number)
```
    Returns value if it is less than number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than
    
    Returns:
    
    the same value
  - checkLessThanOrEqual
```
public static byte checkLessThanOrEqual(byte value,
                                        byte number,
                                        String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThanOrEqual
```
public static byte checkLessThanOrEqual(byte value,
                                        byte number)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    Returns:
    
    the same value
  - checkLessThanOrEqual
```
public static short checkLessThanOrEqual(short value,
                                         short number,
                                         String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThanOrEqual
```
public static short checkLessThanOrEqual(short value,
                                         short number)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    Returns:
    
    the same value
  - checkLessThanOrEqual
```
public static int checkLessThanOrEqual(int value,
                                       int number,
                                       String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThanOrEqual
```
public static int checkLessThanOrEqual(int value,
                                       int number)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    Returns:
    
    the same value
  - checkLessThanOrEqual
```
public static long checkLessThanOrEqual(long value,
                                        long number,
                                        String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThanOrEqual
```
public static long checkLessThanOrEqual(long value,
                                        long number)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    Returns:
    
    the same value
  - checkLessThanOrEqual
```
public static float checkLessThanOrEqual(float value,
                                         float number,
                                         float epsilon,
                                         String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(float, float, float)
  - checkLessThanOrEqual
```
public static float checkLessThanOrEqual(float value,
                                         float number,
                                         float epsilon)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(float, float, float)
  - checkLessThanOrEqual
```
public static float checkLessThanOrEqual(float value,
                                         float number,
                                         String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(float, float)
  - checkLessThanOrEqual
```
public static float checkLessThanOrEqual(float value,
                                         float number)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(float, float)
  - checkLessThanOrEqual
```
public static double checkLessThanOrEqual(double value,
                                          double number,
                                          double epsilon,
                                          String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(double, double, double)
  - checkLessThanOrEqual
```
public static double checkLessThanOrEqual(double value,
                                          double number,
                                          double epsilon)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. The epsilon is used to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    epsilon - the acceptable margin of error between value and number where they will be considered equal
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(double, double, double)
  - checkLessThanOrEqual
```
public static double checkLessThanOrEqual(double value,
                                          double number,
                                          String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(double, double)
  - checkLessThanOrEqual
```
public static double checkLessThanOrEqual(double value,
                                          double number)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value and number are equal.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.lessThanOrEqual(double, double)
  - checkLessThanOrEqual
```
public static char checkLessThanOrEqual(char value,
                                        char number,
                                        String name)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkLessThanOrEqual
```
public static char checkLessThanOrEqual(char value,
                                        char number)
```
    Returns value if it is less than or equal to number, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    number - the number that value must be less than or equal to
    
    Returns:
    
    the same value
  - checkPositive
```
public static byte checkPositive(byte value,
                                 String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPositive
```
public static byte checkPositive(byte value)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPositive
```
public static short checkPositive(short value,
                                  String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPositive
```
public static short checkPositive(short value)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPositive
```
public static int checkPositive(int value,
                                String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPositive
```
public static int checkPositive(int value)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPositive
```
public static long checkPositive(long value,
                                 String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPositive
```
public static long checkPositive(long value)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPositive
```
public static float checkPositive(float value,
                                  float epsilon,
                                  String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float)
  - checkPositive
```
public static float checkPositive(float value,
                                  float epsilon)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float)
  - checkPositive
```
public static float checkPositive(float value,
                                  String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float)
  - checkPositive
```
public static float checkPositive(float value)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float)
  - checkPositive
```
public static double checkPositive(double value,
                                   double epsilon,
                                   String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double)
  - checkPositive
```
public static double checkPositive(double value,
                                   double epsilon)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double)
  - checkPositive
```
public static double checkPositive(double value,
                                   String name)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double)
  - checkPositive
```
public static double checkPositive(double value)
```
    Returns value if it is positive, which means greater than or equal to 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double)
  - checkNegative
```
public static byte checkNegative(byte value,
                                 String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkNegative
```
public static byte checkNegative(byte value)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkNegative
```
public static short checkNegative(short value,
                                  String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkNegative
```
public static short checkNegative(short value)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkNegative
```
public static int checkNegative(int value,
                                String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkNegative
```
public static int checkNegative(int value)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkNegative
```
public static long checkNegative(long value,
                                 String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkNegative
```
public static long checkNegative(long value)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkNegative
```
public static float checkNegative(float value,
                                  float epsilon,
                                  String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(float, float, float)
  - checkNegative
```
public static float checkNegative(float value,
                                  float epsilon)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(float, float, float)
  - checkNegative
```
public static float checkNegative(float value,
                                  String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.lessThan(float, float)
  - checkNegative
```
public static float checkNegative(float value)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.lessThan(float, float)
  - checkNegative
```
public static double checkNegative(double value,
                                   double epsilon,
                                   String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(double, double, double)
  - checkNegative
```
public static double checkNegative(double value,
                                   double epsilon)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.lessThan(double, double, double)
  - checkNegative
```
public static double checkNegative(double value,
                                   String name)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.lessThan(double, double)
  - checkNegative
```
public static double checkNegative(double value)
```
    Returns value if it is negative, which means less than 0. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to 0.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.lessThan(double, double)
  - checkInsideRange
```
public static byte checkInsideRange(byte value,
                                    byte min,
                                    byte max,
                                    String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkInsideRange
```
public static byte checkInsideRange(byte value,
                                    byte min,
                                    byte max)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    Returns:
    
    the same value
  - checkInsideRange
```
public static short checkInsideRange(short value,
                                     short min,
                                     short max,
                                     String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkInsideRange
```
public static short checkInsideRange(short value,
                                     short min,
                                     short max)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    Returns:
    
    the same value
  - checkInsideRange
```
public static int checkInsideRange(int value,
                                   int min,
                                   int max,
                                   String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkInsideRange
```
public static int checkInsideRange(int value,
                                   int min,
                                   int max)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    Returns:
    
    the same value
  - checkInsideRange
```
public static long checkInsideRange(long value,
                                    long min,
                                    long max,
                                    String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkInsideRange
```
public static long checkInsideRange(long value,
                                    long min,
                                    long max)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    Returns:
    
    the same value
  - checkInsideRange
```
public static float checkInsideRange(float value,
                                     float min,
                                     float max,
                                     float epsilon,
                                     String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    epsilon - the acceptable margin of error when checking if value is equal to min or max
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float), FloatingPoint.lessThanOrEqual(float, float, float)
  - checkInsideRange
```
public static float checkInsideRange(float value,
                                     float min,
                                     float max,
                                     float epsilon)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    epsilon - the acceptable margin of error when checking if value is equal to min or max
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float), FloatingPoint.lessThanOrEqual(float, float, float)
  - checkInsideRange
```
public static float checkInsideRange(float value,
                                     float min,
                                     float max,
                                     String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float), FloatingPoint.lessThanOrEqual(float, float)
  - checkInsideRange
```
public static float checkInsideRange(float value,
                                     float min,
                                     float max)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float), FloatingPoint.lessThanOrEqual(float, float)
  - checkInsideRange
```
public static double checkInsideRange(double value,
                                      double min,
                                      double max,
                                      double epsilon,
                                      String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    epsilon - the acceptable margin of error when checking if value is equal to min or max
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double), FloatingPoint.lessThanOrEqual(double, double, double)
  - checkInsideRange
```
public static double checkInsideRange(double value,
                                      double min,
                                      double max,
                                      double epsilon)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    epsilon - the acceptable margin of error when checking if value is equal to min or max
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double), FloatingPoint.lessThanOrEqual(double, double, double)
  - checkInsideRange
```
public static double checkInsideRange(double value,
                                      double min,
                                      double max,
                                      String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double), FloatingPoint.lessThanOrEqual(double, double)
  - checkInsideRange
```
public static double checkInsideRange(double value,
                                      double min,
                                      double max)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to min or max.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double), FloatingPoint.lessThanOrEqual(double, double)
  - checkInsideRange
```
public static char checkInsideRange(char value,
                                    char min,
                                    char max,
                                    String name)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum (inclusive) that value can be
    
    max - the maximum (inclusive) that value can be
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkInsideRange
```
public static char checkInsideRange(char value,
                                    char min,
                                    char max)
```
    Returns value if it is inside the specified range, which means greater than or equal to min and less than or equal to max. If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    min - the minimum that value can be
    
    max - the maximum that value can be
    
    Returns:
    
    the same value
  - checkPercent
```
public static byte checkPercent(byte value,
                                String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPercent
```
public static byte checkPercent(byte value)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPercent
```
public static short checkPercent(short value,
                                 String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPercent
```
public static short checkPercent(short value)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPercent
```
public static int checkPercent(int value,
                               String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPercent
```
public static int checkPercent(int value)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPercent
```
public static long checkPercent(long value,
                                String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
  - checkPercent
```
public static long checkPercent(long value)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
  - checkPercent
```
public static float checkPercent(float value,
                                 float epsilon,
                                 String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0 or 100
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float), FloatingPoint.lessThanOrEqual(float, float, float)
  - checkPercent
```
public static float checkPercent(float value,
                                 float epsilon)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0 or 100
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float, float), FloatingPoint.lessThanOrEqual(float, float, float)
  - checkPercent
```
public static float checkPercent(float value,
                                 String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float), FloatingPoint.lessThanOrEqual(float, float)
  - checkPercent
```
public static float checkPercent(float value)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_FLOAT as the epsilon to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(float, float), FloatingPoint.lessThanOrEqual(float, float)
  - checkPercent
```
public static double checkPercent(double value,
                                  double epsilon,
                                  String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0 or 100
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double), FloatingPoint.lessThanOrEqual(double, double, double)
  - checkPercent
```
public static double checkPercent(double value,
                                  double epsilon)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. The epsilon is used to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    epsilon - the acceptable margin of error when checking if value is equal to 0 or 100
    
    Returns:
    
    the same value
    
    Since:
    
    1.5
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double, double), FloatingPoint.lessThanOrEqual(double, double, double)
  - checkPercent
```
public static double checkPercent(double value,
                                  String name)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same value
    
    Since:
    
    1.1
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double), FloatingPoint.lessThanOrEqual(double, double)
  - checkPercent
```
public static double checkPercent(double value)
```
    Returns value if it is a valid percent, which means between 0 and 100 (inclusive). If not, throws IllegalArgumentException. This will use FloatingPoint.EPSILON_DEFAULT_DOUBLE as the epsilon to determine if value is equal to 0 or 100.
    
    Parameters:
    
    value - the value to check
    
    Returns:
    
    the same value
    
    See Also:
    
    FloatingPoint.greaterThanOrEqual(double, double), FloatingPoint.lessThanOrEqual(double, double)
  - checkLength
```
public static byte[] checkLength(byte[] array,
                                 int length,
                                 String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static byte[] checkLength(byte[] array,
                                 int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static short[] checkLength(short[] array,
                                  int length,
                                  String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static short[] checkLength(short[] array,
                                  int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static int[] checkLength(int[] array,
                                int length,
                                String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static int[] checkLength(int[] array,
                                int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static long[] checkLength(long[] array,
                                 int length,
                                 String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static long[] checkLength(long[] array,
                                 int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static float[] checkLength(float[] array,
                                  int length,
                                  String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static float[] checkLength(float[] array,
                                  int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static double[] checkLength(double[] array,
                                   int length,
                                   String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static double[] checkLength(double[] array,
                                   int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static char[] checkLength(char[] array,
                                 int length,
                                 String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static char[] checkLength(char[] array,
                                 int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static boolean[] checkLength(boolean[] array,
                                    int length,
                                    String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static boolean[] checkLength(boolean[] array,
                                    int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static <T> T[] checkLength(T[] array,
                                  int length,
                                  String name)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Type Parameters:
    
    T - the type of array
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    name - the name of the argument to be included in the detail message of the IllegalArgumentException if it is thrown, or null for no detail message
    
    Returns:
    
    the same array
    
    Since:
    
    1.1
  - checkLength
```
public static <T> T[] checkLength(T[] array,
                                  int length)
```
    Returns array if it's not null and its length equals length, otherwise throws IllegalArgumentException.
    
    Type Parameters:
    
    T - the type of array
    
    Parameters:
    
    array - the array to check
    
    length - the length that array's length must equal
    
    Returns:
    
    the same array
    
    Since:
    
    1.1

Class Argument

Method Summary

Methods inherited from class java.lang.Object

Method Detail

checkNotNull

checkNotNull

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThan

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkGreaterThanOrEqual

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThan

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkLessThanOrEqual

checkPositive

checkPositive