BigDecimalMath (nd4j-common 0.8.0 API)

java.lang.Object
- org.nd4j.linalg.util.BigDecimalMath

public class BigDecimalMath
extends Object

BigDecimal special functions.

Constructor Summary

Constructors
Constructor and Description

BigDecimalMath()

Constructors
Constructor and Description
`BigDecimalMath()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static BigDecimal`	`acosh(BigDecimal x)` The inverse hyperbolic cosine.
`static BigDecimal`	`addRound(BigDecimal x, BigDecimal y)` Add and round according to the larger of the two ulp’s.
`static BigDecimal`	`asin(BigDecimal x)` The inverse trigonometric sine.
`static BigDecimal`	`asinh(BigDecimal x)` The inverse hyperbolic sine.
`static BigDecimal`	`atan(BigDecimal x)` The inverse trigonometric tangent.
`protected static BigDecimal`	`broadhurstBBP(int n, int p, int[] a, MathContext mc)` Broadhurst ladder sequence.
`static BigDecimal`	`cbrt(BigDecimal x)` The cube root.
`static BigDecimal`	`cos(BigDecimal x)` Trigonometric cosine.
`static BigDecimal`	`cosh(BigDecimal x)` The hyperbolic cosine.
`static BigDecimal`	`cot(BigDecimal x)` The trigonometric co-tangent.
`static BigDecimal`	`divideRound(BigDecimal x, BigDecimal y)` Divide and round.
`static BigDecimal`	`divideRound(BigDecimal x, BigInteger n)` Divide and round.
`static BigDecimal`	`divideRound(BigDecimal x, int n)` Divide and round.
`static BigDecimal`	`divideRound(BigInteger n, BigDecimal x)` Divide and round.
`static BigDecimal`	`divideRound(int n, BigDecimal x)` Divide and round.
`static int`	`err2prec(BigDecimal x, BigDecimal xerr)` Convert an absolute error to a precision.
`static int`	`err2prec(double xerr)` Convert a relative error to a precision.
`static int`	`err2prec(double x, double xerr)` Convert an absolute error to a precision.
`static BigDecimal`	`exp(BigDecimal x)` The exponential function.
`static BigDecimal`	`exp(MathContext mc)` The base of the natural logarithm.
`static BigDecimal`	`Gamma(BigDecimal x)` The Gamma function.
`static BigDecimal`	`gamma(MathContext mc)` Euler-Mascheroni constant.
`static BigDecimal`	`hypot(BigDecimal x, BigDecimal y)` The hypotenuse.
`static BigDecimal`	`hypot(int n, BigDecimal x)` The hypotenuse.
`static BigDecimal`	`log(BigDecimal x)` The natural logarithm.
`static BigDecimal`	`log(int n, MathContext mc)` The natural logarithm.
`static BigDecimal`	`log(org.nd4j.linalg.util.Rational r, MathContext mc)` The natural logarithm.
`static BigDecimal`	`mod2pi(BigDecimal x)` Reduce value to the interval [0,2*Pi].
`static BigDecimal`	`modpi(BigDecimal x)` Reduce value to the interval [-Pi/2,Pi/2].
`static BigDecimal`	`multiplyRound(BigDecimal x, BigDecimal y)` Multiply and round.
`static BigDecimal`	`multiplyRound(BigDecimal x, BigInteger n)` Multiply and round.
`static BigDecimal`	`multiplyRound(BigDecimal x, int n)` Multiply and round.
`static BigDecimal`	`multiplyRound(BigDecimal x, org.nd4j.linalg.util.Rational f)` Multiply and round.
`static BigDecimal`	`pi(MathContext mc)` Euler’s constant.
`static BigDecimal`	`pochhammer(BigDecimal x, int n)` Pochhammer’s function.
`static BigDecimal`	`pow(BigDecimal x, BigDecimal y)` Power function.
`static BigDecimal`	`powRound(BigDecimal x, int n)` Raise to an integer power and round.
`static double`	`prec2err(double x, int prec)` Convert a precision (relative error) to an absolute error.
`static BigDecimal`	`root(int n, BigDecimal x)` The integer root.
`static BigDecimal`	`scalePrec(BigDecimal x, int d)` Append decimal zeros to the value.
`static BigDecimal`	`scalePrec(BigDecimal x, MathContext mc)` Boost the precision by appending decimal zeros to the value.
`static BigDecimal`	`sin(BigDecimal x)` Trigonometric sine.
`static BigDecimal`	`sinh(BigDecimal x)` The hyperbolic sine.
`static BigDecimal`	`sqrt(BigDecimal x)` The square root.
`static BigDecimal`	`subtractRound(BigDecimal x, BigDecimal y)` Subtract and round according to the larger of the two ulp’s.
`static BigDecimal`	`tan(BigDecimal x)` The trigonometric tangent.
`static BigDecimal`	`tanh(BigDecimal x)` The hyperbolic tangent.
`static BigDecimal`	`zeta(int n, MathContext mc)` Riemann zeta function.
`static double`	`zeta1(int n)` Riemann zeta function.

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

