BI (Nerd4j Utils 2.0.0 API)

java.lang.Object
- org.nerd4j.utils.math.CU
- - org.nerd4j.utils.math.BI

```
public class BI
extends CU
```
This utility class provides some convenience methods to deal with BigIntegers.
The name of this class is an abbreviation of BigInteger. We have intentionally used a short name for readability because this class is intended to be used in calculations and algebraic statements, for example:
```
 long a = ...;
 long b = ...;
 BigInteger c = ...;
 if( BI.lt(a,BI.sum(b,c) )
   // Do something...
 
```
instead of
```
 long a = ...;
 long b = ...;
 BigInteger c = ...;
 if( BigInteger.valueOf(a).compareTo(BigInteger.valueOf(b).add(c)) < 0 )
   // Do something...
 
```
The aim of this utility class is to facilitate operations with BigIntegers.
Since:

2.0.0

Author:

Massimo Coluzzi

Field Summary

Fields
Modifier and Type	Field and Description
`static BinaryOperator<BigInteger>`	`AND` Performs the binary and of of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`DIV` Performs the division of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`MAX` Finds the maximum of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`MIN` Finds the minimum of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`MOD` Performs the module of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`MUL` Performs the multiplication of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`OR` Performs the binary or of of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`REM` Performs the reminder of the division of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`SUB` Performs the subtraction of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`SUM` Performs the sum of two `non-null` `BigInteger` values.
`static BinaryOperator<BigInteger>`	`XOR` Performs the binary xor of of two `non-null` `BigInteger` values.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static BigInteger`	`and(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns the binary operation `a & b`.
`static BigInteger`	`and(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns the binary operation `a & b`.
`static BigInteger`	`and(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns the binary operation `a & b`.
`static BigInteger`	`and(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the binary operation `a & b`.
`static BigInteger`	`apply(BinaryOperator<BigInteger> operator, BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns the result of the given operator.
`static BigInteger`	`div(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns `a / b`.
`static BigInteger`	`div(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `a / b`.
`static BigInteger`	`div(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `a / b`.
`static BigInteger`	`div(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the value `a / b`.
`static boolean`	`eq(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a == b`.
`static boolean`	`eq(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a == b`.
`static boolean`	`eq(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a == b`.
`static boolean`	`eq(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a == b`.
`static boolean`	`ge(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a >= b`.
`static boolean`	`ge(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a >= b`.
`static boolean`	`ge(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a >= b`.
`static boolean`	`ge(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a >= b`.
`static boolean`	`gt(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a > b`.
`static boolean`	`gt(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a > b`.
`static boolean`	`gt(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a > b`.
`static boolean`	`gt(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a > b`.
`static boolean`	`le(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a <= b`.
`static boolean`	`le(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a <= b`.
`static boolean`	`le(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a <= b`.
`static boolean`	`le(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a <= b`.
`static boolean`	`lt(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a < b`.
`static boolean`	`lt(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if `a < b`.
`static boolean`	`lt(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a < b`.
`static boolean`	`lt(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if `a < b`.
`static BigInteger`	`max(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns the maximum value between them.
`static BigInteger`	`max(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns the maximum value between them.
`static BigInteger`	`max(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns the maximum value between them.
`static BigInteger`	`max(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns the maximum value between them.
`static BigInteger`	`max(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the maximum of them.
`static BigInteger`	`min(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns the minimum value between them.
`static BigInteger`	`min(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns the minimum value between them.
`static BigInteger`	`min(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns the minimum value between them.
`static BigInteger`	`min(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns the minimum value between them.
`static BigInteger`	`min(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the minimum of them.
`static BigInteger`	`mod(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns `a mod b`.
`static BigInteger`	`mod(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `a mod b`.
`static BigInteger`	`mod(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `a mod b`.
`static BigInteger`	`mod(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the value `a mod b`.
`static BigInteger`	`mul(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns `a * b`.
`static BigInteger`	`mul(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `a * b`.
`static BigInteger`	`mul(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `a * b`.
`static BigInteger`	`mul(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the value `a * b`.
`static boolean`	`ne(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if {@code a !
`static boolean`	`ne(BigInteger a, long b, boolean nullLast)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `true` if {@code a !
`static boolean`	`ne(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if {@code a !
`static boolean`	`ne(long a, BigInteger b, boolean nullLast)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `true` if {@code a !
`static BigInteger`	`of(long value)` Wrapper for the method `BigInteger.valueOf(long)`.
`static BigInteger`	`of(String value)` Transforms the string representation of a number into a `BigInteger`.
`static BigInteger`	`or(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns the binary operation `a \| b`.
`static BigInteger`	`or(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns the binary operation `a \| b`.
`static BigInteger`	`or(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns the binary operation `a \| b`.
`static BigInteger`	`or(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the binary operation `a \| b`.
`static BigInteger`	`rem(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns `a % b`.
`static BigInteger`	`rem(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `a % b`.
`static BigInteger`	`rem(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `a % b`.
`static BigInteger`	`rem(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the value `a % b`.
`static BigInteger`	`sub(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns `a - b`.
`static BigInteger`	`sub(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `a - b`.
`static BigInteger`	`sub(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `a - b`.
`static BigInteger`	`sub(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the value `a - b`.
`static BigInteger`	`sum(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns `a + b`.
`static BigInteger`	`sum(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns `a + b`.
`static BigInteger`	`sum(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns `a + b`.
`static BigInteger`	`sum(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the value `a + b`.
`static BigInteger`	`xor(BigInteger a, BigInteger b)` This is a `null-safe` method that, given two `BigInteger` values `a` and `b`, returns the binary operation `a ^ b`.
`static BigInteger`	`xor(BigInteger a, long b)` This is a `null-safe` method that, given a `BigInteger` value `a` and a `long` value `b`, returns the binary operation `a ^ b`.
`static BigInteger`	`xor(long a, BigInteger b)` This is a `null-safe` method that, given a `long` value `a` and a `BigInteger` value `b`, returns the binary operation `a ^ b`.
`static BigInteger`	`xor(long a, long b)` Given two `long` values `a` and `b`, returns a `BigInteger` that represents the binary operation `a ^ b`.

Methods inherited from class org.nerd4j.utils.math.CU
nullFirstNaturalOrderComparator, nullLastNaturalOrderComparator, nullSafeNaturalOrderComparator

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

- Field Detail
  - SUM
```
public static BinaryOperator<BigInteger> SUM
```
    Performs the sum of two non-null BigInteger values.
  - SUB
```
public static BinaryOperator<BigInteger> SUB
```
    Performs the subtraction of two non-null BigInteger values.
  - MUL
```
public static BinaryOperator<BigInteger> MUL
```
    Performs the multiplication of two non-null BigInteger values.
  - DIV
```
public static BinaryOperator<BigInteger> DIV
```
    Performs the division of two non-null BigInteger values.
  - REM
```
public static BinaryOperator<BigInteger> REM
```
    Performs the reminder of the division of two non-null BigInteger values.
  - MOD
```
public static BinaryOperator<BigInteger> MOD
```
    Performs the module of two non-null BigInteger values. This operation differs form REM because a reminder can be negative while the module is always >= 0.
  - AND
```
public static BinaryOperator<BigInteger> AND
```
    Performs the binary and of of two non-null BigInteger values.
  - OR
```
public static BinaryOperator<BigInteger> OR
```
    Performs the binary or of of two non-null BigInteger values.
  - XOR
```
public static BinaryOperator<BigInteger> XOR
```
    Performs the binary xor of of two non-null BigInteger values.
  - MIN
```
public static BinaryOperator<BigInteger> MIN
```
    Finds the minimum of two non-null BigInteger values.
  - MAX
```
public static BinaryOperator<BigInteger> MAX
```
    Finds the maximum of two non-null BigInteger values.
- Method Detail
  - of
```
public static BigInteger of(long value)
```
    Wrapper for the method BigInteger.valueOf(long).
    
    Parameters:
    
    value - value of the BigInteger to return.
    
    Returns:
    
    a BigInteger with the specified value.
  - of
```
public static BigInteger of(String value)
```
    Transforms the string representation of a number into a BigInteger.
    If the argument is null or empty this method returns null.
    If the argument is not empty and does not represent a number this method throws an exception.
    
    Parameters:
    
    value - decimal String representation of BigInteger.
    
    Returns:
    
    a BigInteger with the specified value.
    
    Throws:
    
    NumberFormatException - if value is not a valid representation of a BigInteger.
  - sum
```
public static BigInteger sum(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns a + b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - value to add.
    
    b - value to add.
    
    Returns:
    
    a BigInteger representing a + b.
  - sum
```
public static BigInteger sum(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns a + b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to add.
    
    b - value to add.
    
    Returns:
    
    a BigInteger representing a + b.
  - sum
```
public static BigInteger sum(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns a + b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to add.
    
    b - value to add.
    
    Returns:
    
    a BigInteger representing a + b.
  - sum
```
public static BigInteger sum(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the value a + b.
    
    Parameters:
    
    a - value to add.
    
    b - value to add.
    
    Returns:
    
    a BigInteger representing a + b.
  - sub
```
public static BigInteger sub(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns a - b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - value to subtract from.
    
    b - value to be subtracted.
    
    Returns:
    
    a BigInteger representing a - b.
  - sub
```
public static BigInteger sub(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns a - b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to subtract from.
    
    b - value to be subtracted.
    
    Returns:
    
    a BigInteger representing a - b.
  - sub
```
public static BigInteger sub(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns a - b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to subtract from.
    
    b - value to be subtracted.
    
    Returns:
    
    a BigInteger representing a - b.
  - sub
```
public static BigInteger sub(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the value a - b.
    
    Parameters:
    
    a - value to subtract from.
    
    b - value to be subtracted.
    
    Returns:
    
    a BigInteger representing a - b.
  - mul
```
public static BigInteger mul(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns a * b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - value to multiply.
    
    b - value to multiply.
    
    Returns:
    
    a BigInteger representing a * b.
  - mul
```
public static BigInteger mul(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns a * b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to multiply.
    
    b - value to multiply.
    
    Returns:
    
    a BigInteger representing a * b.
  - mul
```
public static BigInteger mul(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns a * b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to multiply.
    
    b - value to multiply.
    
    Returns:
    
    a BigInteger representing a * b.
  - mul
```
public static BigInteger mul(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the value a * b.
    
    Parameters:
    
    a - value to multiply.
    
    b - value to multiply.
    
    Returns:
    
    a BigInteger representing a * b.
  - div
```
public static BigInteger div(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns a / b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a / b.
  - div
```
public static BigInteger div(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns a / b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a / b.
  - div
```
public static BigInteger div(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns a / b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a / b.
  - div
```
public static BigInteger div(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the value a / b.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a / b.
  - rem
```
public static BigInteger rem(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns a % b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a % b.
  - rem
```
public static BigInteger rem(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns a % b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a % b.
  - rem
```
public static BigInteger rem(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns a % b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a % b.
  - rem
```
public static BigInteger rem(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the value a % b.
    
    Parameters:
    
    a - value to be divided.
    
    b - the divider value.
    
    Returns:
    
    a BigInteger representing a % b.
  - mod
```
public static BigInteger mod(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns a mod b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    This operation differs form rem(BigInteger,BigInteger) because a reminder can be negative while the module is always >= 0.
    
    Parameters:
    
    a - value to be divided.
    
    b - value of the module.
    
    Returns:
    
    a BigInteger representing a mod b.
  - mod
```
public static BigInteger mod(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns a mod b.
    If the BigInteger values is null, the other will be returned.
    This operation differs form rem(BigInteger,long) because a reminder can be negative while the module is always >= 0.
    
    Parameters:
    
    a - value to be divided.
    
    b - value of the module.
    
    Returns:
    
    a BigInteger representing a mod b.
  - mod
```
public static BigInteger mod(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns a mod b.
    If the BigInteger values is null, the other will be returned.
    This operation differs form rem(long,BigInteger) because a reminder can be negative while the module is always >= 0.
    
    Parameters:
    
    a - value to be divided.
    
    b - value of the module.
    
    Returns:
    
    a BigInteger representing a mod b.
  - mod
```
public static BigInteger mod(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the value a mod b.
    This operation differs form rem(long,long) because a reminder can be negative while the module is always >= 0.
    
    Parameters:
    
    a - value to be divided.
    
    b - value of the module.
    
    Returns:
    
    a BigInteger representing a mod b.
  - and
```
public static BigInteger and(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns the binary operation a & b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a & b.
  - and
```
public static BigInteger and(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns the binary operation a & b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a & b.
  - and
```
public static BigInteger and(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns the binary operation a & b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a & b.
  - and
```
public static BigInteger and(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the binary operation a & b.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a & b.
  - or
```
public static BigInteger or(BigInteger a,
                            BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns the binary operation a | b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a | b.
  - or
```
public static BigInteger or(BigInteger a,
                            long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns the binary operation a | b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a | b.
  - or
```
public static BigInteger or(long a,
                            BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns the binary operation a | b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a | b.
  - or
```
public static BigInteger or(long a,
                            long b)
```
    Given two long values a and b, returns a BigInteger that represents the binary operation a | b.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a | b.
  - xor
```
public static BigInteger xor(BigInteger a,
                             BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns the binary operation a ^ b.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a ^ b.
  - xor
```
public static BigInteger xor(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns the binary operation a ^ b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a ^ b.
  - xor
```
public static BigInteger xor(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns the binary operation a ^ b.
    If the BigInteger values is null, the other will be returned.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a ^ b.
  - xor
```
public static BigInteger xor(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the binary operation a ^ b.
    
    Parameters:
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    a BigInteger representing a ^ b.
  - min
```
public static BigInteger min(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns the minimum value between them. If the values are equal returns a.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    the minimum between a and b.
  - min
```
public static BigInteger min(BigInteger a,
                             long b,
                             boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns the minimum value between them. If the values are equal returns a.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    the minimum between a and b.
  - min
```
public static BigInteger min(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns the minimum value between them. If the values are equal returns a.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    the minimum between a and b.
  - min
```
public static BigInteger min(long a,
                             BigInteger b,
                             boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns the minimum value between them. If the values are equal returns a.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    the minimum between a and b.
  - min
```
public static BigInteger min(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the minimum of them.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    the minimum between a and b.
  - max
```
public static BigInteger max(BigInteger a,
                             long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns the maximum value between them. If the values are equal returns a.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    the maximum between a and b.
  - max
```
public static BigInteger max(BigInteger a,
                             long b,
                             boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns the maximum value between them. If the values are equal returns a.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    the maximum between a and b.
  - max
```
public static BigInteger max(long a,
                             BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns the maximum value between them. If the values are equal returns a.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    the maximum between a and b.
  - max
```
public static BigInteger max(long a,
                             BigInteger b,
                             boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns the maximum value between them. If the values are equal returns a.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    the maximum between a and b.
  - max
```
public static BigInteger max(long a,
                             long b)
```
    Given two long values a and b, returns a BigInteger that represents the maximum of them.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    the maximum between a and b.
  - lt
```
public static boolean lt(BigInteger a,
                         long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a < b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a < b.
  - lt
```
public static boolean lt(BigInteger a,
                         long b,
                         boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a < b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a < b.
  - lt
```
public static boolean lt(long a,
                         BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a < b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a < b.
  - lt
```
public static boolean lt(long a,
                         BigInteger b,
                         boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a < b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a < b.
  - le
```
public static boolean le(BigInteger a,
                         long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a <= b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a <= b.
  - le
```
public static boolean le(BigInteger a,
                         long b,
                         boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a <= b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a <= b.
  - le
```
public static boolean le(long a,
                         BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a <= b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a <= b.
  - le
```
public static boolean le(long a,
                         BigInteger b,
                         boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a <= b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a <= b.
  - eq
```
public static boolean eq(BigInteger a,
                         long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a == b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a == b.
  - eq
```
public static boolean eq(BigInteger a,
                         long b,
                         boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a == b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a == b.
  - eq
```
public static boolean eq(long a,
                         BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a == b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a == b.
  - eq
```
public static boolean eq(long a,
                         BigInteger b,
                         boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a == b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a == b.
  - ne
```
public static boolean ne(BigInteger a,
                         long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a != b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a != b.
  - ne
```
public static boolean ne(BigInteger a,
                         long b,
                         boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a != b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a != b.
  - ne
```
public static boolean ne(long a,
                         BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a != b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a != b.
  - ne
```
public static boolean ne(long a,
                         BigInteger b,
                         boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a != b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a != b.
  - ge
```
public static boolean ge(BigInteger a,
                         long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a >= b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a >= b.
  - ge
```
public static boolean ge(BigInteger a,
                         long b,
                         boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a >= b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a >= b.
  - ge
```
public static boolean ge(long a,
                         BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a >= b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a >= b.
  - ge
```
public static boolean ge(long a,
                         BigInteger b,
                         boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a >= b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a >= b.
  - gt
```
public static boolean gt(BigInteger a,
                         long b)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a > b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a > b.
  - gt
```
public static boolean gt(BigInteger a,
                         long b,
                         boolean nullLast)
```
    This is a null-safe method that, given a BigInteger value a and a long value b, returns true if a > b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a > b.
  - gt
```
public static boolean gt(long a,
                         BigInteger b)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a > b.
    This method considers null to be less than non-null.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    Returns:
    
    a > b.
  - gt
```
public static boolean gt(long a,
                         BigInteger b,
                         boolean nullLast)
```
    This is a null-safe method that, given a long value a and a BigInteger value b, returns true if a > b.
    This method considers null to be less than or greater than non-null based on the value of nullLast.
    
    Parameters:
    
    a - value to compare.
    
    b - value to compare.
    
    nullLast - tells if null is greater than non-null.
    
    Returns:
    
    a > b.
  - apply
```
public static BigInteger apply(BinaryOperator<BigInteger> operator,
                               BigInteger a,
                               BigInteger b)
```
    This is a null-safe method that, given two BigInteger values a and b, returns the result of the given operator.
    If one of the values is null, the other will be returned. If both values are null, then null will be returned.
    
    Parameters:
    
    operator - the operator to be applied.
    
    a - an operand.
    
    b - an operand.
    
    Returns:
    
    the result of the operation.

Class BI

Field Summary

Method Summary

Methods inherited from class org.nerd4j.utils.math.CU

Methods inherited from class java.lang.Object

Field Detail

SUM

SUB

MUL

DIV

REM

MOD

AND

OR

XOR

MIN

MAX

Method Detail

of

of

sum

sum

sum

sum

sub

sub

sub

sub

mul

mul

mul

mul

div

div

div

div

rem

rem

rem

rem

mod

mod

mod

mod

and

and

and

and

or

or

or

or

xor

xor

xor

xor

min

min

min

min

min

max

max

max

max

max

lt

lt

lt

lt

le

le

le

le

eq

eq

eq

eq

ne

ne