Package org.apfloat

# Class ApcomplexMath

java.lang.Object
org.apfloat.ApcomplexMath

public class ApcomplexMath extends Object
Various mathematical functions for arbitrary precision complex numbers.
Version:
1.14.0
Author:
Mikko Tommila
• ## Method Summary

Modifier and Type
Method
Description
`static Apfloat`
`abs(Apcomplex z)`
Absolute value.
`static Apcomplex`
`acos(Apcomplex z)`
Inverse cosine.
`static Apcomplex`
`acosh(Apcomplex z)`
Inverse hyperbolic cosine.
`static Apcomplex`
```agm(Apcomplex a, Apcomplex b)```
Arithmetic-geometric mean.
`static Apcomplex`
`airyAi(Apcomplex z)`
Airy function Ai.
`static Apcomplex`
`airyAiPrime(Apcomplex z)`
Derivative of the Airy function Ai.
`static Apcomplex`
`airyBi(Apcomplex z)`
Airy function Bi.
`static Apcomplex`
`airyBiPrime(Apcomplex z)`
Derivative of the Airy function Bi.
`static Apcomplex[]`
```allRoots(Apcomplex z, int n)```
All values of the positive integer root.
`static Apfloat`
`arg(Apcomplex z)`
Angle of the complex vector in the complex plane.
`static Apcomplex`
`asin(Apcomplex z)`
Inverse sine.
`static Apcomplex`
`asinh(Apcomplex z)`
Inverse hyperbolic sine.
`static Apcomplex`
`atan(Apcomplex z)`
Inverse tangent.
`static Apcomplex`
`atanh(Apcomplex z)`
Inverse hyperbolic tangent.
`static Apcomplex`
```bernoulliB(long n, Apcomplex z)```
Bernoulli polynomial.
`static Apcomplex`
```besselI(Apcomplex ν, Apcomplex z)```
Modified Bessel function of the first kind.
`static Apcomplex`
```besselJ(Apcomplex ν, Apcomplex z)```
Bessel function of the first kind.
`static Apcomplex`
```besselK(Apcomplex ν, Apcomplex z)```
Modified Bessel function of the second kind.
`static Apcomplex`
```besselY(Apcomplex ν, Apcomplex z)```
Bessel function of the second kind.
`static Apcomplex`
```beta(Apcomplex a, Apcomplex b)```
Beta function.
`static Apcomplex`
```beta(Apcomplex z, Apcomplex a, Apcomplex b)```
Incomplete beta function.
`static Apcomplex`
```beta(Apcomplex z1, Apcomplex z2, Apcomplex a, Apcomplex b)```
Generalized incomplete beta function.
`static Apcomplex`
```binomial(Apcomplex n, Apcomplex k)```
Binomial coefficient.
`static Apcomplex`
`cbrt(Apcomplex z)`
Cube root.
`static Apcomplex`
```chebyshevT(Apcomplex ν, Apcomplex z)```
Chebyshev function of the first kind.
`static Apcomplex`
```chebyshevU(Apcomplex ν, Apcomplex z)```
Chebyshev function of the second kind.
`static Apcomplex`
`cos(Apcomplex z)`
Cosine.
`static Apcomplex`
`cosh(Apcomplex z)`
Hyperbolic cosine.
`static Apcomplex`
`coshIntegral(Apcomplex z)`
Hyperbolic cosine integral.
`static Apcomplex`
`cosIntegral(Apcomplex z)`
Cosine integral.
`static Apcomplex`
`digamma(Apcomplex z)`
Digamma function.
`static Apcomplex`
`ellipticE(Apcomplex z)`
Complete elliptic integral of the second kind.
`static Apcomplex`
`ellipticK(Apcomplex z)`
Complete elliptic integral of the first kind.
`static Apcomplex`
`erf(Apcomplex z)`
Error function.
`static Apcomplex`
`erfc(Apcomplex z)`
Complementary error function.
`static Apcomplex`
`erfi(Apcomplex z)`
Imaginary error function.
`static Apcomplex`
```eulerE(long n, Apcomplex z)```
Euler polynomial.
`static Apcomplex`
`exp(Apcomplex z)`
Exponent function.
`static Apcomplex`
```expIntegralE(Apcomplex ν, Apcomplex z)```
Exponential integral E.
`static Apcomplex`
`expIntegralEi(Apcomplex z)`
Exponential integral Ei.
`static Apcomplex`
```fibonacci(Apcomplex ν, Apcomplex z)```
Fibonacci function.
`static Apcomplex`
`fresnelC(Apcomplex z)`
Fresnel integral C.
`static Apcomplex`
`fresnelS(Apcomplex z)`
Fresnel integral S.
`static Apcomplex`
`gamma(Apcomplex z)`
Gamma function.
`static Apcomplex`
```gamma(Apcomplex a, Apcomplex z)```
Incomplete gamma function.
`static Apcomplex`
```gamma(Apcomplex a, Apcomplex z0, Apcomplex z1)```
Generalized incomplete gamma function.
`static Apcomplex`
```gegenbauerC(Apcomplex ν, Apcomplex z)```
Renormalized Gegenbauer function.
`static Apcomplex`
```gegenbauerC(Apcomplex ν, Apcomplex λ, Apcomplex z)```
Gegenbauer function.
`static Apcomplex`
`harmonicNumber(Apcomplex z)`
Harmonic number.
`static Apcomplex`
```harmonicNumber(Apcomplex z, Apcomplex r)```
Generalized harmonic number.
`static Apcomplex`
```hermiteH(Apcomplex ν, Apcomplex z)```
Hermite function.
`static Apcomplex`
```hypergeometric0F1(Apcomplex a, Apcomplex z)```
Confluent hypergeometric function 0F1.
`static Apcomplex`
```hypergeometric0F1Regularized(Apcomplex a, Apcomplex z)```
Regularized confluent hypergeometric function 01.
`static Apcomplex`
```hypergeometric1F1(Apcomplex a, Apcomplex b, Apcomplex z)```
Kummer confluent hypergeometric function 1F1.
`static Apcomplex`
```hypergeometric1F1Regularized(Apcomplex a, Apcomplex b, Apcomplex z)```
Regularized Kummer confluent hypergeometric function 11.
`static Apcomplex`
```hypergeometric2F1(Apcomplex a, Apcomplex b, Apcomplex c, Apcomplex z)```
Hypergeometric function 2F1.
`static Apcomplex`
```hypergeometric2F1Regularized(Apcomplex a, Apcomplex b, Apcomplex c, Apcomplex z)```
Regularized hypergeometric function 21.
`static Apcomplex`
```hypergeometricU(Apcomplex a, Apcomplex b, Apcomplex z)```
Tricomi's confluent hypergeometric function U.
`static Apcomplex`
```inverseRoot(Apcomplex z, long n)```
Inverse positive integer root.
`static Apcomplex`
```inverseRoot(Apcomplex z, long n, long k)```
Inverse positive integer root.
`static Apcomplex`
```jacobiP(Apcomplex ν, Apcomplex a, Apcomplex b, Apcomplex z)```
Jacobi function.
`static Apcomplex`
```laguerreL(Apcomplex ν, Apcomplex z)```
Laguerre function.
`static Apcomplex`
```laguerreL(Apcomplex ν, Apcomplex λ, Apcomplex z)```
Generalized Laguerre function.
`static Apcomplex`
```legendreP(Apcomplex ν, Apcomplex z)```
Legendre function.
`static Apcomplex`
```legendreP(Apcomplex ν, Apcomplex μ, Apcomplex z)```
Associated Legendre function of the first kind.
`static Apcomplex`
```legendreQ(Apcomplex ν, Apcomplex z)```
Legendre function of the second kind.
`static Apcomplex`
```legendreQ(Apcomplex ν, Apcomplex μ, Apcomplex z)```
Associated Legendre function of the second kind.
`static Apcomplex`
`log(Apcomplex z)`
Natural logarithm.
`static Apcomplex`
```log(Apcomplex z, Apcomplex w)```
Logarithm in arbitrary base.
`static Apcomplex`
`logGamma(Apcomplex z)`
Logarithm of the gamma function.
`static Apcomplex`
`logIntegral(Apcomplex z)`
Logarithmic integral.
`static Apcomplex`
`logisticSigmoid(Apcomplex z)`
Logistic sigmoid.
`static Apcomplex`
`negate(Apcomplex z)`
Deprecated.
`static Apfloat`
`norm(Apcomplex z)`
Norm.
`static Apcomplex`
```pochhammer(Apcomplex z, Apcomplex n)```
Pochhammer symbol.
`static Apcomplex`
```polygamma(long n, Apcomplex z)```
Polygamma function.
`static Apcomplex`
```polylog(Apcomplex ν, Apcomplex z)```
Polylogarithm.
`static Apcomplex`
```pow(Apcomplex z, long n)```
Integer power.
`static Apcomplex`
```pow(Apcomplex z, Apcomplex w)```
Arbitrary power.
`static Apcomplex`
`product(Apcomplex... z)`
Product of numbers.
`static Apcomplex`
```root(Apcomplex z, long n)```
Positive integer root.
`static Apcomplex`
```root(Apcomplex z, long n, long k)```
Positive integer root.
`static Apcomplex`
```scale(Apcomplex z, long scale)```
Multiply by a power of the radix.
`static Apcomplex`
`sin(Apcomplex z)`
Sine.
`static Apcomplex`
`sinc(Apcomplex z)`
Sinc.
`static Apcomplex`
`sinh(Apcomplex z)`
Hyperbolic sine.
`static Apcomplex`
`sinhIntegral(Apcomplex z)`
Hyperbolic sine integral.
`static Apcomplex`
`sinIntegral(Apcomplex z)`
Sine integral.
`static Apcomplex`
```sphericalHarmonicY(Apcomplex λ, Apcomplex μ, Apcomplex ϑ, Apcomplex ϕ)```
Spherical harmonic function.
`static Apcomplex`
`sqrt(Apcomplex z)`
Square root.
`static Apcomplex`
`sum(Apcomplex... z)`
Sum of numbers.
`static Apcomplex`
`tan(Apcomplex z)`
Tangent.
`static Apcomplex`
`tanh(Apcomplex z)`
Hyperbolic tangent.
`static Apfloat`
`ulp(Apcomplex z)`
Returns the unit in the last place of the argument, considering the scale and precision.
`static Apcomplex`
`w(Apcomplex z)`
Lambert W function.
`static Apcomplex`
```w(Apcomplex z, long k)```
Lambert W function for the specified branch.
`static Apcomplex`
`zeta(Apcomplex s)`
Riemann zeta function.
`static Apcomplex`
```zeta(Apcomplex s, Apcomplex a)```
Hurwitz zeta function.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ## Method Details