- Constructor Detail
  - BigDecimalMath
```
public BigDecimalMath()
```
- Method Detail
  - pi
```
public static BigDecimal pi(MathContext mc)
```
    Euler’s constant.
    
    Parameters:
    
    mc - The required precision of the result.
    
    Returns:
    
    3.14159...
  - gamma
```
public static BigDecimal gamma(MathContext mc)
```
    Euler-Mascheroni constant.
    
    Parameters:
    
    mc - The required precision of the result.
    
    Returns:
    
    0.577...
  - sqrt
```
public static BigDecimal sqrt(BigDecimal x)
```
    The square root.
    
    Parameters:
    
    x - the non-negative argument.
    
    Returns:
    
    the square root of the BigDecimal rounded to the precision implied by x.
  - cbrt
```
public static BigDecimal cbrt(BigDecimal x)
```
    The cube root.
    
    Parameters:
    
    x - The argument.
    
    Returns:
    
    The cubic root of the BigDecimal rounded to the precision implied by x. The sign of the result is the sign of the argument.
  - root
```
public static BigDecimal root(int n,
                              BigDecimal x)
```
    The integer root.
    
    Parameters:
    
    n - the positive argument.
    
    x - the non-negative argument.
    
    Returns:
    
    The n-th root of the BigDecimal rounded to the precision implied by x, x^(1/n).
  - hypot
```
public static BigDecimal hypot(BigDecimal x,
                               BigDecimal y)
```
    The hypotenuse.
    
    Parameters:
    
    x - the first argument.
    
    y - the second argument.
    
    Returns:
    
    the square root of the sum of the squares of the two arguments, sqrt(x^2+y^2).
  - hypot
```
public static BigDecimal hypot(int n,
                               BigDecimal x)
```
    The hypotenuse.
    
    Parameters:
    
    n - the first argument.
    
    x - the second argument.
    
    Returns:
    
    the square root of the sum of the squares of the two arguments, sqrt(n^2+x^2).
  - exp
```
public static BigDecimal exp(BigDecimal x)
```
    The exponential function.
    
    Parameters:
    
    x - the argument.
    
    Returns:
    
    exp(x). The precision of the result is implicitly defined by the precision in the argument. 16 In particular this means that "Invalid Operation" errors are thrown if catastrophic cancellation of digits causes the result to have no valid digits left.
  - exp
```
public static BigDecimal exp(MathContext mc)
```
    The base of the natural logarithm.
    
    Parameters:
    
    mc - the required precision of the result
    
    Returns:
    
    exp(1) = 2.71828....
  - log
```
public static BigDecimal log(BigDecimal x)
```
    The natural logarithm.
    
    Parameters:
    
    x - the argument.
    
    Returns:
    
    ln(x). The precision of the result is implicitly defined by the precision in the argument.
  - log
