## org.op4j.functions Class FnDouble

```Object
org.op4j.functions.FnDouble
```

`public final class FnDoubleextends Object`

Since:
1.0
Author:
Soraya Sánchez

Method Summary
`static Function<Double,Double>` `abs()`
It returns the absolute value of the input
`static Function<Double,Double>` `add(byte add)`
It adds the given number to the target and returns the result
`static Function<Double,Double>` `add(double add)`
It adds the given number to the target and returns the result
`static Function<Double,Double>` `add(float add)`
It adds the given number to the target and returns the result
`static Function<Double,Double>` `add(int add)`
It adds the given number to the target and returns the result
`static Function<Double,Double>` `add(long add)`
It adds the given number to the target and returns the result
`static Function<Double,Double>` `add(Number add)`
It adds the given number to the target and returns the result
`static Function<Double,Double>` `add(short add)`
It adds the given number to the target and returns the result
`static Function<Iterable<Double>,Double>` `avg()`
It returns the average of all the numbers in the `Iterable` input object
`static Function<Iterable<Double>,Double>` `avg(MathContext mathContext)`
It returns the average of all the numbers in the `Iterable` input object.
`static Function<Iterable<Double>,Double>` `avg(RoundingMode roundingMode)`
It returns the average of all the numbers in the `Iterable` input object.
`static Function<Double[],Double>` `avgArray()`
It returns the average of all the numbers in the input array
`static Function<Double[],Double>` `avgArray(MathContext mathContext)`
It returns the average of all the numbers in the input array.
`static Function<Double[],Double>` `avgArray(RoundingMode roundingMode)`
It returns the average of all the numbers in the input array.
`static Function<Double,Boolean>` ```between(double min, double max)```
Determines whether the target object is between min and max in value, this is, whether target.compareTo(min) >= 0 && target.compareTo(max) <= 0.
`static Function<Double,Boolean>` ```between(Number min, Number max)```
Determines whether the target object is between min and max in value, this is, whether target.compareTo(min) >= 0 && target.compareTo(max) <= 0.
`static Function<Double,Double>` `divideBy(byte divisor)`
It divides the target element by the given divisor and returns its result
`static Function<Double,Double>` ```divideBy(byte divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext
`static Function<Double,Double>` ```divideBy(byte divisor, RoundingMode roundingMode)```
It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode
`static Function<Double,Double>` `divideBy(double divisor)`
It divides the target element by the given divisor and returns its result
`static Function<Double,Double>` ```divideBy(double divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext
`static Function<Double,Double>` ```divideBy(double divisor, RoundingMode roundingMode)```
It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode
`static Function<Double,Double>` `divideBy(float divisor)`
It divides the target element by the given divisor and returns its result
`static Function<Double,Double>` ```divideBy(float divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext
`static Function<Double,Double>` ```divideBy(float divisor, RoundingMode roundingMode)```
It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode
`static Function<Double,Double>` `divideBy(int divisor)`
It divides the target element by the given divisor and returns its result
`static Function<Double,Double>` ```divideBy(int divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext
`static Function<Double,Double>` ```divideBy(int divisor, RoundingMode roundingMode)```
It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode
`static Function<Double,Double>` `divideBy(long divisor)`
It divides the target element by the given divisor and returns its result
`static Function<Double,Double>` ```divideBy(long divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext
`static Function<Double,Double>` ```divideBy(long divisor, RoundingMode roundingMode)```
It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode
`static Function<Double,Double>` `divideBy(Number divisor)`
It divides the target element by the given divisor and returns its result
`static Function<Double,Double>` ```divideBy(Number divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext
`static Function<Double,Double>` ```divideBy(Number divisor, RoundingMode roundingMode)```
It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode
`static Function<Double,Double>` `divideBy(short divisor)`
It divides the target element by the given divisor and returns its result
`static Function<Double,Double>` ```divideBy(short divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext
`static Function<Double,Double>` ```divideBy(short divisor, RoundingMode roundingMode)```
It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode
`static Function<Double,Boolean>` `eq(double object)`
Determines whether the target object and the specified object are equal by calling the equals method on the target object.
`static Function<Double,Boolean>` `eq(Double object)`
Determines whether the target object and the specified object are equal by calling the equals method on the target object.
`static Function<Double,Boolean>` ```eqBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object and the specified object parameter are equal by calling the equals method.
`static Function<Double,Boolean>` `eqValue(double object)`
Determines whether the target object and the specified object are equal in value, this is, whether target.compareTo(object) == 0.
`static Function<Double,Boolean>` `eqValue(Number object)`
Determines whether the target object and the specified object are equal in value, this is, whether target.compareTo(object) == 0.
`static Function<Double,Boolean>` ```eqValueBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object and the specified object parameter are equal in value, this is, whether functionResult.compareTo(object) == 0.
`static Function<Double,Boolean>` `greaterOrEqTo(double object)`
Determines whether the target object is greater or equal to the specified object in value, this is, whether target.compareTo(object) >= 0.
`static Function<Double,Boolean>` `greaterOrEqTo(Number object)`
Determines whether the target object is greater or equal to the specified object in value, this is, whether target.compareTo(object) >= 0.
`static Function<Double,Boolean>` ```greaterOrEqToBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object is greater or equal to the specified object parameter in value, this is, whether functionResult.compareTo(object) >= 0.
`static Function<Double,Boolean>` `greaterThan(double object)`
Determines whether the target object is greater than the specified object in value, this is, whether target.compareTo(object) > 0.
`static Function<Double,Boolean>` `greaterThan(Number object)`
Determines whether the target object is greater than the specified object in value, this is, whether target.compareTo(object) > 0.
`static Function<Double,Boolean>` ```greaterThanBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object is greater than the specified object parameter in value, this is, whether functionResult.compareTo(object) > 0.
`static Function<Double,Boolean>` `isNotNull()`
Determines whether the target object is null or not.
`static Function<Double,Boolean>` `isNull()`
Determines whether the target object is null or not.
`static Function<Double,Boolean>` `lessOrEqTo(double object)`
Determines whether the target object is less or equal to the specified object in value, this is, whether target.compareTo(object) <= 0.
`static Function<Double,Boolean>` `lessOrEqTo(Number object)`
Determines whether the target object is less or equal to the specified object in value, this is, whether target.compareTo(object) <= 0.
`static Function<Double,Boolean>` ```lessOrEqToBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object is less or equal to the specified object parameter in value, this is, whether functionResult.compareTo(object) <= 0.
`static Function<Double,Boolean>` `lessThan(double object)`
Determines whether the target object is less than the specified object in value, this is, whether target.compareTo(object) < 0.
`static Function<Double,Boolean>` `lessThan(Number object)`
Determines whether the target object is less than the specified object in value, this is, whether target.compareTo(object) < 0.
`static Function<Double,Boolean>` ```lessThanBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object is less than the specified object parameter in value, this is, whether functionResult.compareTo(object) < 0.
`static Function<Iterable<Double>,Double>` `max()`
It returns the maximum number from an `Iterable` input object
`static Function<Double[],Double>` `maxArray()`
It returns the maximum number from the input array
`static Function<Iterable<Double>,Double>` `min()`
It returns the minimum number from an `Iterable` input object
`static Function<Double[],Double>` `minArray()`
It returns the minimum number from the input array
`static Function<Double,Double>` `multiplyBy(byte multiplicand)`
It multiplies target by multiplicand and returns its value
`static Function<Double,Double>` ```multiplyBy(byte multiplicand, MathContext mathContext)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` ```multiplyBy(byte multiplicand, RoundingMode roundingMode)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` `multiplyBy(double multiplicand)`
It multiplies target by multiplicand and returns its value
`static Function<Double,Double>` ```multiplyBy(double multiplicand, MathContext mathContext)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` ```multiplyBy(double multiplicand, RoundingMode roundingMode)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` `multiplyBy(float multiplicand)`
It multiplies target by multiplicand and returns its value
`static Function<Double,Double>` ```multiplyBy(float multiplicand, MathContext mathContext)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` ```multiplyBy(float multiplicand, RoundingMode roundingMode)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` `multiplyBy(int multiplicand)`
It multiplies target by multiplicand and returns its value
`static Function<Double,Double>` ```multiplyBy(int multiplicand, MathContext mathContext)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` ```multiplyBy(int multiplicand, RoundingMode roundingMode)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` `multiplyBy(long multiplicand)`
It multiplies target by multiplicand and returns its value
`static Function<Double,Double>` ```multiplyBy(long multiplicand, MathContext mathContext)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` ```multiplyBy(long multiplicand, RoundingMode roundingMode)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` `multiplyBy(Number multiplicand)`
It multiplies target by multiplicand and returns its value
`static Function<Double,Double>` ```multiplyBy(Number multiplicand, MathContext mathContext)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` ```multiplyBy(Number multiplicand, RoundingMode roundingMode)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` `multiplyBy(short multiplicand)`
It multiplies target by multiplicand and returns its value
`static Function<Double,Double>` ```multiplyBy(short multiplicand, MathContext mathContext)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Double>` ```multiplyBy(short multiplicand, RoundingMode roundingMode)```
It multiplies target by multiplicand and returns its value.
`static Function<Double,Boolean>` `notEq(double object)`
Determines whether the target object and the specified object are NOT equal by calling the equals method on the target object.
`static Function<Double,Boolean>` `notEq(Double object)`
Determines whether the target object and the specified object are NOT equal by calling the equals method on the target object.
`static Function<Double,Boolean>` ```notEqBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object and the specified object parameter are NOT equal by calling the equals method.
`static Function<Double,Boolean>` `notEqValue(double object)`
Determines whether the target object and the specified object are NOT equal in value, this is, whether target.compareTo(object) !
`static Function<Double,Boolean>` `notEqValue(Number object)`
Determines whether the target object and the specified object are NOT equal in value, this is, whether target.compareTo(object) !
`static Function<Double,Boolean>` ```notEqValueBy(IFunction<Double,?> by, Object object)```
Determines whether the result of executing the specified function on the target object and the specified object parameter are NOT equal in value, this is, whether functionResult.compareTo(object) !
`static Function<Double,Double>` `pow(int power)`
It performs the operation targetpower and returns its value
`static Function<Double,Double>` ```pow(int power, MathContext mathContext)```
It performs the operation targetpower and returns its value.
`static Function<Double,Double>` ```pow(int power, RoundingMode roundingMode)```
It performs the operation targetpower and returns its value.
`static Function<Double,Double>` `remainder(byte divisor)`
It divides the target element by the given divisor and returns the remainder (target % divisor)
`static Function<Double,Double>` ```remainder(byte divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns the remainder (target % divisor).
`static Function<Double,Double>` `remainder(double divisor)`
It divides the target element by the given divisor and returns the remainder (target % divisor)
`static Function<Double,Double>` ```remainder(double divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns the remainder (target % divisor).
`static Function<Double,Double>` `remainder(float divisor)`
It divides the target element by the given divisor and returns the remainder (target % divisor)
`static Function<Double,Double>` ```remainder(float divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns the remainder (target % divisor).
`static Function<Double,Double>` `remainder(int divisor)`
It divides the target element by the given divisor and returns the remainder (target % divisor)
`static Function<Double,Double>` ```remainder(int divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns the remainder (target % divisor).
`static Function<Double,Double>` `remainder(long divisor)`
It divides the target element by the given divisor and returns the remainder (target % divisor)
`static Function<Double,Double>` ```remainder(long divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns the remainder (target % divisor).
`static Function<Double,Double>` `remainder(Number divisor)`
It divides the target element by the given divisor and returns the remainder (target % divisor)
`static Function<Double,Double>` ```remainder(Number divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns the remainder (target % divisor).
`static Function<Double,Double>` `remainder(short divisor)`
It divides the target element by the given divisor and returns the remainder (target % divisor)
`static Function<Double,Double>` ```remainder(short divisor, MathContext mathContext)```
It divides the target element by the given divisor and returns the remainder (target % divisor).
`static Function<Double,Double>` `round(MathContext mathContext)`
It rounds the input number with the given `MathContext`
`static Function<Double,Double>` `round(RoundingMode roundingMode)`
It rounds the input number with the given `RoundingMode`
`static Function<Double,Double>` ```roundDouble(int scale, RoundingMode roundingMode)```

`static Function<Double,Double>` `subtract(byte subtract)`
It subtracts the given number from the target and returns the result
`static Function<Double,Double>` `subtract(double subtract)`
It subtracts the given number from the target and returns the result
`static Function<Double,Double>` `subtract(float subtract)`
It subtracts the given number from the target and returns the result
`static Function<Double,Double>` `subtract(int subtract)`
It subtracts the given number from the target and returns the result
`static Function<Double,Double>` `subtract(long subtract)`
It subtracts the given number from the target and returns the result
`static Function<Double,Double>` `subtract(Number subtract)`
It subtracts the given number from the target and returns the result
`static Function<Double,Double>` `subtract(short subtract)`
It subtracts the given number from the target and returns the result
`static Function<Iterable<Double>,Double>` `sum()`
It returns the sum of all the numbers in the `Iterable` input object
`static Function<Double[],Double>` `sumArray()`
It returns the sum of all the numbers in the input array
`static Function<Double,String>` `toCurrencyStr()`
It returns the `String` representation of the target as a currency in the default `Locale`
`static Function<Double,String>` `toCurrencyStr(boolean groupingUsed)`
It returns the `String` representation of the target as a currency in the default `Locale`
`static Function<Double,String>` `toCurrencyStr(Locale locale)`
It returns the `String` representation of the target as a currency in the given `Locale`
`static Function<Double,String>` ```toCurrencyStr(Locale locale, boolean groupingUsed)```
It returns the `String` representation of the target as a currency in the given `Locale`
`static Function<Double,String>` ```toCurrencyStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed)```
It returns the `String` representation of the target as a currency in the given `Locale`.
`static Function<Double,String>` ```toCurrencyStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target as a currency in the given `Locale` taking into account the given parameters.
`static Function<Double,String>` ```toCurrencyStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, char groupingSeparator, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target as a currency in the given `Locale` taking into account the given parameters.
`static Function<Double,String>` `toCurrencyStr(String locale)`
It returns the `String` representation of the target as a currency in the given locale
`static Function<Double,String>` ```toCurrencyStr(String locale, boolean groupingUsed)```
It returns the `String` representation of the target as a currency in the given locale
`static Function<Double,String>` ```toCurrencyStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed)```
It returns the `String` representation of the target as a currency in the given locale taking into account the given parameters.
`static Function<Double,String>` ```toCurrencyStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target as a currency in the given locale taking into account the given parameters.
`static Function<Double,String>` ```toCurrencyStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, char groupingSeparator, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target as a currency in the given locale taking into account the given parameters.
`static Function<Double,String>` `toPercentStr()`
A `String` representing a percentage is created from the target number.
`static Function<Double,String>` `toPercentStr(boolean groupingUsed)`
A `String` representing a percentage is created from the target number either using grouping or not depending on the given parameter.
`static Function<Double,String>` `toPercentStr(Locale locale)`
A `String` representing a percentage is created from the target number in the given `Locale`
`static Function<Double,String>` ```toPercentStr(Locale locale, boolean groupingUsed)```
A `String` representing a percentage is created from the target number in the given `Locale`.
`static Function<Double,String>` ```toPercentStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed)```
A `String` representing a percentage is created from the target number in the given `Locale`.
`static Function<Double,String>` ```toPercentStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
A `String` representing a percentage is created from the target number in the given locale and using the other given parameters as well.
`static Function<Double,String>` ```toPercentStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, char groupingSeparator, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
A `String` representing a percentage is created from the target number in the given `Locale` and using the other given parameters as well.
`static Function<Double,String>` `toPercentStr(String locale)`
A `String` representing a percentage is created from the target number in the given locale
`static Function<Double,String>` ```toPercentStr(String locale, boolean groupingUsed)```
A `String` representing a percentage is created from the target number in the given locale.
`static Function<Double,String>` ```toPercentStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed)```
A `String` representing a percentage is created from the target number in the given locale.
`static Function<Double,String>` ```toPercentStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
A `String` representing a percentage is created from the target number in the given locale and using the other given parameters as well.
`static Function<Double,String>` ```toPercentStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, char groupingSeparator, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
A `String` representing a percentage is created from the target number in the given locale and using the other given parameters as well.
`static Function<Double,String>` `toStr()`
It returns the `String` representation of the input number
`static Function<Double,String>` `toStr(boolean groupingUsed)`
It returns the `String` representation of the input number either using or not using grouping
`static Function<Double,String>` `toStr(Locale locale)`
It returns the `String` representation of the target number in the given `Locale`
`static Function<Double,String>` ```toStr(Locale locale, boolean groupingUsed)```
It returns the `String` representation of the target number in the given `Locale`.
`static Function<Double,String>` ```toStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed)```
It returns the `String` representation of the target number in the given `Locale`.
`static Function<Double,String>` ```toStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target number in the given `Locale`.
`static Function<Double,String>` ```toStr(Locale locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, char groupingSeparator, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target number in the given `Locale`.
`static Function<Double,String>` `toStr(String locale)`
It returns the `String` representation of the target number in the given locale
`static Function<Double,String>` ```toStr(String locale, boolean groupingUsed)```
It returns the `String` representation of the target number in the given locale.
`static Function<Double,String>` ```toStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed)```
It returns the `String` representation of the target number in the given locale.
`static Function<Double,String>` ```toStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, boolean groupingUsed, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target number in the given locale.
`static Function<Double,String>` ```toStr(String locale, int minIntegerDigits, int minFractionDigits, int maxFractionDigits, char groupingSeparator, char decimalSeparator, boolean decimalSeparatorAlwaysShown)```
It returns the `String` representation of the target number in the given locale.

Methods inherited from class Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Method Detail

### roundDouble

```public static final Function<Double,Double> roundDouble(int scale,
RoundingMode roundingMode)```

### toStr

`public static final Function<Double,String> toStr()`

It returns the `String` representation of the input number

Returns:
the `String` representation of the input

### toStr

`public static final Function<Double,String> toStr(boolean groupingUsed)`

It returns the `String` representation of the input number either using or not using grouping

Parameters:
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input

### toStr

`public static final Function<Double,String> toStr(Locale locale)`

It returns the `String` representation of the target number in the given `Locale`

Parameters:
`locale` - the `Locale` to be used
Returns:
the `String` representation of the input

### toStr

`public static final Function<Double,String> toStr(String locale)`

It returns the `String` representation of the target number in the given locale

Parameters:
`locale` - the locale to be used
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(Locale locale,
boolean groupingUsed)```

It returns the `String` representation of the target number in the given `Locale`. Grouping will be used depending on the value of the groupingUsed parameter

Parameters:
`locale` - the `Locale` to be used
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(String locale,
boolean groupingUsed)```

It returns the `String` representation of the target number in the given locale. Grouping will be used depending on the value of the groupingUsed parameter

Parameters:
`locale` - the locale to be used
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed)```

It returns the `String` representation of the target number in the given `Locale`. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toStr(Locale.ENGLISH, 3, 2, 2, true) would return 010.00 if target number is 10`
`toStr(Locale.ENGLISH, 2, 2, 4, true) would return 00.00 if target number is 0`

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed)```

It returns the `String` representation of the target number in the given locale. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toStr(Locale.ENGLISH.toString(), 3, 2, 2, true) would return 010.00 if target number is 10`
`toStr(Locale.ENGLISH.toString(), 2, 2, 4, true) would return 00.00 if target number is 0`

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
char groupingSeparator,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target number in the given `Locale`. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toStr(Locale.ENGLISH, 3, 2, 2, ',', '.', true) would return 1,000.00 if target number is 1000`
`toStr(Locale.ENGLISH, 2, 2, 4, ',', '.', true) would return 00.00 if target number is 0`

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingSeparator` - grouping separator to be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target number in the given `Locale`. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toStr(Locale.ENGLISH, 3, 2, 2, true, ',', true) would return 1,000,00 if target number is 1000`
`toStr(Locale.ENGLISH, 2, 2, 4, true, ',', true) would return 00,00 if target number is 0`

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
char groupingSeparator,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target number in the given locale. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toStr(Locale.ENGLISH.toString(), 3, 2, 2, ',', '.', true) would return 1,000.00 if target number is 1000`
`toStr(Locale.ENGLISH.toString(), 2, 2, 4, ',', '.', true) would return 00.00 if target number is 0`

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingSeparator` - grouping separator to be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input

### toStr

```public static final Function<Double,String> toStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target number in the given locale. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toStr(Locale.ENGLISH.toString(), 3, 2, 2, true, ',', true) would return 1,000,00 if target number is 1000`
`toStr(Locale.ENGLISH.toString(), 2, 2, 4, true, ',', true) would return 00,00 if target number is 0`

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input

### toCurrencyStr

`public static final Function<Double,String> toCurrencyStr()`

It returns the `String` representation of the target as a currency in the default `Locale`

Returns:
the `String` representation of the input as a currency

### toCurrencyStr

`public static final Function<Double,String> toCurrencyStr(boolean groupingUsed)`

It returns the `String` representation of the target as a currency in the default `Locale`

Parameters:
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

`public static final Function<Double,String> toCurrencyStr(Locale locale)`

It returns the `String` representation of the target as a currency in the given `Locale`

Parameters:
`locale` - the `Locale` to be used
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

`public static final Function<Double,String> toCurrencyStr(String locale)`

It returns the `String` representation of the target as a currency in the given locale

Parameters:
`locale` - the locale to be used
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(Locale locale,
boolean groupingUsed)```

It returns the `String` representation of the target as a currency in the given `Locale`

Parameters:
`locale` - the `Locale` to be used
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(String locale,
boolean groupingUsed)```

It returns the `String` representation of the target as a currency in the given locale

Parameters:
`locale` - the locale to be used
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed)```

It returns the `String` representation of the target as a currency in the given `Locale`. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toCurrencyStr(Locale.UK, 3, 2, 2, true) would return £1,000.00 if target number is 1000`
`toCurrencyStr(Locale.UK, 2, 2, 4, true) would return £00.00 if target number is 0`

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed)```

It returns the `String` representation of the target as a currency in the given locale taking into account the given parameters. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toCurrencyStr(Locale.UK.toString(), 3, 2, 2, true) would return £1,000.00 if target number is 1000`
`toCurrencyStr(Locale.UK.toString(), 2, 2, 4, true) would return £00.00 if target number is 0`

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
char groupingSeparator,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target as a currency in the given `Locale` taking into account the given parameters. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toCurrencyStr(Locale.UK, 3, 2, 2, ',', ',', true) would return £1,000,00 if target number is 1000`
`toCurrencyStr(Locale.UK, 2, 2, 4, ',', ',', true) would return £00,00 if target number is 0`

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingSeparator` - grouping separator to be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target as a currency in the given `Locale` taking into account the given parameters. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toCurrencyStr(Locale.UK.toString(), 3, 2, 2, ',', ',', true) would return £1,000,00 if target number is 1000`
`toCurrencyStr(Locale.UK.toString(), 2, 2, 4, ',', ',', true) would return £00,00 if target number is 0`

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
char groupingSeparator,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target as a currency in the given locale taking into account the given parameters. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toCurrencyStr(Locale.UK, 3, 2, 2, ',', ',', true) would return £1,000,00 if target number is 1000`
`toCurrencyStr(Locale.UK, 2, 2, 4, ',', ',', true) would return £00,00 if target number is 0`

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingSeparator` - grouping separator to be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input as a currency

### toCurrencyStr

```public static final Function<Double,String> toCurrencyStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

It returns the `String` representation of the target as a currency in the given locale taking into account the given parameters. If necessary, it will add leading or trailing zeros to the string based on the given parameters. So,

`toCurrencyStr(Locale.UK.toString(), 3, 2, 2, ',', ',', true) would return £1,000,00 if target number is 1000`
`toCurrencyStr(Locale.UK.toString(), 2, 2, 4, ',', ',', true) would return £00,00 if target number is 0`

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the `String` representation of the input as a currency

### toPercentStr

`public static final Function<Double,String> toPercentStr()`

A `String` representing a percentage is created from the target number.

Returns:
the string representation of the input number as a percentage

### toPercentStr

`public static final Function<Double,String> toPercentStr(boolean groupingUsed)`

A `String` representing a percentage is created from the target number either using grouping or not depending on the given parameter. So,

`toPercentStr(true) would return 100,000% if target number is 1000`
`toPercentStr(false) would return 100000% if target number is 1000`

Parameters:
`groupingUsed` - whether or not grouping will be used
Returns:
the string representation of the input number as a percentage

### toPercentStr

`public static final Function<Double,String> toPercentStr(Locale locale)`

A `String` representing a percentage is created from the target number in the given `Locale`

Parameters:
`locale` - the `Locale` to be used
Returns:
the string representation of the input number as a percentage

### toPercentStr

`public static final Function<Double,String> toPercentStr(String locale)`

A `String` representing a percentage is created from the target number in the given locale

Parameters:
`locale` - the locale to be used
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(Locale locale,
boolean groupingUsed)```

A `String` representing a percentage is created from the target number in the given `Locale`. Grouping will be used depending on the value of the groupingUsed parameter.

Parameters:
`locale` - the `Locale` to be used
`groupingUsed` - whether or not grouping will be used
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(String locale,
boolean groupingUsed)```

A `String` representing a percentage is created from the target number in the given locale. Grouping will be used depending on the value of the groupingUsed parameter.

Parameters:
`locale` - the locale to be used
`groupingUsed` - whether or not grouping will be used
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed)```

A `String` representing a percentage is created from the target number in the given `Locale`. If necessary, it will add leading or trailing zeros to the string based on the given parameters.

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed)```

A `String` representing a percentage is created from the target number in the given locale. If necessary, it will add leading or trailing zeros to the string based on the given parameters.

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
char groupingSeparator,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

A `String` representing a percentage is created from the target number in the given `Locale` and using the other given parameters as well. If necessary, it will add leading or trailing zeros to the string based on the given parameters.

Parameters:
`locale` - the `Locale` to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingSeparator` - grouping separator to be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(Locale locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

A `String` representing a percentage is created from the target number in the given locale and using the other given parameters as well. If necessary, it will add leading or trailing zeros to the string based on the given parameters.

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
char groupingSeparator,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

A `String` representing a percentage is created from the target number in the given locale and using the other given parameters as well. If necessary, it will add leading or trailing zeros to the string based on the given parameters.

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingSeparator` - grouping separator to be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the string representation of the input number as a percentage

### toPercentStr

```public static final Function<Double,String> toPercentStr(String locale,
int minIntegerDigits,
int minFractionDigits,
int maxFractionDigits,
boolean groupingUsed,
char decimalSeparator,
boolean decimalSeparatorAlwaysShown)```

A `String` representing a percentage is created from the target number in the given locale and using the other given parameters as well. If necessary, it will add leading or trailing zeros to the string based on the given parameters.

Parameters:
`locale` - the locale to be used
`minIntegerDigits` - minimum number of integer digits so, if not enough in the target number, 0's will be added to the left of the integer part
`minFractionDigits` - minimum number of fraction digits so, if not enough in the target number, 0's will be added to the right of the decimal part
`maxFractionDigits` - maximum number of fraction digits
`groupingUsed` - whether or not grouping will be used
`decimalSeparator` - decimal separator to be used
`decimalSeparatorAlwaysShown` - whether decimal separator should be shown even if the decimal part is zero or not
Returns:
the string representation of the input number as a percentage

### eq

`public static final Function<Double,Boolean> eq(Double object)`

Determines whether the target object and the specified object are equal by calling the equals method on the target object.

Parameters:
`object` - the `Double` to compare to the target
Returns:
true if both objects are equal, false if not.

### eq

`public static final Function<Double,Boolean> eq(double object)`

Determines whether the target object and the specified object are equal by calling the equals method on the target object.

Parameters:
`object` - the object to compare to the target
Returns:
true if both objects are equal, false if not.

### eqValue

`public static final Function<Double,Boolean> eqValue(Number object)`

Determines whether the target object and the specified object are equal in value, this is, whether target.compareTo(object) == 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if both objects are equal according to "compareTo", false if not.

### eqValue

`public static final Function<Double,Boolean> eqValue(double object)`

Determines whether the target object and the specified object are equal in value, this is, whether target.compareTo(object) == 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if both objects are equal according to "compareTo", false if not.

### notEq

`public static final Function<Double,Boolean> notEq(Double object)`

Determines whether the target object and the specified object are NOT equal by calling the equals method on the target object.

Parameters:
`object` - the `Double` to compare to the target
Returns:
false if both objects are equal, true if not.

### notEq

`public static final Function<Double,Boolean> notEq(double object)`

Determines whether the target object and the specified object are NOT equal by calling the equals method on the target object.

Parameters:
`object` - the object to compare to the target
Returns:
false if both objects are equal, true if not.

### notEqValue

`public static final Function<Double,Boolean> notEqValue(Number object)`

Determines whether the target object and the specified object are NOT equal in value, this is, whether target.compareTo(object) != 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
false if both objects are equal according to "compareTo", true if not.

### notEqValue

`public static final Function<Double,Boolean> notEqValue(double object)`

Determines whether the target object and the specified object are NOT equal in value, this is, whether target.compareTo(object) != 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
false if both objects are equal according to "compareTo", true if not.

### lessThan

`public static final Function<Double,Boolean> lessThan(Number object)`

Determines whether the target object is less than the specified object in value, this is, whether target.compareTo(object) < 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is less than the specified object, false if not

### lessThan

`public static final Function<Double,Boolean> lessThan(double object)`

Determines whether the target object is less than the specified object in value, this is, whether target.compareTo(object) < 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is less than the specified object, false if not

### lessOrEqTo

`public static final Function<Double,Boolean> lessOrEqTo(Number object)`

Determines whether the target object is less or equal to the specified object in value, this is, whether target.compareTo(object) <= 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is less or equal to the specified object, false if not

### lessOrEqTo

`public static final Function<Double,Boolean> lessOrEqTo(double object)`

Determines whether the target object is less or equal to the specified object in value, this is, whether target.compareTo(object) <= 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is less or equal to the specified object, false if not

### greaterThan

`public static final Function<Double,Boolean> greaterThan(Number object)`

Determines whether the target object is greater than the specified object in value, this is, whether target.compareTo(object) > 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is greater than the specified object, false if not

### greaterThan

`public static final Function<Double,Boolean> greaterThan(double object)`

Determines whether the target object is greater than the specified object in value, this is, whether target.compareTo(object) > 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is greater than the specified object, false if not

### greaterOrEqTo

`public static final Function<Double,Boolean> greaterOrEqTo(Number object)`

Determines whether the target object is greater or equal to the specified object in value, this is, whether target.compareTo(object) >= 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is greater or equal to the specified object, false if not

### greaterOrEqTo

`public static final Function<Double,Boolean> greaterOrEqTo(double object)`

Determines whether the target object is greater or equal to the specified object in value, this is, whether target.compareTo(object) >= 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if target is greater or equal to the specified object, false if not

### eqBy

```public static final Function<Double,Boolean> eqBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object and the specified object parameter are equal by calling the equals method.

Parameters:
`object` - the object to compare to the target
Returns:
true if both objects are equal, false if not.
Since:
1.1

### eqValueBy

```public static final Function<Double,Boolean> eqValueBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object and the specified object parameter are equal in value, this is, whether functionResult.compareTo(object) == 0. Both the function result and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if both objects are equal according to "compareTo", false if not.
Since:
1.1

### notEqBy

```public static final Function<Double,Boolean> notEqBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object and the specified object parameter are NOT equal by calling the equals method.

Parameters:
`object` - the object to compare to the target
Returns:
false if both objects are equal, true if not.
Since:
1.1

### notEqValueBy

```public static final Function<Double,Boolean> notEqValueBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object and the specified object parameter are NOT equal in value, this is, whether functionResult.compareTo(object) != 0. Both the function result and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
false if both objects are equal according to "compareTo", true if not.
Since:
1.1

### lessThanBy

```public static final Function<Double,Boolean> lessThanBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object is less than the specified object parameter in value, this is, whether functionResult.compareTo(object) < 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if function result is less than the specified object, false if not
Since:
1.1

### lessOrEqToBy

```public static final Function<Double,Boolean> lessOrEqToBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object is less or equal to the specified object parameter in value, this is, whether functionResult.compareTo(object) <= 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if function result is less or equal to the specified object, false if not
Since:
1.1

### greaterThanBy

```public static final Function<Double,Boolean> greaterThanBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object is greater than the specified object parameter in value, this is, whether functionResult.compareTo(object) > 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if function result is greater than the specified object, false if not
Since:
1.1

### greaterOrEqToBy

```public static final Function<Double,Boolean> greaterOrEqToBy(IFunction<Double,?> by,
Object object)```

Determines whether the result of executing the specified function on the target object is greater or equal to the specified object parameter in value, this is, whether functionResult.compareTo(object) >= 0. Both the target and the specified object have to implement `Comparable`.

Parameters:
`object` - the object to compare to the target
Returns:
true if function result is greater or equal to the specified object, false if not
Since:
1.1

### isNull

`public static final Function<Double,Boolean> isNull()`

Determines whether the target object is null or not.

Returns:
true if the target object is null, false if not.

### isNotNull

`public static final Function<Double,Boolean> isNotNull()`

Determines whether the target object is null or not.

Returns:
false if the target object is null, true if not.

### max

`public static final Function<Iterable<Double>,Double> max()`

It returns the maximum number from an `Iterable` input object

Returns:
the maximum number

### min

`public static final Function<Iterable<Double>,Double> min()`

It returns the minimum number from an `Iterable` input object

Returns:
the minimum number

### sum

`public static final Function<Iterable<Double>,Double> sum()`

It returns the sum of all the numbers in the `Iterable` input object

Returns:
a number equal to the sum of all the elements in the input `Iterable`

### avg

`public static final Function<Iterable<Double>,Double> avg()`

It returns the average of all the numbers in the `Iterable` input object

Returns:
a number representing the average of the input numbers

### avg

`public static final Function<Iterable<Double>,Double> avg(MathContext mathContext)`

It returns the average of all the numbers in the `Iterable` input object. The given `MathContext` will be used to round and set the output precision

Parameters:
`mathContext` - the `MathContext` to define `RoundingMode` and precision of the average
Returns:
a number representing the average

### avg

`public static final Function<Iterable<Double>,Double> avg(RoundingMode roundingMode)`

It returns the average of all the numbers in the `Iterable` input object. The given `RoundingMode` will be used to round the output

Parameters:
`roundingMode` - the `RoundingMode` to round the average
Returns:
a number representing the average

### maxArray

`public static final Function<Double[],Double> maxArray()`

It returns the maximum number from the input array

Returns:
the maximum number

### minArray

`public static final Function<Double[],Double> minArray()`

It returns the minimum number from the input array

Returns:
the minimum number

### sumArray

`public static final Function<Double[],Double> sumArray()`

It returns the sum of all the numbers in the input array

Returns:
a number equal to the sum of all the elements in the input array

### avgArray

`public static final Function<Double[],Double> avgArray()`

It returns the average of all the numbers in the input array

Returns:
a number representing the average of the input numbers

### avgArray

`public static final Function<Double[],Double> avgArray(MathContext mathContext)`

It returns the average of all the numbers in the input array. The given `MathContext` will be used to round and set the output precision

Parameters:
`mathContext` - the `MathContext` to define `RoundingMode` and precision of the average
Returns:
a number representing the average

### avgArray

`public static final Function<Double[],Double> avgArray(RoundingMode roundingMode)`

It returns the average of all the numbers in the input array. The given `RoundingMode` will be used to round the output

Parameters:
`roundingMode` - the `RoundingMode` to round the average
Returns:
a number representing the average

### round

`public static final Function<Double,Double> round(MathContext mathContext)`

It rounds the input number with the given `MathContext`

Parameters:
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the input rounded

### round

`public static final Function<Double,Double> round(RoundingMode roundingMode)`

It rounds the input number with the given `RoundingMode`

Parameters:
`roundingMode` - the `RoundingMode`
Returns:
the input rounded

### abs

`public static final Function<Double,Double> abs()`

It returns the absolute value of the input

Returns:
the absolute value of the input

`public static final Function<Double,Double> add(Number add)`

It adds the given number to the target and returns the result

Parameters:
`add` - value to be added to the target
Returns:

`public static final Function<Double,Double> add(byte add)`

It adds the given number to the target and returns the result

Parameters:
`add` - value to be added to the target
Returns:

`public static final Function<Double,Double> add(short add)`

It adds the given number to the target and returns the result

Parameters:
`add` - value to be added to the target
Returns:

`public static final Function<Double,Double> add(int add)`

It adds the given number to the target and returns the result

Parameters:
`add` - value to be added to the target
Returns:

`public static final Function<Double,Double> add(long add)`

It adds the given number to the target and returns the result

Parameters:
`add` - value to be added to the target
Returns:

`public static final Function<Double,Double> add(float add)`

It adds the given number to the target and returns the result

Parameters:
`add` - value to be added to the target
Returns:

`public static final Function<Double,Double> add(double add)`

It adds the given number to the target and returns the result

Parameters:
`add` - value to be added to the target
Returns:

### subtract

`public static final Function<Double,Double> subtract(Number subtract)`

It subtracts the given number from the target and returns the result

Parameters:
`subtract` - number to be subtracted from the target
Returns:
the result of the subtraction

### subtract

`public static final Function<Double,Double> subtract(byte subtract)`

It subtracts the given number from the target and returns the result

Parameters:
`subtract` - number to be subtracted from the target
Returns:
the result of the subtraction

### subtract

`public static final Function<Double,Double> subtract(short subtract)`

It subtracts the given number from the target and returns the result

Parameters:
`subtract` - number to be subtracted from the target
Returns:
the result of the subtraction

### subtract

`public static final Function<Double,Double> subtract(int subtract)`

It subtracts the given number from the target and returns the result

Parameters:
`subtract` - number to be subtracted from the target
Returns:
the result of the subtraction

### subtract

`public static final Function<Double,Double> subtract(long subtract)`

It subtracts the given number from the target and returns the result

Parameters:
`subtract` - number to be subtracted from the target
Returns:
the result of the subtraction

### subtract

`public static final Function<Double,Double> subtract(float subtract)`

It subtracts the given number from the target and returns the result

Parameters:
`subtract` - number to be subtracted from the target
Returns:
the result of the subtraction

### subtract

`public static final Function<Double,Double> subtract(double subtract)`

It subtracts the given number from the target and returns the result

Parameters:
`subtract` - number to be subtracted from the target
Returns:
the result of the subtraction

### divideBy

`public static final Function<Double,Double> divideBy(Number divisor)`

It divides the target element by the given divisor and returns its result

Parameters:
`divisor` - the divisor
Returns:
the result of target/divisor

### divideBy

`public static final Function<Double,Double> divideBy(byte divisor)`

It divides the target element by the given divisor and returns its result

Parameters:
`divisor` - the divisor
Returns:
the result of target/divisor

### divideBy

`public static final Function<Double,Double> divideBy(short divisor)`

It divides the target element by the given divisor and returns its result

Parameters:
`divisor` - the divisor
Returns:
the result of target/divisor

### divideBy

`public static final Function<Double,Double> divideBy(int divisor)`

It divides the target element by the given divisor and returns its result

Parameters:
`divisor` - the divisor
Returns:
the result of target/divisor

### divideBy

`public static final Function<Double,Double> divideBy(long divisor)`

It divides the target element by the given divisor and returns its result

Parameters:
`divisor` - the divisor
Returns:
the result of target/divisor

### divideBy

`public static final Function<Double,Double> divideBy(float divisor)`

It divides the target element by the given divisor and returns its result

Parameters:
`divisor` - the divisor
Returns:
the result of target/divisor

### divideBy

`public static final Function<Double,Double> divideBy(double divisor)`

It divides the target element by the given divisor and returns its result

Parameters:
`divisor` - the divisor
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(Number divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(byte divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(short divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(int divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(long divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(float divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(double divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns its result with the precision and rounding mode specified by mathContext

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(Number divisor,
RoundingMode roundingMode)```

It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode

Parameters:
`divisor` - the divisor
`roundingMode` - the `RoundingMode`
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(byte divisor,
RoundingMode roundingMode)```

It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode

Parameters:
`divisor` - the divisor
`roundingMode` - the `RoundingMode`
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(short divisor,
RoundingMode roundingMode)```

It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode

Parameters:
`divisor` - the divisor
`roundingMode` - the `RoundingMode`
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(int divisor,
RoundingMode roundingMode)```

It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode

Parameters:
`divisor` - the divisor
`roundingMode` - the `RoundingMode`
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(long divisor,
RoundingMode roundingMode)```

It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode

Parameters:
`divisor` - the divisor
`roundingMode` - the `RoundingMode`
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(float divisor,
RoundingMode roundingMode)```

It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode

Parameters:
`divisor` - the divisor
`roundingMode` - the `RoundingMode`
Returns:
the result of target/divisor

### divideBy

```public static final Function<Double,Double> divideBy(double divisor,
RoundingMode roundingMode)```

It divides the target element by the given divisor and returns its result rounded based on the specified rounding mode

Parameters:
`divisor` - the divisor
`roundingMode` - the `RoundingMode`
Returns:
the result of target/divisor

### remainder

`public static final Function<Double,Double> remainder(Number divisor)`

It divides the target element by the given divisor and returns the remainder (target % divisor)

Parameters:
`divisor` - the divisor
Returns:
the remainder of target/divisor

### remainder

`public static final Function<Double,Double> remainder(byte divisor)`

It divides the target element by the given divisor and returns the remainder (target % divisor)

Parameters:
`divisor` - the divisor
Returns:
the remainder of target/divisor

### remainder

`public static final Function<Double,Double> remainder(short divisor)`

It divides the target element by the given divisor and returns the remainder (target % divisor)

Parameters:
`divisor` - the divisor
Returns:
the remainder of target/divisor

### remainder

`public static final Function<Double,Double> remainder(int divisor)`

It divides the target element by the given divisor and returns the remainder (target % divisor)

Parameters:
`divisor` - the divisor
Returns:
the remainder of target/divisor

### remainder

`public static final Function<Double,Double> remainder(long divisor)`

It divides the target element by the given divisor and returns the remainder (target % divisor)

Parameters:
`divisor` - the divisor
Returns:
the remainder of target/divisor

### remainder

`public static final Function<Double,Double> remainder(float divisor)`

It divides the target element by the given divisor and returns the remainder (target % divisor)

Parameters:
`divisor` - the divisor
Returns:
the remainder of target/divisor

### remainder

`public static final Function<Double,Double> remainder(double divisor)`

It divides the target element by the given divisor and returns the remainder (target % divisor)

Parameters:
`divisor` - the divisor
Returns:
the remainder of target/divisor

### remainder

```public static final Function<Double,Double> remainder(Number divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns the remainder (target % divisor). The remainder precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the remainder of target/divisor

### remainder

```public static final Function<Double,Double> remainder(byte divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns the remainder (target % divisor). The remainder precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the remainder of target/divisor

### remainder

```public static final Function<Double,Double> remainder(short divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns the remainder (target % divisor). The remainder precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the remainder of target/divisor

### remainder

```public static final Function<Double,Double> remainder(int divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns the remainder (target % divisor). The remainder precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the remainder of target/divisor

### remainder

```public static final Function<Double,Double> remainder(long divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns the remainder (target % divisor). The remainder precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the remainder of target/divisor

### remainder

```public static final Function<Double,Double> remainder(float divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns the remainder (target % divisor). The remainder precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the remainder of target/divisor

### remainder

```public static final Function<Double,Double> remainder(double divisor,
MathContext mathContext)```

It divides the target element by the given divisor and returns the remainder (target % divisor). The remainder precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`divisor` - the divisor
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the remainder of target/divisor

### multiplyBy

`public static final Function<Double,Double> multiplyBy(Number multiplicand)`

It multiplies target by multiplicand and returns its value

Parameters:
`multiplicand` - the multiplicand
Returns:
the result of target * multiplicand

### multiplyBy

`public static final Function<Double,Double> multiplyBy(byte multiplicand)`

It multiplies target by multiplicand and returns its value

Parameters:
`multiplicand` - the multiplicand
Returns:
the result of target * multiplicand

### multiplyBy

`public static final Function<Double,Double> multiplyBy(short multiplicand)`

It multiplies target by multiplicand and returns its value

Parameters:
`multiplicand` - the multiplicand
Returns:
the result of target * multiplicand

### multiplyBy

`public static final Function<Double,Double> multiplyBy(int multiplicand)`

It multiplies target by multiplicand and returns its value

Parameters:
`multiplicand` - the multiplicand
Returns:
the result of target * multiplicand

### multiplyBy

`public static final Function<Double,Double> multiplyBy(long multiplicand)`

It multiplies target by multiplicand and returns its value

Parameters:
`multiplicand` - the multiplicand
Returns:
the result of target * multiplicand

### multiplyBy

`public static final Function<Double,Double> multiplyBy(float multiplicand)`

It multiplies target by multiplicand and returns its value

Parameters:
`multiplicand` - the multiplicand
Returns:
the result of target * multiplicand

### multiplyBy

`public static final Function<Double,Double> multiplyBy(double multiplicand)`

It multiplies target by multiplicand and returns its value

Parameters:
`multiplicand` - the multiplicand
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(Number multiplicand,
MathContext mathContext)```

It multiplies target by multiplicand and returns its value. The result precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`multiplicand` - the multiplicand
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(byte multiplicand,
MathContext mathContext)```

It multiplies target by multiplicand and returns its value. The result precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`multiplicand` - the multiplicand
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(short multiplicand,
MathContext mathContext)```

It multiplies target by multiplicand and returns its value. The result precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`multiplicand` - the multiplicand
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(int multiplicand,
MathContext mathContext)```

It multiplies target by multiplicand and returns its value. The result precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`multiplicand` - the multiplicand
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(long multiplicand,
MathContext mathContext)```

It multiplies target by multiplicand and returns its value. The result precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`multiplicand` - the multiplicand
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(float multiplicand,
MathContext mathContext)```

It multiplies target by multiplicand and returns its value. The result precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`multiplicand` - the multiplicand
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(double multiplicand,
MathContext mathContext)```

It multiplies target by multiplicand and returns its value. The result precision and `RoundingMode` is specified by the given `MathContext`

Parameters:
`multiplicand` - the multiplicand
`mathContext` - the `MathContext` to define `RoundingMode` and precision
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(Number multiplicand,
RoundingMode roundingMode)```

It multiplies target by multiplicand and returns its value. The result is rounded based on the given `RoundingMode`

Parameters:
`multiplicand` - the multiplicand
`roundingMode` - the `RoundingMode`
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(byte multiplicand,
RoundingMode roundingMode)```

It multiplies target by multiplicand and returns its value. The result is rounded based on the given `RoundingMode`

Parameters:
`multiplicand` - the multiplicand
`roundingMode` - the `RoundingMode`
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(short multiplicand,
RoundingMode roundingMode)```

It multiplies target by multiplicand and returns its value. The result is rounded based on the given `RoundingMode`

Parameters:
`multiplicand` - the multiplicand
`roundingMode` - the `RoundingMode`
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(int multiplicand,
RoundingMode roundingMode)```

It multiplies target by multiplicand and returns its value. The result is rounded based on the given `RoundingMode`

Parameters:
`multiplicand` - the multiplicand
`roundingMode` - the `RoundingMode`
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(long multiplicand,
RoundingMode roundingMode)```

It multiplies target by multiplicand and returns its value. The result is rounded based on the given `RoundingMode`

Parameters:
`multiplicand` - the multiplicand
`roundingMode` - the `RoundingMode`
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(float multiplicand,
RoundingMode roundingMode)```

It multiplies target by multiplicand and returns its value. The result is rounded based on the given `RoundingMode`

Parameters:
`multiplicand` - the multiplicand
`roundingMode` - the `RoundingMode`
Returns:
the result of target * multiplicand

### multiplyBy

```public static final Function<Double,Double> multiplyBy(double multiplicand,
RoundingMode roundingMode)```

It multiplies target by multiplicand and returns its value. The result is rounded based on the given `RoundingMode`

Parameters:
`multiplicand` - the multiplicand
`roundingMode` - the `RoundingMode`
Returns:
the result of target * multiplicand

### pow

`public static final Function<Double,Double> pow(int power)`

It performs the operation targetpower and returns its value

Parameters:
`power` - the power to raise the target to
Returns:
the result of targetpower

### pow

```public static final Function<Double,Double> pow(int power,
MathContext mathContext)```

It performs the operation targetpower and returns its value. The result precision and rounding mode is specified by the given `MathContext`

Parameters:
`power` - the power to raise the target to
`mathContext` - the `MathContext` to specify precision and `RoundingMode`
Returns:
the result of targetpower

### pow

```public static final Function<Double,Double> pow(int power,
RoundingMode roundingMode)```

It performs the operation targetpower and returns its value. The result rounding mode is specified by the given `RoundingMode`

Parameters:
`power` - the power to raise the target to
`roundingMode` - the `RoundingMode`
Returns:
the result of targetpower

### between

```public static final Function<Double,Boolean> between(Number min,
Number max)```

Determines whether the target object is between min and max in value, this is, whether target.compareTo(min) >= 0 && target.compareTo(max) <= 0. The target and the specified min and max have to implement `Comparable`.

Parameters:
`min` - the minimum value of the target
`max` - the maximum value of the target
Returns:
true if the target is between min and max (or it's equal to any of them)

### between

```public static final Function<Double,Boolean> between(double min,
double max)```

Determines whether the target object is between min and max in value, this is, whether target.compareTo(min) >= 0 && target.compareTo(max) <= 0. The target and the specified min and max have to implement `Comparable`.

Parameters:
`min` - the minimum value of the target
`max` - the maximum value of the target
Returns:
true if the target is between min and max (or it's equal to any of them)