• ### negate

public static Apcomplex negate(Apcomplex z) throws ApfloatRuntimeException
Deprecated.
Negative value.
Parameters:
`z` - The argument.
Returns:
`-z`.
Throws:
`ApfloatRuntimeException`
• ### abs

public static Apfloat abs(Apcomplex z) throws ApfloatRuntimeException
Absolute value.
Parameters:
`z` - The argument.
Returns:
`sqrt(x2 + y2)`, where `z = x + i y`.
Throws:
`ApfloatRuntimeException`
• ### norm

public static Apfloat norm(Apcomplex z) throws ApfloatRuntimeException
Norm. Square of the magnitude.
Parameters:
`z` - The argument.
Returns:
`x2 + y2`, where `z = x + i y`.
Throws:
`ApfloatRuntimeException`
• ### arg

public static Apfloat arg(Apcomplex z) throws
Angle of the complex vector in the complex plane.
Parameters:
`z` - The argument.
Returns:
`arctan(y / x)` from the appropriate branch, where `z = x + i y`.
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
• ### scale

public static Apcomplex scale(Apcomplex z, long scale) throws ApfloatRuntimeException
Multiply by a power of the radix.
Parameters:
`z` - The argument.
`scale` - The scaling factor.
Returns:
`z * z.radix()scale`.
Throws:
`ApfloatRuntimeException`
• ### pow