```
public static BigDecimal log(int n,
                             MathContext mc)
```
    The natural logarithm.
    
    Parameters:
    
    n - The main argument, a strictly positive integer.
    
    mc - The requirements on the precision.
    
    Returns:
    
    ln(n).
  - log
```
public static BigDecimal log(org.nd4j.linalg.util.Rational r,
                             MathContext mc)
```
    The natural logarithm.
    
    Parameters:
    
    r - The main argument, a strictly positive value.
    
    mc - The requirements on the precision.
    
    Returns:
    
    ln(r).
  - pow
```
public static BigDecimal pow(BigDecimal x,
                             BigDecimal y)
```
    Power function.
    
    Parameters:
    
    x - Base of the power.
    
    y - Exponent of the power.
    
    Returns:
    
    x^y. The estimation of the relative error in the result is |log(x)*err(y)|+|y*err(x)/x|
  - powRound
```
public static BigDecimal powRound(BigDecimal x,
                                  int n)
```
    Raise to an integer power and round.
    
    Parameters:
    
    x - The base.
    
    n - The exponent.
    
    Returns:
    
    x^n.
  - sin
```
public static BigDecimal sin(BigDecimal x)
```
    Trigonometric sine.
    
    Parameters:
    
    x - The argument in radians.
    
    Returns:
    
    sin(x) in the range -1 to 1.
  - cos
```
public static BigDecimal cos(BigDecimal x)
```
    Trigonometric cosine.
    
    Parameters:
    
    x - The argument in radians.
    
    Returns:
    
    cos(x) in the range -1 to 1.
  - tan
```
public static BigDecimal tan(BigDecimal x)
```
    The trigonometric tangent.
    
    Parameters:
    
    x - the argument in radians.
    
    Returns:
    
    the tan(x)
  - cot
```
public static BigDecimal cot(BigDecimal x)
```
    The trigonometric co-tangent.
    
    Parameters:
    
    x - the argument in radians.
    
    Returns:
    
    the cot(x)
  - asin
```
public static BigDecimal asin(BigDecimal x)
```
    The inverse trigonometric sine.
    
    Parameters:
    
    x - the argument.
    
    Returns:
    
    the arcsin(x) in radians.
  - atan
```
public static BigDecimal atan(BigDecimal x)
```
    The inverse trigonometric tangent.
    
    Parameters:
    
    x - the argument.
    
    Returns:
    
    the principal value of arctan(x) in radians in the range -pi/2 to +pi/2.
  - cosh
```
public static BigDecimal cosh(BigDecimal x)
```
    The hyperbolic cosine.
    
    Parameters:
    
    x - The argument.
    
    Returns:
    
    The cosh(x) = (exp(x)+exp(-x))/2 .
  - sinh
```
public static BigDecimal sinh(BigDecimal x)
```
    The hyperbolic sine.
    
    Parameters:
    
    x - the argument.
    
    Returns:
    
    the sinh(x) = (exp(x)-exp(-x))/2 .
  - tanh
```
public static BigDecimal tanh(BigDecimal x)
```
    The hyperbolic tangent.
    
    Parameters:
    
    x - The argument.
    
    Returns:
    
    The tanh(x) = sinh(x)/cosh(x).
  - asinh
```
public static BigDecimal asinh(BigDecimal x)
```
    The inverse hyperbolic sine.
    
    Parameters:
    
    x - The argument.
    
    Returns:
    
    The arcsinh(x) .
  - acosh
```
public static BigDecimal acosh(BigDecimal x)
```
    The inverse hyperbolic cosine.
    
    Parameters:
    
    x - The argument.
    
    Returns:
    
    The arccosh(x) .
  - Gamma
```
public static BigDecimal Gamma(BigDecimal x)
```
    The Gamma function.
    
    Parameters:
    
    x - The argument.
    
    Returns:
    
    Gamma(x).
  - pochhammer
```
public static BigDecimal pochhammer(BigDecimal x,
                                    int n)
```
    Pochhammer’s function.
    
    Parameters:
    
    x - The main argument.
    
    n - The non-negative index.
    
    Returns:
    
    (x)_n = x(x+1)(x+2)*...*(x+n-1).
  - mod2pi
```
public static BigDecimal mod2pi(BigDecimal x)
```
    Reduce value to the interval [0,2*Pi].
    
    Parameters:
    
    x - the original value
    
    Returns:
    
    the value modulo 2*pi in the interval from 0 to 2*pi.
  - modpi
```
public static BigDecimal modpi(BigDecimal x)
```
    Reduce value to the interval [-Pi/2,Pi/2].
    
    Parameters:
    
    x - The original value
    
    Returns:
    
    The value modulo pi, shifted to the interval from -Pi/2 to Pi/2.
  - zeta
```
public static BigDecimal zeta(int n,
                              MathContext mc)
```
    Riemann zeta function.
    
    Parameters:
    
    n - The positive integer argument. 32
    
    mc - Specification of the accuracy of the result.
    
    Returns:
    
    zeta(n).
  - zeta1
```
public static double zeta1(int n)
```
    Riemann zeta function.
    
    Parameters:
    
    n - The positive integer argument.
    
    Returns:
    
    zeta(n)-1.
  - broadhurstBBP