public static Apcomplex pow(Apcomplex z, long n) throws
Integer power.
Parameters:
`z` - Base of the power operator.
`n` - Exponent of the power operator.
Returns:
`z` to the `n`:th power, that is `zn`.
Throws:
`ArithmeticException` - If both `z` and `n` are zero.
`ApfloatRuntimeException`
• ### sqrt

public static Apcomplex sqrt(Apcomplex z) throws ApfloatRuntimeException
Square root.
Parameters:
`z` - The argument.
Returns:
Square root of `z`.
Throws:
`ApfloatRuntimeException`
• ### cbrt

public static Apcomplex cbrt(Apcomplex z) throws ApfloatRuntimeException
Cube root.
Parameters:
`z` - The argument.
Returns:
Cube root of `z`.
Throws:
`ApfloatRuntimeException`
• ### root

public static Apcomplex root(Apcomplex z, long n) throws
Positive integer root. The branch that has the smallest angle and same sign of imaginary part as `z` is always chosen.
Parameters:
`z` - The argument.
`n` - Which root to take.
Returns:
`n`:th root of `z`, that is `z1/n`.
Throws:
`ArithmeticException` - If `n` is zero.
`ApfloatRuntimeException`
• ### root

public static Apcomplex root(Apcomplex z, long n, long k) throws
Positive integer root. The specified branch counting from the smallest angle and same sign of imaginary part as `z` is chosen.
Parameters:
`z` - The argument.
`n` - Which root to take.
`k` - Which branch to take.
Returns:
`n`:th root of `z`, that is `z1/nei2πsk/n` where `s` is the signum of the imaginary part of `z`.
Throws:
`ArithmeticException` - If `n` is zero.
`ApfloatRuntimeException`
Since:
1.5
• ### inverseRoot

public static Apcomplex inverseRoot(Apcomplex z, long n) throws
Inverse positive integer root. The branch that has the smallest angle and different sign of imaginary part than `z` is always chosen.
Parameters:
`z` - The argument.
`n` - Which inverse root to take.
Returns:
Inverse `n`:th root of `z`, that is `z-1/n`.
Throws:
`ArithmeticException` - If `z` or `n` is zero.
`ApfloatRuntimeException`
• ### inverseRoot

public static Apcomplex inverseRoot(Apcomplex z, long n, long k) throws
Inverse positive integer root. The specified branch counting from the smallest angle and different sign of imaginary part than `z` is chosen.
Parameters:
`z` - The argument.
`n` - Which inverse root to take.
`k` - Which branch to take.
Returns:
Inverse `n`:th root of `z`, that is `z-1/ne-i2πk/n`.
Throws:
`ArithmeticException` - If `z` or `n` is zero.
`ApfloatRuntimeException`
• ### allRoots

public static  allRoots(Apcomplex z, int n) throws
All values of the positive integer root.

Returns all of the `n` values of the root, in the order of the angle, starting from the smallest angle and same sign of imaginary part as `z`.

Parameters:
`z` - The argument.
`n` - Which root to take.
Returns:
All values of the `n`:th root of `z`, that is `z1/n`, in the order of the angle.
Throws:
`ArithmeticException` - If `n` is zero.
`ApfloatRuntimeException`
Since:
1.5
• ### agm

public static Apcomplex agm(Apcomplex a, Apcomplex b) throws ApfloatRuntimeException
Arithmetic-geometric mean.
Parameters:
`a` - First argument.
`b` - Second argument.
Returns:
Arithmetic-geometric mean of `a` and `b`.
Throws:
`ApfloatRuntimeException`
• ### log

public static Apcomplex log(Apcomplex z) throws
Natural logarithm.

The logarithm is calculated using the arithmetic-geometric mean. See the Borweins' book for the formula.

Parameters:
`z` - The argument.
Returns:
Natural logarithm of `z`.
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
• ### log

public static Apcomplex log(Apcomplex z, Apcomplex w) throws
Logarithm in arbitrary base.

Parameters:
`z` - The argument.
`w` - The base.
Returns:
Base-`w` logarithm of `z`.
Throws:
`ArithmeticException` - If `z` or `w` is zero.
`ApfloatRuntimeException`
Since:
1.6
• ### exp

public static Apcomplex exp(Apcomplex z) throws ApfloatRuntimeException
Exponent function. Calculated using Newton's iteration for the inverse of logarithm.
Parameters:
`z` - The argument.
Returns:
`ez`.
Throws:
`ApfloatRuntimeException`
• ### pow