```
protected static BigDecimal broadhurstBBP(int n,
                                          int p,
                                          int[] a,
                                          MathContext mc)
```
    Broadhurst ladder sequence.
    
    Parameters:
    
    a - The vector of 8 integer arguments
    
    mc - Specification of the accuracy of the result
    
    Returns:
    
    S_(n, p)(a)
    
    See Also:
    
    width0pt\protect\href{http://arxiv.org/abs/math/9803067}{arXiv:math/9803067}
  - addRound
```
public static BigDecimal addRound(BigDecimal x,
                                  BigDecimal y)
```
    Add and round according to the larger of the two ulp’s.
    
    Parameters:
    
    x - The left summand
    
    y - The right summand
    
    Returns:
    
    The sum x+y.
  - subtractRound
```
public static BigDecimal subtractRound(BigDecimal x,
                                       BigDecimal y)
```
    Subtract and round according to the larger of the two ulp’s.
    
    Parameters:
    
    x - The left term.
    
    y - The right term.
    
    Returns:
    
    The difference x-y.
  - multiplyRound
```
public static BigDecimal multiplyRound(BigDecimal x,
                                       BigDecimal y)
```
    Multiply and round.
    
    Parameters:
    
    x - The left factor.
    
    y - The right factor.
    
    Returns:
    
    The product x*y.
  - multiplyRound
```
public static BigDecimal multiplyRound(BigDecimal x,
                                       org.nd4j.linalg.util.Rational f)
```
    Multiply and round.
    
    Parameters:
    
    x - The left factor.
    
    f - The right factor.
    
    Returns:
    
    The product x*f.
  - multiplyRound
```
public static BigDecimal multiplyRound(BigDecimal x,
                                       int n)
```
    Multiply and round.
    
    Parameters:
    
    x - The left factor.
    
    n - The right factor.
    
    Returns:
    
    The product x*n.
  - multiplyRound
```
public static BigDecimal multiplyRound(BigDecimal x,
                                       BigInteger n)
```
    Multiply and round.
    
    Parameters:
    
    x - The left factor.
    
    n - The right factor.
    
    Returns:
    
    the product x*n
  - divideRound
```
public static BigDecimal divideRound(BigDecimal x,
                                     BigDecimal y)
```
    Divide and round.
    
    Parameters:
    
    x - The numerator
    
    y - The denominator
    
    Returns:
    
    the divided x/y
  - divideRound
```
public static BigDecimal divideRound(BigDecimal x,
                                     int n)
```
    Divide and round.
    
    Parameters:
    
    x - The numerator
    
    n - The denominator
    
    Returns:
    
    the divided x/n
  - divideRound
```
public static BigDecimal divideRound(BigDecimal x,
                                     BigInteger n)
```
    Divide and round.
    
    Parameters:
    
    x - The numerator
    
    n - The denominator
    
    Returns:
    
    the divided x/n
  - divideRound
```
public static BigDecimal divideRound(BigInteger n,
                                     BigDecimal x)
```
    Divide and round.
    
    Parameters:
    
    n - The numerator
    
    x - The denominator
    
    Returns:
    
    the divided n/x
  - divideRound
```
public static BigDecimal divideRound(int n,
                                     BigDecimal x)
```
    Divide and round.
    
    Parameters:
    
    n - The numerator.
    
    x - The denominator.
    
    Returns:
    
    the divided n/x.
  - scalePrec
```
public static BigDecimal scalePrec(BigDecimal x,
                                   int d)
```
    Append decimal zeros to the value. This returns a value which appears to have a higher precision than the input.
    
    Parameters:
    
    x - The input value
    
    d - The (positive) value of zeros to be added as least significant digits.
    
    Returns:
    
    The same value as the input but with increased (pseudo) precision.
  - scalePrec
```
public static BigDecimal scalePrec(BigDecimal x,
                                   MathContext mc)
```
    Boost the precision by appending decimal zeros to the value. This returns a value which appears to have a higher precision than the input.
    
    Parameters:
    
    x - The input value
    
    mc - The requirement on the minimum precision on return.
    
    Returns:
    
    The same value as the input but with increased (pseudo) precision.
  - err2prec
```
public static int err2prec(BigDecimal x,
                           BigDecimal xerr)
```
    Convert an absolute error to a precision.
    
    Parameters:
    
    x - The value of the variable
    
    xerr - The absolute error in the variable
    
    Returns:
    
    The number of valid digits in x. The value is rounded down, and on the pessimistic side for that reason.
  - err2prec
```
public static int err2prec(double x,
                           double xerr)
```
    Convert an absolute error to a precision.
    
    Parameters:
    
    x - The value of the variable The value returned depends only on the absolute value, not on the sign.
    
    xerr - The absolute error in the variable The value returned depends only on the absolute value, not on the sign.
    
    Returns:
    
    The number of valid digits in x. Derived from the representation x+- xerr, as if the error was represented 38 in a "half width" (half of the error bar) form. The value is rounded down, and on the pessimistic side for that reason.
  - err2prec
```
public static int err2prec(double xerr)
```
    Convert a relative error to a precision.
    
    Parameters:
    
    xerr - The relative error in the variable. The value returned depends only on the absolute value, not on the sign.
    
    Returns:
    
    The number of valid digits in x. The value is rounded down, and on the pessimistic side for that reason.
  - prec2err
```
public static double prec2err(double x,
                              int prec)
```
    Convert a precision (relative error) to an absolute error. The is the inverse functionality of err2prec().
    
    Parameters:
    
    x - The value of the variable The value returned depends only on the absolute value, not on the sign.
    
    prec - The number of valid digits of the variable.
    
    Returns:
    
    the absolute error in x. Derived from the an accuracy of one half of the ulp.

Class BigDecimalMath

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BigDecimalMath

Method Detail

pi

gamma

sqrt

cbrt

root

hypot

hypot

exp

exp

log

log

log

pow

powRound

sin

cos

tan

cot

asin

atan

cosh

sinh

tanh

asinh

acosh

Gamma

pochhammer

mod2pi

modpi

zeta

zeta1

broadhurstBBP

addRound

subtractRound

multiplyRound

multiplyRound

multiplyRound

multiplyRound

divideRound

divideRound

divideRound

divideRound

divideRound

scalePrec

scalePrec

err2prec

err2prec

err2prec

prec2err