public static Apcomplex pow(Apcomplex z, Apcomplex w) throws ApfloatRuntimeException
Arbitrary power. Calculated using `log()` and `exp()`.

Parameters:
`z` - The base.
`w` - The exponent.
Returns:
`zw`.
Throws:
`ArithmeticException` - If both `z` and `w` are zero.
`ApfloatRuntimeException`
• ### acos

public static Apcomplex acos(Apcomplex z) throws ApfloatRuntimeException
Inverse cosine. Calculated using `log()`.
Parameters:
`z` - The argument.
Returns:
Inverse cosine of `z`.
Throws:
`ApfloatRuntimeException`
• ### acosh

public static Apcomplex acosh(Apcomplex z) throws ApfloatRuntimeException
Inverse hyperbolic cosine. Calculated using `log()`.
Parameters:
`z` - The argument.
Returns:
Inverse hyperbolic cosine of `z`.
Throws:
`ApfloatRuntimeException`
• ### asin

public static Apcomplex asin(Apcomplex z) throws ApfloatRuntimeException
Inverse sine. Calculated using `log()`.
Parameters:
`z` - The argument.
Returns:
Inverse sine of `z`.
Throws:
`ApfloatRuntimeException`
• ### asinh

public static Apcomplex asinh(Apcomplex z) throws ApfloatRuntimeException
Inverse hyperbolic sine. Calculated using `log()`.
Parameters:
`z` - The argument.
Returns:
Inverse hyperbolic sine of `z`.
Throws:
`ApfloatRuntimeException`
• ### atan

public static Apcomplex atan(Apcomplex z) throws
Inverse tangent. Calculated using `log()`.
Parameters:
`z` - The argument.
Returns:
Inverse tangent of `z`.
Throws:
`ArithmeticException` - If `z == i`.
`ApfloatRuntimeException`
• ### atanh

public static Apcomplex atanh(Apcomplex z) throws
Inverse hyperbolic tangent. Calculated using `log()`.
Parameters:
`z` - The argument.
Returns:
Inverse hyperbolic tangent of `z`.
Throws:
`ArithmeticException` - If `z` is 1 or -1.
`ApfloatRuntimeException`
• ### cos

public static Apcomplex cos(Apcomplex z) throws ApfloatRuntimeException
Cosine. Calculated using `exp()`.
Parameters:
`z` - The argument.
Returns:
Cosine of `z`.
Throws:
`ApfloatRuntimeException`
• ### cosh

public static Apcomplex cosh(Apcomplex z) throws ApfloatRuntimeException
Hyperbolic cosine. Calculated using `exp()`.
Parameters:
`z` - The argument.
Returns:
Hyperbolic cosine of `z`.
Throws:
`ApfloatRuntimeException`
• ### sin

public static Apcomplex sin(Apcomplex z) throws ApfloatRuntimeException
Sine. Calculated using `exp()`.
Parameters:
`z` - The argument.
Returns:
Sine of `z`.
Throws:
`ApfloatRuntimeException`
• ### sinh

public static Apcomplex sinh(Apcomplex z) throws ApfloatRuntimeException
Hyperbolic sine. Calculated using `exp()`.
Parameters:
`z` - The argument.
Returns:
Hyperbolic sine of `z`.
Throws:
`ApfloatRuntimeException`
• ### tan

public static Apcomplex tan(Apcomplex z) throws
Tangent. Calculated using `exp()`.
Parameters:
`z` - The argument.
Returns:
Tangent of `z`.
Throws:
`ArithmeticException` - If `z` is π/2 + n π where n is an integer.
`ApfloatRuntimeException`
• ### tanh

public static Apcomplex tanh(Apcomplex z) throws
Hyperbolic tangent. Calculated using `exp()`.
Parameters:
`z` - The argument.
Returns:
Hyperbolic tangent of `z`.
Throws:
`ArithmeticException` - If `z` is i (π/2 + n π) where n is an integer.
`ApfloatRuntimeException`
• ### sinc

public static Apcomplex sinc(Apcomplex z) throws ApfloatRuntimeException
Sinc.
Parameters:
`z` - The argument.
Returns:
sinc(z)
Throws:
`ApfloatRuntimeException`
Since:
1.14.0
• ### w

public static Apcomplex w(Apcomplex z) throws ApfloatRuntimeException
Lambert W function. The W function gives the solution to the equation `W eW = z`. Also known as the product logarithm.

This function gives the solution to the principal branch, W0.

Parameters:
`z` - The argument.
Returns:
`W0(z)`.
Throws:
`ApfloatRuntimeException`
Since:
1.8.0
• ### w

public static Apcomplex w(Apcomplex z, long k) throws
Lambert W function for the specified branch.

Parameters:
`z` - The argument.
`k` - The branch.
Returns:
`Wk(z)`.
Throws:
`ArithmeticException` - If `z` is zero and `k` is not zero.
`ApfloatRuntimeException`
Since:
1.8.0
• ### product

public static Apcomplex product(Apcomplex... z) throws ApfloatRuntimeException
Product of numbers. The precision used in the multiplications is only what is needed for the end result. This method may perform significantly better than simply multiplying the numbers sequentially.

If there are no arguments, the return value is `1`.

Parameters:
`z` - The argument(s).
Returns:
The product of the given numbers.
Throws:
`ApfloatRuntimeException`
Since:
1.3
• ### sum

public static Apcomplex sum(Apcomplex... z) throws ApfloatRuntimeException
Sum of numbers. The precision used in the additions is only what is needed for the end result. This method may perform significantly better than simply adding the numbers sequentially.

If there are no arguments, the return value is `0`.

Parameters:
`z` - The argument(s).
Returns:
The sum of the given numbers.
Throws:
`ApfloatRuntimeException`
Since:
1.3
• ### gamma

public static Apcomplex gamma(Apcomplex z) throws
Gamma function.

Parameters:
`z` - The argument.
Returns:
`Γ(z)`
Throws:
`ArithmeticException` - If `z` is a nonpositive integer.
`ApfloatRuntimeException`
Since:
1.9.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the gamma function.
• ### gamma

public static Apcomplex gamma(Apcomplex a, Apcomplex z) throws
Incomplete gamma function.

Parameters:
`a` - The first argument.
`z` - The second argument.
Returns:
`Γ(a, z)`
Throws:
`ArithmeticException` - If the real part of `a` is nonpositive and `z` is zero.
`ApfloatRuntimeException`
Since:
1.10.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the incomplete gamma function.
• ### gamma

public static Apcomplex gamma(Apcomplex a, Apcomplex z0, Apcomplex z1) throws
Generalized incomplete gamma function.

This function is defined as: `Γ(a, z0, z1) = Γ(a, z0) - Γ(a, z1)`

The lower gamma function can be calculated with: `γ(a, z) = Γ(a, 0, z)`

Parameters:
`a` - The first argument.
`z0` - The second argument.
`z1` - The third argument.
Returns:
`Γ(a, z0, z1)`
Throws:
`ArithmeticException` - If the real part of `a` is nonpositive and either `z0` or `z1` is zero. For the lower gamma function if `a` is a nonpositive integer.
`ApfloatRuntimeException`
Since:
1.10.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the incomplete gamma function.
• ### logGamma

public static Apcomplex logGamma(Apcomplex z) throws
Logarithm of the gamma function. Note that this function has a different branch structure than `log(gamma(z))`.

Parameters:
`z` - The argument.
Returns:
`logΓ(z)`
Throws:
`ArithmeticException` - If `z` is a nonpositive integer.
`ApfloatRuntimeException`
Since:
1.11.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the gamma function.
• ### digamma

public static Apcomplex digamma(Apcomplex z) throws
Digamma function.

Parameters:
`z` - The argument.
Returns:
`ψ(z)`
Throws:
`ArithmeticException` - If `z` is a nonpositive integer.
`ApfloatRuntimeException`
Since:
1.11.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the digamma function.
• ### polygamma

public static Apcomplex polygamma(long n, Apcomplex z) throws
Polygamma function.

Parameters:
`n` - The order.
`z` - The argument.
Returns:
`ψ(n)(z)`
Throws:
`ArithmeticException` - If `n` is negative or `z` is a nonpositive integer.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the polygamma function.
• ### beta

public static Apcomplex beta(Apcomplex a, Apcomplex b) throws
Beta function.

Parameters:
`a` - The first argument.
`b` - The second argument.
Returns:
B(a, b)
Throws:
`ArithmeticException` - If `a` or `b` is a nonpositive integer but `a + b` is not. Also if both `a` and `b` are nonpositive integers.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the beta function.
• ### beta

public static Apcomplex beta(Apcomplex z, Apcomplex a, Apcomplex b) throws
Incomplete beta function.

Parameters:
`z` - The first argument.
`a` - The second argument.
`b` - The third argument.
Returns:
Bz(a, b)
Throws:
`ArithmeticException` - If `a` is a nonpositive integer or `z` is zero and `a` has nonpositive real part.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### beta

public static Apcomplex beta(Apcomplex z1, Apcomplex z2, Apcomplex a, Apcomplex b) throws
Generalized incomplete beta function.

Parameters:
`z1` - The first argument.
`z2` - The second argument.
`a` - The third argument.
`b` - The fourth argument.
Returns:
B(z1, z2)(a, b)
Throws:
`ArithmeticException` - If `a` is a nonpositive integer or `z1` or `z2` is zero and `a` has nonpositive real part.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### pochhammer

public static Apcomplex pochhammer(Apcomplex z, Apcomplex n) throws
Pochhammer symbol.

Parameters:
`z` - The first argument.
`n` - The second argument.
Returns:
`(z)n`
Throws:
`ArithmeticException` - If `z + n` is a nonpositive integer but `z` is not.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. The asymptotic complexity is at least O(n2log n) and it is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the pochhammer symbol.
• ### binomial

public static Apcomplex binomial(Apcomplex n, Apcomplex k) throws
Binomial coefficient. Calculated using the `gamma(Apcomplex)` function.
Parameters:
`n` - The first argument.
`k` - The second argument.
Returns:
$\left(\genfrac{}{}{0}{}{n}{k}\right)$
Throws:
`ArithmeticException` - If `n` is a negative integer and `k` is noninteger.
`ApfloatRuntimeException`
Since:
1.11.0
• ### zeta

public static Apcomplex zeta(Apcomplex s) throws
Riemann zeta function.

Parameters:
`s` - The argument.
Returns:
`ζ(s)`
Throws:
`ArithmeticException` - If `s` is `1`.
`ApfloatRuntimeException`
Since:
1.11.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few hundred digits. At the time of implementation no generic fast algorithm is known for the zeta function.
• ### zeta

public static Apcomplex zeta(Apcomplex s, Apcomplex a) throws
Hurwitz zeta function.

Parameters:
`s` - The first argument.
`a` - The second argument.
Returns:
`ζ(s, a)`
Throws:
`ArithmeticException` - If `s` is `1` or if `a` is a nonpositive integer.
`ApfloatRuntimeException`
Since:
1.11.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few hundred digits. At the time of implementation no generic fast algorithm is known for the zeta function.
• ### hypergeometric0F1

public static Apcomplex hypergeometric0F1(Apcomplex a, Apcomplex z) throws
Confluent hypergeometric function 0F1.

Parameters:
`a` - The first argument.
`z` - The second argument.
Returns:
0F1(; a; z)
Throws:
`ArithmeticException` - If the function value is not finite.
`ApfloatRuntimeException`
Since:
1.11.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### hypergeometric0F1Regularized

public static Apcomplex hypergeometric0F1Regularized(Apcomplex a, Apcomplex z) throws ApfloatRuntimeException
Regularized confluent hypergeometric function 01.

Parameters:
`a` - The first argument.
`z` - The second argument.
Returns:
01(; a; z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### hypergeometric1F1

public static Apcomplex hypergeometric1F1(Apcomplex a, Apcomplex b, Apcomplex z) throws
Kummer confluent hypergeometric function 1F1. Also known as the confluent hypergeometric function of the first kind.

Parameters:
`a` - The first argument.
`b` - The second argument.
`z` - The third argument.
Returns:
1F1(a; b; z)
Throws:
`ArithmeticException` - If the function value is not finite.
`ApfloatRuntimeException`
Since:
1.11.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### hypergeometric1F1Regularized

public static Apcomplex hypergeometric1F1Regularized(Apcomplex a, Apcomplex b, Apcomplex z) throws ApfloatRuntimeException
Regularized Kummer confluent hypergeometric function 11. Also known as the regularized confluent hypergeometric function of the first kind.

Parameters:
`a` - The first argument.
`b` - The second argument.
`z` - The third argument.
Returns:
11(a; b; z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### hypergeometric2F1

public static Apcomplex hypergeometric2F1(Apcomplex a, Apcomplex b, Apcomplex c, Apcomplex z) throws
Hypergeometric function 2F1. Also known as the Gaussian or ordinary hypergeometric function.

Parameters:
`a` - The first argument.
`b` - The second argument.
`c` - The third argument.
`z` - The fourth argument.
Returns:
2F1(a, b; c; z)
Throws:
`ArithmeticException` - If the function value is not finite.
`ApfloatRuntimeException`
Since:
1.11.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### hypergeometric2F1Regularized

public static Apcomplex hypergeometric2F1Regularized(Apcomplex a, Apcomplex b, Apcomplex c, Apcomplex z) throws ApfloatRuntimeException
Regularized hypergeometric function 21. Also known as the regularized Gaussian or ordinary hypergeometric function.

Parameters:
`a` - The first argument.
`b` - The second argument.
`c` - The third argument.
`z` - The fourth argument.
Returns:
21(a, b; c; z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### hypergeometricU

public static Apcomplex hypergeometricU(Apcomplex a, Apcomplex b, Apcomplex z) throws
Tricomi's confluent hypergeometric function U. Also known as the confluent hypergeometric function of the second kind.

Parameters:
`a` - The first argument.
`b` - The second argument.
`z` - The third argument.
Returns:
U(a, b, z)
Throws:
`ArithmeticException` - If the result is not finite.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### erf

public static Apcomplex erf(Apcomplex z) throws ApfloatRuntimeException
Error function.

Parameters:
`z` - The argument.
Returns:
erf(z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### erfc

public static Apcomplex erfc(Apcomplex z) throws ApfloatRuntimeException
Complementary error function.

Parameters:
`z` - The argument.
Returns:
erfc(z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### erfi

public static Apcomplex erfi(Apcomplex z) throws ApfloatRuntimeException
Imaginary error function.

Parameters:
`z` - The argument.
Returns:
erfi(z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### fresnelS

public static Apcomplex fresnelS(Apcomplex z) throws ApfloatRuntimeException
Fresnel integral S.

Parameters:
`z` - The argument.
Returns:
S(z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### fresnelC

public static Apcomplex fresnelC(Apcomplex z) throws ApfloatRuntimeException
Fresnel integral C.

Parameters:
`z` - The argument.
Returns:
C(z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### expIntegralE

public static Apcomplex expIntegralE(Apcomplex ν, Apcomplex z) throws
Exponential integral E.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Eν(z)
Throws:
`ArithmeticException` - If real part of `ν` is ≤ 1 and `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### expIntegralEi

public static Apcomplex expIntegralEi(Apcomplex z) throws
Exponential integral Ei.

Parameters:
`z` - The argument.
Returns:
Ei(z)
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.

public static Apcomplex logIntegral(Apcomplex z) throws
Logarithmic integral.

Parameters:
`z` - The argument.
Returns:
li(z)
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### sinIntegral

public static Apcomplex sinIntegral(Apcomplex z) throws ApfloatRuntimeException
Sine integral.

Parameters:
`z` - The argument.
Returns:
Si(z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### cosIntegral

public static Apcomplex cosIntegral(Apcomplex z) throws
Cosine integral.

Parameters:
`z` - The argument.
Returns:
Ci(z)
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### sinhIntegral

public static Apcomplex sinhIntegral(Apcomplex z) throws ApfloatRuntimeException
Hyperbolic sine integral.

Parameters:
`z` - The argument.
Returns:
Shi(z)
Throws:
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### coshIntegral

public static Apcomplex coshIntegral(Apcomplex z) throws
Hyperbolic cosine integral.

Parameters:
`z` - The argument.
Returns:
Chi(z)
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### airyAi

public static Apcomplex airyAi(Apcomplex z) throws ApfloatRuntimeException
Airy function Ai.

Parameters:
`z` - The argument.
Returns:
Ai(z)
Throws:
`InfiniteExpansionException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### airyAiPrime

public static Apcomplex airyAiPrime(Apcomplex z) throws ApfloatRuntimeException
Derivative of the Airy function Ai.

Parameters:
`z` - The argument.
Returns:
Ai′(z)
Throws:
`InfiniteExpansionException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### airyBi

public static Apcomplex airyBi(Apcomplex z) throws ApfloatRuntimeException
Airy function Bi.

Parameters:
`z` - The argument.
Returns:
Bi(z)
Throws:
`InfiniteExpansionException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### airyBiPrime

public static Apcomplex airyBiPrime(Apcomplex z) throws ApfloatRuntimeException
Derivative of the Airy function Bi.

Parameters:
`z` - The argument.
Returns:
Bi′(z)
Throws:
`InfiniteExpansionException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### besselJ

public static Apcomplex besselJ(Apcomplex ν, Apcomplex z) throws
Bessel function of the first kind.

Parameters:
`ν` - The order.
`z` - The argument.
Returns:
Jν(z)
Throws:
`ArithmeticException` - If the real part of `ν` is < 0 and `ν` is not an integer and `z` is zero. Also if the real part of `ν` is zero but the imaginary part is not, and `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### besselI

public static Apcomplex besselI(Apcomplex ν, Apcomplex z) throws
Modified Bessel function of the first kind.

Parameters:
`ν` - The order.
`z` - The argument.
Returns:
Iν(z)
Throws:
`ArithmeticException` - If the real part of `ν` is < 0 and `ν` is not an integer and `z` is zero. Also if the real part of `ν` is zero but the imaginary part is not, and `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### besselY

public static Apcomplex besselY(Apcomplex ν, Apcomplex z) throws
Bessel function of the second kind.

Parameters:
`ν` - The order.
`z` - The argument.
Returns:
Yν(z)
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### besselK

public static Apcomplex besselK(Apcomplex ν, Apcomplex z) throws
Modified Bessel function of the second kind.

Parameters:
`ν` - The order.
`z` - The argument.
Returns:
Kν(z)
Throws:
`ArithmeticException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### ellipticK

public static Apcomplex ellipticK(Apcomplex z) throws
Complete elliptic integral of the first kind.

Note that this function uses the definition: $K\left(z\right)⩵{\int }_{0}^{\frac{\pi }{2}}\frac{1}{\sqrt{1-z{\mathrm{sin}}^{2}\left(t\right)}}dt$

Parameters:
`z` - The argument.
Returns:
K(z)
Throws:
`InfiniteExpansionException` - If `z` is zero.
`ArithmeticException` - If `z` is one.
`ApfloatRuntimeException`
Since:
1.13.0
• ### ellipticE

public static Apcomplex ellipticE(Apcomplex z) throws ApfloatRuntimeException
Complete elliptic integral of the second kind.

Note that this function uses the definition: $E\left(z\right)⩵{\int }_{0}^{\frac{\pi }{2}}\sqrt{1-z{\mathrm{sin}}^{2}\left(t\right)}dt$

Parameters:
`z` - The argument.
Returns:
E(z)
Throws:
`InfiniteExpansionException` - If `z` is zero.
`ApfloatRuntimeException`
Since:
1.13.0
• ### hermiteH

public static Apcomplex hermiteH(Apcomplex ν, Apcomplex z) throws ApfloatRuntimeException
Hermite function. For integer values of `ν` gives the Hermite polynomial.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Hν(z)
Throws:
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### laguerreL

public static Apcomplex laguerreL(Apcomplex ν, Apcomplex z) throws ApfloatRuntimeException
Laguerre function. For integer values of `ν` gives the Laguerre polynomial.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Lν(z)
Throws:
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### laguerreL

public static Apcomplex laguerreL(Apcomplex ν, Apcomplex λ, Apcomplex z) throws ApfloatRuntimeException
Generalized Laguerre function. For integer values of `ν` gives the generalized Laguerre polynomial.

Parameters:
`ν` - The first argument.
`λ` - The second argument.
`z` - The third argument.
Returns:
Lνλ(z)
Throws:
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### legendreP

public static Apcomplex legendreP(Apcomplex ν, Apcomplex z) throws
Legendre function. For integer values of `ν` gives the Legendre polynomial.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Pν(z)
Throws:
`ArithmeticException` - If `ν` is not an integer and `z` is -1.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### legendreP

public static Apcomplex legendreP(Apcomplex ν, Apcomplex μ, Apcomplex z) throws
Associated Legendre function of the first kind. Gives Legendre functions of type 2.

Parameters:
`ν` - The first argument.
`μ` - The second argument.
`z` - The third argument.
Returns:
Pνμ(z)
Throws:
`ArithmeticException` - If `ν` is not an integer and `z` is -1.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### legendreQ

public static Apcomplex legendreQ(Apcomplex ν, Apcomplex z) throws
Legendre function of the second kind.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Qν(z)
Throws:
`ArithmeticException` - If `z` is 1 or -1.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### legendreQ

public static Apcomplex legendreQ(Apcomplex ν, Apcomplex μ, Apcomplex z) throws
Associated Legendre function of the second kind. Gives Legendre functions of type 2.

Parameters:
`ν` - The first argument.
`μ` - The second argument.
`z` - The third argument.
Returns:
Qνμ(z)
Throws:
`ArithmeticException` - If `z` is 1 or -1.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### sphericalHarmonicY

public static Apcomplex sphericalHarmonicY(Apcomplex λ, Apcomplex μ, Apcomplex ϑ, Apcomplex ϕ) throws
Spherical harmonic function.

Parameters:
`λ` - The first argument.
`μ` - The second argument.
`ϑ` - The third argument.
`ϕ` - The fourth argument.
Returns:
Yλμ(ϑ, φ)
Throws:
`ArithmeticException` - If `ϑ` is π plus a multiple of 2 π and μ is not an integer and has a negative real part, or if `λ - μ` is a negative integer.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### chebyshevT

public static Apcomplex chebyshevT(Apcomplex ν, Apcomplex z) throws ApfloatRuntimeException
Chebyshev function of the first kind. For integer values of `ν` gives the Chebyshev polynomial of the first kind.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Tν(z)
Throws:
`ApfloatRuntimeException`
Since:
1.14.0
• ### chebyshevU

public static Apcomplex chebyshevU(Apcomplex ν, Apcomplex z) throws
Chebyshev function of the second kind. For integer values of `ν` gives the Chebyshev polynomial of the second kind.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Uν(z)
Throws:
`ArithmeticException` - If `z` is -1 and `ν` is not an integer.
`ApfloatRuntimeException`
Since:
1.14.0
• ### gegenbauerC

public static Apcomplex gegenbauerC(Apcomplex ν, Apcomplex z) throws
Renormalized Gegenbauer function.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Cν(0)(z)
Throws:
`ArithmeticException` - If `ν` is zero.
`ApfloatRuntimeException`
Since:
1.14.0
• ### gegenbauerC

public static Apcomplex gegenbauerC(Apcomplex ν, Apcomplex λ, Apcomplex z) throws
Gegenbauer function. For nonnegative integer values of `ν` gives the Gegenbauer polynomial.

Parameters:
`ν` - The first argument.
`λ` - The second argument.
`z` - The third argument.
Returns:
Cνλ(z)
Throws:
`ArithmeticException` - If `z` is -1 and real part of `λ` is > 1/2. Also if `z` is -1 and `λ` is 1/2 and `ν` is not an integer.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### jacobiP

public static Apcomplex jacobiP(Apcomplex ν, Apcomplex a, Apcomplex b, Apcomplex z) throws
Jacobi function. For nonnegative integer values of `ν` gives the Jacobi polynomial.

Parameters:
`ν` - The first argument.
`a` - The second argument.
`b` - The third argument.
`z` - The fourth argument.
Returns:
Pν(a,b)(z)
Throws:
`ArithmeticException` - If `z` is -1 and real part of `b` is > 0 and `ν` is not a positive integer. Also if `ν + a` is a negative integer and `ν` is not an integer.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### fibonacci

public static Apcomplex fibonacci(Apcomplex ν, Apcomplex z) throws
Fibonacci function. For nonnegative integer values of `ν` gives the Fibonacci polynomial.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Fν(z)
Throws:
`ArithmeticException` - If `z` is -1 and `ν` is not an integer.
`ApfloatRuntimeException`
Since:
1.14.0
• ### eulerE

public static Apcomplex eulerE(long n, Apcomplex z) throws
Euler polynomial.

Parameters:
`n` - The first argument.
`z` - The second argument.
Returns:
En(z)
Throws:
`IllegalArgumentException` - If `n` < 0.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### bernoulliB

public static Apcomplex bernoulliB(long n, Apcomplex z) throws
Bernoulli polynomial.

Parameters:
`n` - The first argument.
`z` - The second argument.
Returns:
Bn(z)
Throws:
`IllegalArgumentException` - If `n` < 0.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### harmonicNumber

public static Apcomplex harmonicNumber(Apcomplex z) throws
Harmonic number.

Parameters:
`z` - The argument.
Returns:
Hz
Throws:
`ArithmeticException` - If `z` is a negative integer.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### harmonicNumber

public static Apcomplex harmonicNumber(Apcomplex z, Apcomplex r) throws
Generalized harmonic number.

Parameters:
`z` - The first argument.
`r` - The second argument.
Returns:
Hz(r)
Throws:
`ArithmeticException` - If `z` is a negative integer, unless `r` has a negative real part or is zero.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### polylog

public static Apcomplex polylog(Apcomplex ν, Apcomplex z) throws
Polylogarithm.

Parameters:
`ν` - The first argument.
`z` - The second argument.
Returns:
Liν(z)
Throws:
`ArithmeticException` - If the real part of `ν` is ≤ 1 and `z` is 1.
`ApfloatRuntimeException`
Since:
1.14.0
Implementation notes:
This implementation is slow, meaning that it isn't a fast algorithm. It is impractically slow beyond a precision of a few thousand digits. At the time of implementation no generic fast algorithm is known for the function.
• ### logisticSigmoid

public static Apcomplex logisticSigmoid(Apcomplex z) throws
Logistic sigmoid.
Parameters:
`z` - The argument.
Returns:
σ(z)
Throws:
`ArithmeticException` - If `z` is an odd integer multiple of π i.
`ApfloatRuntimeException`
Since:
1.14.0
• ### ulp

public static Apfloat ulp(Apcomplex z)
Returns the unit in the last place of the argument, considering the scale and precision. This is maximum of the ulps of the real and imaginary part of the argument. If the precision of the argument is infinite, zero is returned.
Parameters:
`z` - The argument.
Returns:
The ulp of the argument.
Since:
1.10.0