package scipy

Get an attribute of this module as a Py.Object.t. This is useful to pass a Python function to another function.

agm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

agm(a, b)

Compute the arithmetic-geometric mean of `a` and `b`.

Start with a_0 = a and b_0 = b and iteratively compute::

a_n+1 = (a_n + b_n)/2 b_n+1 = sqrt(a_n*b_n)

a_n and b_n converge to the same limit as n increases; their common limit is agm(a, b).

Parameters ---------- a, b : array_like Real values only. If the values are both negative, the result is negative. If one value is negative and the other is positive, `nan` is returned.

Returns ------- float The arithmetic-geometric mean of `a` and `b`.

Examples -------- >>> from scipy.special import agm >>> a, b = 24.0, 6.0 >>> agm(a, b) 13.458171481725614

Compare that result to the iteration:

>>> while a != b: ... a, b = (a + b)/2, np.sqrt(a*b) ... print('a = %19.16f b=%19.16f' % (a, b)) ... a = 15.0000000000000000 b=12.0000000000000000 a = 13.5000000000000000 b=13.4164078649987388 a = 13.4582039324993694 b=13.4581390309909850 a = 13.4581714817451772 b=13.4581714817060547 a = 13.4581714817256159 b=13.4581714817256159

When array-like arguments are given, broadcasting applies:

>>> a = np.array([1.5], [3], [6]) # a has shape (3, 1). >>> b = np.array(6, 12, 24, 48) # b has shape (4,). >>> agm(a, b) array([ 3.36454287, 5.42363427, 9.05798751, 15.53650756], [ 4.37037309, 6.72908574, 10.84726853, 18.11597502], [ 6. , 8.74074619, 13.45817148, 21.69453707])

airy(x, out1, out2, out3, out4, / , out=(None, None, None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

airy(z)

Airy functions and their derivatives.

Parameters ---------- z : array_like Real or complex argument.

Returns ------- Ai, Aip, Bi, Bip : ndarrays Airy functions Ai and Bi, and their derivatives Aip and Bip.

Notes ----- The Airy functions Ai and Bi are two independent solutions of

.. math:: y''(x) = x y(x).

For real `z` in -10, 10, the computation is carried out by calling the Cephes 1_ `airy` routine, which uses power series summation for small `z` and rational minimax approximations for large `z`.

Outside this range, the AMOS 2_ `zairy` and `zbiry` routines are employed. They are computed using power series for :math:`|z| < 1` and the following relations to modified Bessel functions for larger `z` (where :math:`t \equiv 2 z^

/2

/3`):

.. math::

Ai(z) = \frac

\pi \sqrt{3

}

K_

/3

(t)

Ai'(z) = -\fracz\pi \sqrt{3

}

K_

/3

(t)

Bi(z) = \sqrt\frac{z

}

\left(I_

1/3

}

(t) + I_

/3

(t) \right)

Bi'(z) = \fracz\sqrt{3

}

\left(I_

2/3

}

(t) + I_

/3

(t)\right)

See also -------- airye : exponentially scaled Airy functions.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/ .. 2 Donald E. Amos, 'AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order', http://netlib.org/amos/

Examples -------- Compute the Airy functions on the interval -15, 5.

>>> from scipy import special >>> x = np.linspace(-15, 5, 201) >>> ai, aip, bi, bip = special.airy(x)

Plot Ai(x) and Bi(x).

>>> import matplotlib.pyplot as plt >>> plt.plot(x, ai, 'r', label='Ai(x)') >>> plt.plot(x, bi, 'b--', label='Bi(x)') >>> plt.ylim(-0.5, 1.0) >>> plt.grid() >>> plt.legend(loc='upper left') >>> plt.show()

airye(x, out1, out2, out3, out4, / , out=(None, None, None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

airye(z)

Exponentially scaled Airy functions and their derivatives.

Scaling::

eAi = Ai * exp(2.0/3.0*z*sqrt(z)) eAip = Aip * exp(2.0/3.0*z*sqrt(z)) eBi = Bi * exp(-abs(2.0/3.0*(z*sqrt(z)).real)) eBip = Bip * exp(-abs(2.0/3.0*(z*sqrt(z)).real))

Parameters ---------- z : array_like Real or complex argument.

Returns ------- eAi, eAip, eBi, eBip : array_like Exponentially scaled Airy functions eAi and eBi, and their derivatives eAip and eBip

Notes ----- Wrapper for the AMOS 1_ routines `zairy` and `zbiry`.

See also -------- airy

References ---------- .. 1 Donald E. Amos, 'AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order', http://netlib.org/amos/

Examples -------- We can compute exponentially scaled Airy functions and their derivatives:

>>> from scipy.special import airye >>> import matplotlib.pyplot as plt >>> z = np.linspace(0, 50, 500) >>> eAi, eAip, eBi, eBip = airye(z) >>> f, ax = plt.subplots(2, 1, sharex=True) >>> for ind, data in enumerate([eAi, eAip, ['eAi', 'eAip']], ... [eBi, eBip, ['eBi', 'eBip']]): ... axind.plot(z, data0, '-r', z, data1, '-b') ... axind.legend(data2) ... axind.grid(True) >>> plt.show()

We can compute these using usual non-scaled Airy functions by:

>>> from scipy.special import airy >>> Ai, Aip, Bi, Bip = airy(z) >>> np.allclose(eAi, Ai * np.exp(2.0 / 3.0 * z * np.sqrt(z))) True >>> np.allclose(eAip, Aip * np.exp(2.0 / 3.0 * z * np.sqrt(z))) True >>> np.allclose(eBi, Bi * np.exp(-abs(np.real(2.0 / 3.0 * z * np.sqrt(z))))) True >>> np.allclose(eBip, Bip * np.exp(-abs(np.real(2.0 / 3.0 * z * np.sqrt(z))))) True

Comparing non-scaled and exponentially scaled ones, the usual non-scaled function quickly underflows for large values, whereas the exponentially scaled function does not.

>>> airy(200) (0.0, 0.0, nan, nan) >>> airye(200) (0.07501041684381093, -1.0609012305109042, 0.15003188417418148, 2.1215836725571093)

bdtr(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

bdtr(k, n, p)

Binomial distribution cumulative distribution function.

Sum of the terms 0 through `floor(k)` of the Binomial probability density.

.. math:: \mathrmdtr(k, n, p) = \sum_j=0^\lfloor k \rfloor {n\choosej

}

p^j (1-p)^n-j

Parameters ---------- k : array_like Number of successes (double), rounded down to the nearest integer. n : array_like Number of events (int). p : array_like Probability of success in a single event (float).

Returns ------- y : ndarray Probability of `floor(k)` or fewer successes in `n` independent events with success probabilities of `p`.

Notes ----- The terms are not summed directly; instead the regularized incomplete beta function is employed, according to the formula,

.. math:: \mathrmdtr(k, n, p) = I_

- p

(n - \lfloor k \rfloor, \lfloor k \rfloor + 1).

Wrapper for the Cephes 1_ routine `bdtr`.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

bdtrc(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

bdtrc(k, n, p)

Binomial distribution survival function.

Sum of the terms `floor(k) + 1` through `n` of the binomial probability density,

.. math:: \mathrmdtrc(k, n, p) = \sum_j=\lfloor k \rfloor +1^n {n\choosej

}

p^j (1-p)^n-j

Parameters ---------- k : array_like Number of successes (double), rounded down to nearest integer. n : array_like Number of events (int) p : array_like Probability of success in a single event.

Returns ------- y : ndarray Probability of `floor(k) + 1` or more successes in `n` independent events with success probabilities of `p`.

See also -------- bdtr betainc

Notes ----- The terms are not summed directly; instead the regularized incomplete beta function is employed, according to the formula,

.. math:: \mathrmdtrc(k, n, p) = I_p(\lfloor k \rfloor + 1, n - \lfloor k \rfloor).

Wrapper for the Cephes 1_ routine `bdtrc`.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

bdtri(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

bdtri(k, n, y)

Inverse function to `bdtr` with respect to `p`.

Finds the event probability `p` such that the sum of the terms 0 through `k` of the binomial probability density is equal to the given cumulative probability `y`.

Parameters ---------- k : array_like Number of successes (float), rounded down to the nearest integer. n : array_like Number of events (float) y : array_like Cumulative probability (probability of `k` or fewer successes in `n` events).

Returns ------- p : ndarray The event probability such that `bdtr(\lfloor k \rfloor, n, p) = y`.

See also -------- bdtr betaincinv

Notes ----- The computation is carried out using the inverse beta integral function and the relation,::

1 - p = betaincinv(n - k, k + 1, y).

Wrapper for the Cephes 1_ routine `bdtri`.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

bdtrik(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

bdtrik(y, n, p)

Inverse function to `bdtr` with respect to `k`.

Finds the number of successes `k` such that the sum of the terms 0 through `k` of the Binomial probability density for `n` events with probability `p` is equal to the given cumulative probability `y`.

Parameters ---------- y : array_like Cumulative probability (probability of `k` or fewer successes in `n` events). n : array_like Number of events (float). p : array_like Success probability (float).

Returns ------- k : ndarray The number of successes `k` such that `bdtr(k, n, p) = y`.

See also -------- bdtr

Notes ----- Formula 26.5.24 of 1_ is used to reduce the binomial distribution to the cumulative incomplete beta distribution.

Computation of `k` involves a search for a value that produces the desired value of `y`. The search relies on the monotonicity of `y` with `k`.

Wrapper for the CDFLIB 2_ Fortran routine `cdfbin`.

References ---------- .. 1 Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972. .. 2 Barry Brown, James Lovato, and Kathy Russell, CDFLIB: Library of Fortran Routines for Cumulative Distribution Functions, Inverses, and Other Parameters.

bdtrin(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

bdtrin(k, y, p)

Inverse function to `bdtr` with respect to `n`.

Finds the number of events `n` such that the sum of the terms 0 through `k` of the Binomial probability density for events with probability `p` is equal to the given cumulative probability `y`.

Parameters ---------- k : array_like Number of successes (float). y : array_like Cumulative probability (probability of `k` or fewer successes in `n` events). p : array_like Success probability (float).

Returns ------- n : ndarray The number of events `n` such that `bdtr(k, n, p) = y`.

See also -------- bdtr

Notes ----- Formula 26.5.24 of 1_ is used to reduce the binomial distribution to the cumulative incomplete beta distribution.

Computation of `n` involves a search for a value that produces the desired value of `y`. The search relies on the monotonicity of `y` with `n`.

Wrapper for the CDFLIB 2_ Fortran routine `cdfbin`.

References ---------- .. 1 Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972. .. 2 Barry Brown, James Lovato, and Kathy Russell, CDFLIB: Library of Fortran Routines for Cumulative Distribution Functions, Inverses, and Other Parameters.

bei(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

bei(x, out=None)

Kelvin function bei.

Defined as

.. math::

\mathrmei(x) = \ImJ_0(x e^{3 \pi i / 4})

where :math:`J_0` is the Bessel function of the first kind of order zero (see `jv`). See dlmf_ for more details.

Parameters ---------- x : array_like Real argument. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray Values of the Kelvin function.

See Also -------- ber : the corresponding real part beip : the derivative of bei jv : Bessel function of the first kind

References ---------- .. dlmf NIST, Digital Library of Mathematical Functions, https://dlmf.nist.gov/10.61

Examples -------- It can be expressed using Bessel functions.

>>> import scipy.special as sc >>> x = np.array(1.0, 2.0, 3.0, 4.0) >>> sc.jv(0, x * np.exp(3 * np.pi * 1j / 4)).imag array(0.24956604, 0.97229163, 1.93758679, 2.29269032) >>> sc.bei(x) array(0.24956604, 0.97229163, 1.93758679, 2.29269032)

beip(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

beip(x, out=None)

Derivative of the Kelvin function bei.

Parameters ---------- x : array_like Real argument. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray The values of the derivative of bei.

See Also -------- bei

References ---------- .. dlmf NIST, Digital Library of Mathematical Functions, https://dlmf.nist.gov/10#PT5

ber(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

ber(x, out=None)

Kelvin function ber.

Defined as

.. math::

\mathrmer(x) = \ReJ_0(x e^{3 \pi i / 4})

where :math:`J_0` is the Bessel function of the first kind of order zero (see `jv`). See dlmf_ for more details.

Parameters ---------- x : array_like Real argument. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray Values of the Kelvin function.

See Also -------- bei : the corresponding real part berp : the derivative of bei jv : Bessel function of the first kind

References ---------- .. dlmf NIST, Digital Library of Mathematical Functions, https://dlmf.nist.gov/10.61

Examples -------- It can be expressed using Bessel functions.

>>> import scipy.special as sc >>> x = np.array(1.0, 2.0, 3.0, 4.0) >>> sc.jv(0, x * np.exp(3 * np.pi * 1j / 4)).real array( 0.98438178, 0.75173418, -0.22138025, -2.56341656) >>> sc.ber(x) array( 0.98438178, 0.75173418, -0.22138025, -2.56341656)

berp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

berp(x, out=None)

Derivative of the Kelvin function ber.

Parameters ---------- x : array_like Real argument. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray The values of the derivative of ber.

See Also -------- ber

References ---------- .. dlmf NIST, Digital Library of Mathematical Functions, https://dlmf.nist.gov/10#PT5

besselpoly(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

besselpoly(a, lmb, nu, out=None)

Weighted integral of the Bessel function of the first kind.

Computes

.. math::

\int_0^1 x^\lambda J_\nu(2 a x) \, dx

where :math:`J_\nu` is a Bessel function and :math:`\lambda=lmb`, :math:`\nu=nu`.

Parameters ---------- a : array_like Scale factor inside the Bessel function. lmb : array_like Power of `x` nu : array_like Order of the Bessel function. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray Value of the integral.

beta(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

beta(a, b, out=None)

Beta function.

This function is defined in 1_ as

.. math::

B(a, b) = \int_0^1 t^a-1(1-t)^-1dt = \frac\Gamma(a)\Gamma(b)\Gamma(a+b),

where :math:`\Gamma` is the gamma function.

Parameters ---------- a, b : array-like Real-valued arguments out : ndarray, optional Optional output array for the function result

Returns ------- scalar or ndarray Value of the beta function

See Also -------- gamma : the gamma function betainc : the incomplete beta function betaln : the natural logarithm of the absolute value of the beta function

References ---------- .. 1 NIST Digital Library of Mathematical Functions, Eq. 5.12.1. https://dlmf.nist.gov/5.12

Examples -------- >>> import scipy.special as sc

The beta function relates to the gamma function by the definition given above:

>>> sc.beta(2, 3) 0.08333333333333333 >>> sc.gamma(2)*sc.gamma(3)/sc.gamma(2 + 3) 0.08333333333333333

As this relationship demonstrates, the beta function is symmetric:

>>> sc.beta(1.7, 2.4) 0.16567527689031739 >>> sc.beta(2.4, 1.7) 0.16567527689031739

This function satisfies :math:`B(1, b) = 1/b`:

>>> sc.beta(1, 4) 0.25

betainc(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

betainc(a, b, x, out=None)

Incomplete beta function.

Computes the incomplete beta function, defined as 1_:

.. math::

I_x(a, b) = \frac\Gamma(a+b)\Gamma(a)\Gamma(b) \int_0^x t^a-1(1-t)^-1dt,

for :math:`0 \leq x \leq 1`.

Parameters ---------- a, b : array-like Positive, real-valued parameters x : array-like Real-valued such that :math:`0 \leq x \leq 1`, the upper limit of integration out : ndarray, optional Optional output array for the function values

Returns ------- array-like Value of the incomplete beta function

See Also -------- beta : beta function betaincinv : inverse of the incomplete beta function

Notes ----- The incomplete beta function is also sometimes defined without the `gamma` terms, in which case the above definition is the so-called regularized incomplete beta function. Under this definition, you can get the incomplete beta function by multiplying the result of the SciPy function by `beta`.

References ---------- .. 1 NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/8.17

Examples --------

Let :math:`B(a, b)` be the `beta` function.

>>> import scipy.special as sc

The coefficient in terms of `gamma` is equal to :math:`1/B(a, b)`. Also, when :math:`x=1` the integral is equal to :math:`B(a, b)`. Therefore, :math:`I_x=1(a, b) = 1` for any :math:`a, b`.

>>> sc.betainc(0.2, 3.5, 1.0) 1.0

It satisfies :math:`I_x(a, b) = x^a F(a, 1-b, a+1, x)/ (aB(a, b))`, where :math:`F` is the hypergeometric function `hyp2f1`:

>>> a, b, x = 1.4, 3.1, 0.5 >>> x**a * sc.hyp2f1(a, 1 - b, a + 1, x)/(a * sc.beta(a, b)) 0.8148904036225295 >>> sc.betainc(a, b, x) 0.8148904036225296

This functions satisfies the relationship :math:`I_x(a, b) = 1 - I_

-x

(b, a)`:

>>> sc.betainc(2.2, 3.1, 0.4) 0.49339638807619446 >>> 1 - sc.betainc(3.1, 2.2, 1 - 0.4) 0.49339638807619446

betaincinv(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

betaincinv(a, b, y, out=None)

Inverse of the incomplete beta function.

Computes :math:`x` such that:

.. math::

y = I_x(a, b) = \frac\Gamma(a+b)\Gamma(a)\Gamma(b) \int_0^x t^a-1(1-t)^-1dt,

where :math:`I_x` is the normalized incomplete beta function `betainc` and :math:`\Gamma` is the `gamma` function 1_.

Parameters ---------- a, b : array-like Positive, real-valued parameters y : array-like Real-valued input out : ndarray, optional Optional output array for function values

Returns ------- array-like Value of the inverse of the incomplete beta function

See Also -------- betainc : incomplete beta function gamma : gamma function

References ---------- .. 1 NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/8.17

Examples -------- >>> import scipy.special as sc

This function is the inverse of `betainc` for fixed values of :math:`a` and :math:`b`.

>>> a, b = 1.2, 3.1 >>> y = sc.betainc(a, b, 0.2) >>> sc.betaincinv(a, b, y) 0.2 >>> >>> a, b = 7.5, 0.4 >>> x = sc.betaincinv(a, b, 0.5) >>> sc.betainc(a, b, x) 0.5

betaln(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

betaln(a, b)

Natural logarithm of absolute value of beta function.

Computes ``ln(abs(beta(a, b)))``.

binom(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

binom(n, k)

Binomial coefficient

See Also -------- comb : The number of combinations of N things taken k at a time.

boxcox(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

boxcox(x, lmbda)

Compute the Box-Cox transformation.

The Box-Cox transformation is::

y = (x**lmbda - 1) / lmbda if lmbda != 0 log(x) if lmbda == 0

Returns `nan` if ``x < 0``. Returns `-inf` if ``x == 0`` and ``lmbda < 0``.

Parameters ---------- x : array_like Data to be transformed. lmbda : array_like Power parameter of the Box-Cox transform.

Returns ------- y : array Transformed data.

Notes -----

.. versionadded:: 0.14.0

Examples -------- >>> from scipy.special import boxcox >>> boxcox(1, 4, 10, 2.5) array( 0. , 12.4 , 126.09110641) >>> boxcox(2, 0, 1, 2) array( 0.69314718, 1. , 1.5 )

boxcox1p(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

boxcox1p(x, lmbda)

Compute the Box-Cox transformation of 1 + `x`.

The Box-Cox transformation computed by `boxcox1p` is::

y = ((1+x)**lmbda - 1) / lmbda if lmbda != 0 log(1+x) if lmbda == 0

Returns `nan` if ``x < -1``. Returns `-inf` if ``x == -1`` and ``lmbda < 0``.

Parameters ---------- x : array_like Data to be transformed. lmbda : array_like Power parameter of the Box-Cox transform.

Returns ------- y : array Transformed data.

Notes -----

.. versionadded:: 0.14.0

Examples -------- >>> from scipy.special import boxcox1p >>> boxcox1p(1e-4, 0, 0.5, 1) array( 9.99950003e-05, 9.99975001e-05, 1.00000000e-04) >>> boxcox1p(0.01, 0.1, 0.25) array( 0.00996272, 0.09645476)

btdtr(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

btdtr(a, b, x)

Cumulative distribution function of the beta distribution.

Returns the integral from zero to `x` of the beta probability density function,

.. math:: I = \int_0^x \frac\Gamma(a + b)\Gamma(a)\Gamma(b) t^a-1 (1-t)^-1\,dt

where :math:`\Gamma` is the gamma function.

Parameters ---------- a : array_like Shape parameter (a > 0). b : array_like Shape parameter (b > 0). x : array_like Upper limit of integration, in 0, 1.

Returns ------- I : ndarray Cumulative distribution function of the beta distribution with parameters `a` and `b` at `x`.

See Also -------- betainc

Notes ----- This function is identical to the incomplete beta integral function `betainc`.

Wrapper for the Cephes 1_ routine `btdtr`.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

btdtri(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

btdtri(a, b, p)

The `p`-th quantile of the beta distribution.

This function is the inverse of the beta cumulative distribution function, `btdtr`, returning the value of `x` for which `btdtr(a, b, x) = p`, or

.. math:: p = \int_0^x \frac\Gamma(a + b)\Gamma(a)\Gamma(b) t^a-1 (1-t)^-1\,dt

Parameters ---------- a : array_like Shape parameter (`a` > 0). b : array_like Shape parameter (`b` > 0). p : array_like Cumulative probability, in 0, 1.

Returns ------- x : ndarray The quantile corresponding to `p`.

See Also -------- betaincinv btdtr

Notes ----- The value of `x` is found by interval halving or Newton iterations.

Wrapper for the Cephes 1_ routine `incbi`, which solves the equivalent problem of finding the inverse of the incomplete beta integral.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

btdtria(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

btdtria(p, b, x)

Inverse of `btdtr` with respect to `a`.

This is the inverse of the beta cumulative distribution function, `btdtr`, considered as a function of `a`, returning the value of `a` for which `btdtr(a, b, x) = p`, or

.. math:: p = \int_0^x \frac\Gamma(a + b)\Gamma(a)\Gamma(b) t^a-1 (1-t)^-1\,dt

Parameters ---------- p : array_like Cumulative probability, in 0, 1. b : array_like Shape parameter (`b` > 0). x : array_like The quantile, in 0, 1.

Returns ------- a : ndarray The value of the shape parameter `a` such that `btdtr(a, b, x) = p`.

See Also -------- btdtr : Cumulative distribution function of the beta distribution. btdtri : Inverse with respect to `x`. btdtrib : Inverse with respect to `b`.

Notes ----- Wrapper for the CDFLIB 1_ Fortran routine `cdfbet`.

The cumulative distribution function `p` is computed using a routine by DiDinato and Morris 2_. Computation of `a` involves a search for a value that produces the desired value of `p`. The search relies on the monotonicity of `p` with `a`.

References ---------- .. 1 Barry Brown, James Lovato, and Kathy Russell, CDFLIB: Library of Fortran Routines for Cumulative Distribution Functions, Inverses, and Other Parameters. .. 2 DiDinato, A. R. and Morris, A. H., Algorithm 708: Significant Digit Computation of the Incomplete Beta Function Ratios. ACM Trans. Math. Softw. 18 (1993), 360-373.

btdtrib(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

btdtria(a, p, x)

Inverse of `btdtr` with respect to `b`.

This is the inverse of the beta cumulative distribution function, `btdtr`, considered as a function of `b`, returning the value of `b` for which `btdtr(a, b, x) = p`, or

.. math:: p = \int_0^x \frac\Gamma(a + b)\Gamma(a)\Gamma(b) t^a-1 (1-t)^-1\,dt

Parameters ---------- a : array_like Shape parameter (`a` > 0). p : array_like Cumulative probability, in 0, 1. x : array_like The quantile, in 0, 1.

Returns ------- b : ndarray The value of the shape parameter `b` such that `btdtr(a, b, x) = p`.

See Also -------- btdtr : Cumulative distribution function of the beta distribution. btdtri : Inverse with respect to `x`. btdtria : Inverse with respect to `a`.

Notes ----- Wrapper for the CDFLIB 1_ Fortran routine `cdfbet`.

The cumulative distribution function `p` is computed using a routine by DiDinato and Morris 2_. Computation of `b` involves a search for a value that produces the desired value of `p`. The search relies on the monotonicity of `p` with `b`.

References ---------- .. 1 Barry Brown, James Lovato, and Kathy Russell, CDFLIB: Library of Fortran Routines for Cumulative Distribution Functions, Inverses, and Other Parameters. .. 2 DiDinato, A. R. and Morris, A. H., Algorithm 708: Significant Digit Computation of the Incomplete Beta Function Ratios. ACM Trans. Math. Softw. 18 (1993), 360-373.

cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

cbrt(x)

Element-wise cube root of `x`.

Parameters ---------- x : array_like `x` must contain real numbers.

Returns ------- float The cube root of each value in `x`.

Examples -------- >>> from scipy.special import cbrt

>>> cbrt(8) 2.0 >>> cbrt(-8, -3, 0.125, 1.331) array(-2. , -1.44224957, 0.5 , 1.1 )

chdtr(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chdtr(v, x, out=None)

Chi square cumulative distribution function.

Returns the area under the left tail (from 0 to `x`) of the Chi square probability density function with `v` degrees of freedom:

.. math::

\frac

^

/2} \Gamma(v/2)} \int_0^x t^{v/2 - 1} e^{-t/2} dt

Here :math:`\Gamma` is the Gamma function; see `gamma`. This
integral can be expressed in terms of the regularized lower
incomplete gamma function `gammainc` as
``gammainc(v / 2, x / 2)``. [1]_

Parameters
----------
v : array_like
    Degrees of freedom.
x : array_like
    Upper bound of the integral.
out : ndarray, optional
    Optional output array for the function results.

Returns
-------
scalar or ndarray
    Values of the cumulative distribution function.

See Also
--------
chdtrc, chdtri, chdtriv, gammainc

References
----------
.. [1] Chi-Square distribution,
    https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm

Examples
--------
>>> import scipy.special as sc

It can be expressed in terms of the regularized lower incomplete
gamma function.

>>> v = 1
>>> x = np.arange(4)
>>> sc.chdtr(v, x)
array([0.        , 0.68268949, 0.84270079, 0.91673548])
>>> sc.gammainc(v / 2, x / 2)
array([0.        , 0.68268949, 0.84270079, 0.91673548])

chdtrc(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chdtrc(v, x, out=None)

Chi square survival function.

Returns the area under the right hand tail (from `x` to infinity) of the Chi square probability density function with `v` degrees of freedom:

.. math::

\frac

^

/2} \Gamma(v/2)} \int_x^\infty t^{v/2 - 1} e^{-t/2} dt

Here :math:`\Gamma` is the Gamma function; see `gamma`. This
integral can be expressed in terms of the regularized upper
incomplete gamma function `gammaincc` as
``gammaincc(v / 2, x / 2)``. [1]_

Parameters
----------
v : array_like
    Degrees of freedom.
x : array_like
    Lower bound of the integral.
out : ndarray, optional
    Optional output array for the function results.

Returns
-------
scalar or ndarray
    Values of the survival function.

See Also
--------
chdtr, chdtri, chdtriv, gammaincc

References
----------
.. [1] Chi-Square distribution,
    https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm

Examples
--------
>>> import scipy.special as sc

It can be expressed in terms of the regularized upper incomplete
gamma function.

>>> v = 1
>>> x = np.arange(4)
>>> sc.chdtrc(v, x)
array([1.        , 0.31731051, 0.15729921, 0.08326452])
>>> sc.gammaincc(v / 2, x / 2)
array([1.        , 0.31731051, 0.15729921, 0.08326452])

chdtri(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chdtri(v, p, out=None)

Inverse to `chdtrc` with respect to `x`.

Returns `x` such that ``chdtrc(v, x) == p``.

Parameters ---------- v : array_like Degrees of freedom. p : array_like Probability. out : ndarray, optional Optional output array for the function results.

Returns ------- x : scalar or ndarray Value so that the probability a Chi square random variable with `v` degrees of freedom is greater than `x` equals `p`.

See Also -------- chdtrc, chdtr, chdtriv

References ---------- .. 1 Chi-Square distribution, https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm

Examples -------- >>> import scipy.special as sc

It inverts `chdtrc`.

>>> v, p = 1, 0.3 >>> sc.chdtrc(v, sc.chdtri(v, p)) 0.3 >>> x = 1 >>> sc.chdtri(v, sc.chdtrc(v, x)) 1.0

chdtriv(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chdtriv(p, x, out=None)

Inverse to `chdtr` with respect to `v`.

Returns `v` such that ``chdtr(v, x) == p``.

Parameters ---------- p : array_like Probability that the Chi square random variable is less than or equal to `x`. x : array_like Nonnegative input. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray Degrees of freedom.

See Also -------- chdtr, chdtrc, chdtri

References ---------- .. 1 Chi-Square distribution, https://www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm

Examples -------- >>> import scipy.special as sc

It inverts `chdtr`.

>>> p, x = 0.5, 1 >>> sc.chdtr(sc.chdtriv(p, x), x) 0.5000000000202172 >>> v = 1 >>> sc.chdtriv(sc.chdtr(v, x), v) 1.0000000000000013

chndtr(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chndtr(x, df, nc)

Non-central chi square cumulative distribution function

chndtridf(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chndtridf(x, p, nc)

Inverse to `chndtr` vs `df`

chndtrinc(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chndtrinc(x, df, p)

Inverse to `chndtr` vs `nc`

chndtrix(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

chndtrix(p, df, nc)

Inverse to `chndtr` vs `x`

cosdg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

cosdg(x, out=None)

Cosine of the angle `x` given in degrees.

Parameters ---------- x : array_like Angle, given in degrees. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray Cosine of the input.

See Also -------- sindg, tandg, cotdg

Examples -------- >>> import scipy.special as sc

It is more accurate than using cosine directly.

>>> x = 90 + 180 * np.arange(3) >>> sc.cosdg(x) array(-0., 0., -0.) >>> np.cos(x * np.pi / 180) array( 6.1232340e-17, -1.8369702e-16, 3.0616170e-16)

cosm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

cosm1(x, out=None)

cos(x) - 1 for use when `x` is near zero.

Parameters ---------- x : array_like Real valued argument. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray Values of ``cos(x) - 1``.

See Also -------- expm1, log1p

Examples -------- >>> import scipy.special as sc

It is more accurate than computing ``cos(x) - 1`` directly for ``x`` around 0.

>>> x = 1e-30 >>> np.cos(x) - 1 0.0 >>> sc.cosm1(x) -5.0000000000000005e-61

cotdg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

cotdg(x, out=None)

Cotangent of the angle `x` given in degrees.

Parameters ---------- x : array_like Angle, given in degrees. out : ndarray, optional Optional output array for the function results.

Returns ------- scalar or ndarray Cotangent at the input.

See Also -------- sindg, cosdg, tandg

Examples -------- >>> import scipy.special as sc

It is more accurate than using cotangent directly.

>>> x = 90 + 180 * np.arange(3) >>> sc.cotdg(x) array(0., 0., 0.) >>> 1 / np.tan(x * np.pi / 180) array(6.1232340e-17, 1.8369702e-16, 3.0616170e-16)

dawsn(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

dawsn(x)

Dawson's integral.

Computes::

exp(-x**2) * integral(exp(t**2), t=0..x).

See Also -------- wofz, erf, erfc, erfcx, erfi

References ---------- .. 1 Steven G. Johnson, Faddeeva W function implementation. http://ab-initio.mit.edu/Faddeeva

Examples -------- >>> from scipy import special >>> import matplotlib.pyplot as plt >>> x = np.linspace(-15, 15, num=1000) >>> plt.plot(x, special.dawsn(x)) >>> plt.xlabel('$x$') >>> plt.ylabel('$dawsn(x)$') >>> plt.show()

ellipe(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

ellipe(m)

Complete elliptic integral of the second kind

This function is defined as

.. math:: E(m) = \int_0^\pi/2 1 - m \sin(t)^2^

/2

dt

Parameters ---------- m : array_like Defines the parameter of the elliptic integral.

Returns ------- E : ndarray Value of the elliptic integral.

Notes ----- Wrapper for the Cephes 1_ routine `ellpe`.

For `m > 0` the computation uses the approximation,

.. math:: E(m) \approx P(1-m) - (1-m) \log(1-m) Q(1-m),

where :math:`P` and :math:`Q` are tenth-order polynomials. For `m < 0`, the relation

.. math:: E(m) = E(m/(m - 1)) \sqrt(1-m)

is used.

The parameterization in terms of :math:`m` follows that of section 17.2 in 2_. Other parameterizations in terms of the complementary parameter :math:`1 - m`, modular angle :math:`\sin^2(\alpha) = m`, or modulus :math:`k^2 = m` are also used, so be careful that you choose the correct parameter.

See Also -------- ellipkm1 : Complete elliptic integral of the first kind, near `m` = 1 ellipk : Complete elliptic integral of the first kind ellipkinc : Incomplete elliptic integral of the first kind ellipeinc : Incomplete elliptic integral of the second kind

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/ .. 2 Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

Examples -------- This function is used in finding the circumference of an ellipse with semi-major axis `a` and semi-minor axis `b`.

>>> from scipy import special

>>> a = 3.5 >>> b = 2.1 >>> e_sq = 1.0 - b**2/a**2 # eccentricity squared

Then the circumference is found using the following:

>>> C = 4*a*special.ellipe(e_sq) # circumference formula >>> C 17.868899204378693

When `a` and `b` are the same (meaning eccentricity is 0), this reduces to the circumference of a circle.

>>> 4*a*special.ellipe(0.0) # formula for ellipse with a = b 21.991148575128552 >>> 2*np.pi*a # formula for circle of radius a 21.991148575128552

ellipeinc(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

ellipeinc(phi, m)

Incomplete elliptic integral of the second kind

This function is defined as

.. math:: E(\phi, m) = \int_0^\phi 1 - m \sin(t)^2^

/2

dt

Parameters ---------- phi : array_like amplitude of the elliptic integral.

m : array_like parameter of the elliptic integral.

Returns ------- E : ndarray Value of the elliptic integral.

Notes ----- Wrapper for the Cephes 1_ routine `ellie`.

Computation uses arithmetic-geometric means algorithm.

The parameterization in terms of :math:`m` follows that of section 17.2 in 2_. Other parameterizations in terms of the complementary parameter :math:`1 - m`, modular angle :math:`\sin^2(\alpha) = m`, or modulus :math:`k^2 = m` are also used, so be careful that you choose the correct parameter.

See Also -------- ellipkm1 : Complete elliptic integral of the first kind, near `m` = 1 ellipk : Complete elliptic integral of the first kind ellipkinc : Incomplete elliptic integral of the first kind ellipe : Complete elliptic integral of the second kind

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/ .. 2 Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

ellipj(x1, x2, out1, out2, out3, out4, / , out=(None, None, None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

ellipj(u, m)

Jacobian elliptic functions

Calculates the Jacobian elliptic functions of parameter `m` between 0 and 1, and real argument `u`.

Parameters ---------- m : array_like Parameter. u : array_like Argument.

Returns ------- sn, cn, dn, ph : ndarrays The returned functions::

sn(u|m), cn(u|m), dn(u|m)

The value `ph` is such that if `u = ellipkinc(ph, m)`, then `sn(u|m) = sin(ph)` and `cn(u|m) = cos(ph)`.

Notes ----- Wrapper for the Cephes 1_ routine `ellpj`.

These functions are periodic, with quarter-period on the real axis equal to the complete elliptic integral `ellipk(m)`.

Relation to incomplete elliptic integral: If `u = ellipkinc(phi,m)`, then `sn(u|m) = sin(phi)`, and `cn(u|m) = cos(phi)`. The `phi` is called the amplitude of `u`.

Computation is by means of the arithmetic-geometric mean algorithm, except when `m` is within 1e-9 of 0 or 1. In the latter case with `m` close to 1, the approximation applies only for `phi < pi/2`.

See also -------- ellipk : Complete elliptic integral of the first kind ellipkinc : Incomplete elliptic integral of the first kind

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

ellipk(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

ellipk(m)

Complete elliptic integral of the first kind.

This function is defined as

.. math:: K(m) = \int_0^\pi/2 1 - m \sin(t)^2^

1/2

}

dt

Parameters ---------- m : array_like The parameter of the elliptic integral.

Returns ------- K : array_like Value of the elliptic integral.

Notes ----- For more precision around point m = 1, use `ellipkm1`, which this function calls.

The parameterization in terms of :math:`m` follows that of section 17.2 in 1_. Other parameterizations in terms of the complementary parameter :math:`1 - m`, modular angle :math:`\sin^2(\alpha) = m`, or modulus :math:`k^2 = m` are also used, so be careful that you choose the correct parameter.

See Also -------- ellipkm1 : Complete elliptic integral of the first kind around m = 1 ellipkinc : Incomplete elliptic integral of the first kind ellipe : Complete elliptic integral of the second kind ellipeinc : Incomplete elliptic integral of the second kind

References ---------- .. 1 Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

ellipkinc(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

ellipkinc(phi, m)

Incomplete elliptic integral of the first kind

This function is defined as

.. math:: K(\phi, m) = \int_0^\phi 1 - m \sin(t)^2^

1/2

}

dt

This function is also called `F(phi, m)`.

Parameters ---------- phi : array_like amplitude of the elliptic integral

m : array_like parameter of the elliptic integral

Returns ------- K : ndarray Value of the elliptic integral

Notes ----- Wrapper for the Cephes 1_ routine `ellik`. The computation is carried out using the arithmetic-geometric mean algorithm.

The parameterization in terms of :math:`m` follows that of section 17.2 in 2_. Other parameterizations in terms of the complementary parameter :math:`1 - m`, modular angle :math:`\sin^2(\alpha) = m`, or modulus :math:`k^2 = m` are also used, so be careful that you choose the correct parameter.

See Also -------- ellipkm1 : Complete elliptic integral of the first kind, near `m` = 1 ellipk : Complete elliptic integral of the first kind ellipe : Complete elliptic integral of the second kind ellipeinc : Incomplete elliptic integral of the second kind

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/ .. 2 Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

ellipkm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

ellipkm1(p)

Complete elliptic integral of the first kind around `m` = 1

This function is defined as

.. math:: K(p) = \int_0^\pi/2 1 - m \sin(t)^2^

1/2

}

dt

where `m = 1 - p`.

Parameters ---------- p : array_like Defines the parameter of the elliptic integral as `m = 1 - p`.

Returns ------- K : ndarray Value of the elliptic integral.

Notes ----- Wrapper for the Cephes 1_ routine `ellpk`.

For `p <= 1`, computation uses the approximation,

.. math:: K(p) \approx P(p) - \log(p) Q(p),

where :math:`P` and :math:`Q` are tenth-order polynomials. The argument `p` is used internally rather than `m` so that the logarithmic singularity at `m = 1` will be shifted to the origin; this preserves maximum accuracy. For `p > 1`, the identity

.. math:: K(p) = K(1/p)/\sqrt(p)

is used.

See Also -------- ellipk : Complete elliptic integral of the first kind ellipkinc : Incomplete elliptic integral of the first kind ellipe : Complete elliptic integral of the second kind ellipeinc : Incomplete elliptic integral of the second kind

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

entr(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

entr(x)

Elementwise function for computing entropy.

.. math:: \textntr(x) = \begincases - x \log(x) & x > 0 \\ 0 & x = 0 \\ -\infty & \textotherwise \endcases

Parameters ---------- x : ndarray Input array.

Returns ------- res : ndarray The value of the elementwise entropy function at the given points `x`.

See Also -------- kl_div, rel_entr

Notes ----- This function is concave.

.. versionadded:: 0.15.0

erf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

erf(z)

Returns the error function of complex argument.

It is defined as ``2/sqrt(pi)*integral(exp(-t**2), t=0..z)``.

Parameters ---------- x : ndarray Input array.

Returns ------- res : ndarray The values of the error function at the given points `x`.

See Also -------- erfc, erfinv, erfcinv, wofz, erfcx, erfi

Notes ----- The cumulative of the unit normal distribution is given by ``Phi(z) = 1/21 + erf(z/sqrt(2))``.

References ---------- .. 1 https://en.wikipedia.org/wiki/Error_function .. 2 Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972. http://www.math.sfu.ca/~cbm/aands/page_297.htm .. 3 Steven G. Johnson, Faddeeva W function implementation. http://ab-initio.mit.edu/Faddeeva

Examples -------- >>> from scipy import special >>> import matplotlib.pyplot as plt >>> x = np.linspace(-3, 3) >>> plt.plot(x, special.erf(x)) >>> plt.xlabel('$x$') >>> plt.ylabel('$erf(x)$') >>> plt.show()

erfc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

erfc(x, out=None)

Complementary error function, ``1 - erf(x)``.

Parameters ---------- x : array_like Real or complex valued argument out : ndarray, optional Optional output array for the function results

Returns ------- scalar or ndarray Values of the complementary error function

See Also -------- erf, erfi, erfcx, dawsn, wofz

References ---------- .. 1 Steven G. Johnson, Faddeeva W function implementation. http://ab-initio.mit.edu/Faddeeva

Examples -------- >>> from scipy import special >>> import matplotlib.pyplot as plt >>> x = np.linspace(-3, 3) >>> plt.plot(x, special.erfc(x)) >>> plt.xlabel('$x$') >>> plt.ylabel('$erfc(x)$') >>> plt.show()

erfcinv(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

Inverse of the complementary error function.

Computes the inverse of the complementary error function.

In the complex domain, there is no unique complex number w satisfying erfc(w)=z. This indicates a true inverse function would have multi-value. When the domain restricts to the real, 0 < x < 2, there is a unique real number satisfying erfc(erfcinv(x)) = erfcinv(erfc(x)).

It is related to inverse of the error function by erfcinv(1-x) = erfinv(x)

Parameters ---------- y : ndarray Argument at which to evaluate. Domain: 0, 2

Returns ------- erfcinv : ndarray The inverse of erfc of y, element-wise

See Also -------- erf : Error function of a complex argument erfc : Complementary error function, ``1 - erf(x)`` erfinv : Inverse of the error function

Examples -------- 1) evaluating a float number

>>> from scipy import special >>> special.erfcinv(0.5) 0.4769362762044698

2) evaluating an ndarray

>>> from scipy import special >>> y = np.linspace(0.0, 2.0, num=11) >>> special.erfcinv(y) array( inf, 0.9061938 , 0.59511608, 0.37080716, 0.17914345, -0. , -0.17914345, -0.37080716, -0.59511608, -0.9061938 , -inf)

erfcx(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

erfcx(x, out=None)

Scaled complementary error function, ``exp(x**2) * erfc(x)``.

Parameters ---------- x : array_like Real or complex valued argument out : ndarray, optional Optional output array for the function results

Returns ------- scalar or ndarray Values of the scaled complementary error function

See Also -------- erf, erfc, erfi, dawsn, wofz

Notes -----

.. versionadded:: 0.12.0

References ---------- .. 1 Steven G. Johnson, Faddeeva W function implementation. http://ab-initio.mit.edu/Faddeeva

Examples -------- >>> from scipy import special >>> import matplotlib.pyplot as plt >>> x = np.linspace(-3, 3) >>> plt.plot(x, special.erfcx(x)) >>> plt.xlabel('$x$') >>> plt.ylabel('$erfcx(x)$') >>> plt.show()

erfi(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

erfi(z, out=None)

Imaginary error function, ``-i erf(i z)``.

Parameters ---------- z : array_like Real or complex valued argument out : ndarray, optional Optional output array for the function results

Returns ------- scalar or ndarray Values of the imaginary error function

See Also -------- erf, erfc, erfcx, dawsn, wofz

Notes -----

.. versionadded:: 0.12.0

References ---------- .. 1 Steven G. Johnson, Faddeeva W function implementation. http://ab-initio.mit.edu/Faddeeva

Examples -------- >>> from scipy import special >>> import matplotlib.pyplot as plt >>> x = np.linspace(-3, 3) >>> plt.plot(x, special.erfi(x)) >>> plt.xlabel('$x$') >>> plt.ylabel('$erfi(x)$') >>> plt.show()

erfinv(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

Inverse of the error function.

Computes the inverse of the error function.

In the complex domain, there is no unique complex number w satisfying erf(w)=z. This indicates a true inverse function would have multi-value. When the domain restricts to the real, -1 < x < 1, there is a unique real number satisfying erf(erfinv(x)) = x.

Parameters ---------- y : ndarray Argument at which to evaluate. Domain: -1, 1

Returns ------- erfinv : ndarray The inverse of erf of y, element-wise)

See Also -------- erf : Error function of a complex argument erfc : Complementary error function, ``1 - erf(x)`` erfcinv : Inverse of the complementary error function

Examples -------- 1) evaluating a float number

>>> from scipy import special >>> special.erfinv(0.5) 0.4769362762044698

2) evaluating an ndarray

>>> from scipy import special >>> y = np.linspace(-1.0, 1.0, num=10) >>> special.erfinv(y) array( -inf, -0.86312307, -0.5407314 , -0.30457019, -0.0987901 , 0.0987901 , 0.30457019, 0.5407314 , 0.86312307, inf)

eval_chebyc(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_chebyc(n, x, out=None)

Evaluate Chebyshev polynomial of the first kind on -2, 2 at a point.

These polynomials are defined as

.. math::

C_n(x) = 2 T_n(x/2)

where :math:`T_n` is a Chebyshev polynomial of the first kind. See 22.5.11 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to `eval_chebyt`. x : array_like Points at which to evaluate the Chebyshev polynomial

Returns ------- C : ndarray Values of the Chebyshev polynomial

See Also -------- roots_chebyc : roots and quadrature weights of Chebyshev polynomials of the first kind on -2, 2 chebyc : Chebyshev polynomial object numpy.polynomial.chebyshev.Chebyshev : Chebyshev series eval_chebyt : evaluate Chebycshev polynomials of the first kind

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

Examples -------- >>> import scipy.special as sc

They are a scaled version of the Chebyshev polynomials of the first kind.

>>> x = np.linspace(-2, 2, 6) >>> sc.eval_chebyc(3, x) array(-2. , 1.872, 1.136, -1.136, -1.872, 2. ) >>> 2 * sc.eval_chebyt(3, x / 2) array(-2. , 1.872, 1.136, -1.136, -1.872, 2. )

eval_chebys(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_chebys(n, x, out=None)

Evaluate Chebyshev polynomial of the second kind on -2, 2 at a point.

These polynomials are defined as

.. math::

S_n(x) = U_n(x/2)

where :math:`U_n` is a Chebyshev polynomial of the second kind. See 22.5.13 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to `eval_chebyu`. x : array_like Points at which to evaluate the Chebyshev polynomial

Returns ------- S : ndarray Values of the Chebyshev polynomial

See Also -------- roots_chebys : roots and quadrature weights of Chebyshev polynomials of the second kind on -2, 2 chebys : Chebyshev polynomial object eval_chebyu : evaluate Chebyshev polynomials of the second kind

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

Examples -------- >>> import scipy.special as sc

They are a scaled version of the Chebyshev polynomials of the second kind.

>>> x = np.linspace(-2, 2, 6) >>> sc.eval_chebys(3, x) array(-4. , 0.672, 0.736, -0.736, -0.672, 4. ) >>> sc.eval_chebyu(3, x / 2) array(-4. , 0.672, 0.736, -0.736, -0.672, 4. )

eval_chebyt(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_chebyt(n, x, out=None)

Evaluate Chebyshev polynomial of the first kind at a point.

The Chebyshev polynomials of the first kind can be defined via the Gauss hypergeometric function :math:`{

}

_2F_1` as

.. math::

T_n(x) = {

}

_2F_1(n, -n; 1/2; (1 - x)/2).

When :math:`n` is an integer the result is a polynomial of degree :math:`n`. See 22.5.47 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to the Gauss hypergeometric function. x : array_like Points at which to evaluate the Chebyshev polynomial

Returns ------- T : ndarray Values of the Chebyshev polynomial

See Also -------- roots_chebyt : roots and quadrature weights of Chebyshev polynomials of the first kind chebyu : Chebychev polynomial object eval_chebyu : evaluate Chebyshev polynomials of the second kind hyp2f1 : Gauss hypergeometric function numpy.polynomial.chebyshev.Chebyshev : Chebyshev series

Notes ----- This routine is numerically stable for `x` in ``-1, 1`` at least up to order ``10000``.

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_chebyu(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_chebyu(n, x, out=None)

Evaluate Chebyshev polynomial of the second kind at a point.

The Chebyshev polynomials of the second kind can be defined via the Gauss hypergeometric function :math:`{

}

_2F_1` as

.. math::

U_n(x) = (n + 1) {

}

_2F_1(-n, n + 2; 3/2; (1 - x)/2).

When :math:`n` is an integer the result is a polynomial of degree :math:`n`. See 22.5.48 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to the Gauss hypergeometric function. x : array_like Points at which to evaluate the Chebyshev polynomial

Returns ------- U : ndarray Values of the Chebyshev polynomial

See Also -------- roots_chebyu : roots and quadrature weights of Chebyshev polynomials of the second kind chebyu : Chebyshev polynomial object eval_chebyt : evaluate Chebyshev polynomials of the first kind hyp2f1 : Gauss hypergeometric function

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_gegenbauer(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_gegenbauer(n, alpha, x, out=None)

Evaluate Gegenbauer polynomial at a point.

The Gegenbauer polynomials can be defined via the Gauss hypergeometric function :math:`{

}

_2F_1` as

.. math::

C_n^(\alpha) = \frac(2\alpha)_n\Gamma(n + 1) {

}

_2F_1(-n, 2\alpha + n; \alpha + 1/2; (1 - z)/2).

When :math:`n` is an integer the result is a polynomial of degree :math:`n`. See 22.5.46 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to the Gauss hypergeometric function. alpha : array_like Parameter x : array_like Points at which to evaluate the Gegenbauer polynomial

Returns ------- C : ndarray Values of the Gegenbauer polynomial

See Also -------- roots_gegenbauer : roots and quadrature weights of Gegenbauer polynomials gegenbauer : Gegenbauer polynomial object hyp2f1 : Gauss hypergeometric function

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_genlaguerre(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_genlaguerre(n, alpha, x, out=None)

Evaluate generalized Laguerre polynomial at a point.

The generalized Laguerre polynomials can be defined via the confluent hypergeometric function :math:`{

}

_1F_1` as

.. math::

L_n^(\alpha)(x) = \binomn + \alphan {

}

_1F_1(-n, \alpha + 1, x).

When :math:`n` is an integer the result is a polynomial of degree :math:`n`. See 22.5.54 in AS_ for details. The Laguerre polynomials are the special case where :math:`\alpha = 0`.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to the confluent hypergeometric function. alpha : array_like Parameter; must have ``alpha > -1`` x : array_like Points at which to evaluate the generalized Laguerre polynomial

Returns ------- L : ndarray Values of the generalized Laguerre polynomial

See Also -------- roots_genlaguerre : roots and quadrature weights of generalized Laguerre polynomials genlaguerre : generalized Laguerre polynomial object hyp1f1 : confluent hypergeometric function eval_laguerre : evaluate Laguerre polynomials

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_hermite(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_hermite(n, x, out=None)

Evaluate physicist's Hermite polynomial at a point.

Defined by

.. math::

H_n(x) = (-1)^n e^x^2 \fracd^ndx^n e^

x^2

}

;

:math:`H_n` is a polynomial of degree :math:`n`. See 22.11.7 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial x : array_like Points at which to evaluate the Hermite polynomial

Returns ------- H : ndarray Values of the Hermite polynomial

See Also -------- roots_hermite : roots and quadrature weights of physicist's Hermite polynomials hermite : physicist's Hermite polynomial object numpy.polynomial.hermite.Hermite : Physicist's Hermite series eval_hermitenorm : evaluate Probabilist's Hermite polynomials

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_hermitenorm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_hermitenorm(n, x, out=None)

Evaluate probabilist's (normalized) Hermite polynomial at a point.

Defined by

.. math::

He_n(x) = (-1)^n e^x^2/2 \fracd^ndx^n e^

x^2/2

}

;

:math:`He_n` is a polynomial of degree :math:`n`. See 22.11.8 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial x : array_like Points at which to evaluate the Hermite polynomial

Returns ------- He : ndarray Values of the Hermite polynomial

See Also -------- roots_hermitenorm : roots and quadrature weights of probabilist's Hermite polynomials hermitenorm : probabilist's Hermite polynomial object numpy.polynomial.hermite_e.HermiteE : Probabilist's Hermite series eval_hermite : evaluate physicist's Hermite polynomials

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_jacobi(x1, x2, x3, x4, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_jacobi(n, alpha, beta, x, out=None)

Evaluate Jacobi polynomial at a point.

The Jacobi polynomials can be defined via the Gauss hypergeometric function :math:`{

}

_2F_1` as

.. math::

P_n^(\alpha, \beta)(x) = \frac(\alpha + 1)_n\Gamma(n + 1) {

}

_2F_1(-n, 1 + \alpha + \beta + n; \alpha + 1; (1 - z)/2)

where :math:`(\cdot)_n` is the Pochhammer symbol; see `poch`. When :math:`n` is an integer the result is a polynomial of degree :math:`n`. See 22.5.42 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer the result is determined via the relation to the Gauss hypergeometric function. alpha : array_like Parameter beta : array_like Parameter x : array_like Points at which to evaluate the polynomial

Returns ------- P : ndarray Values of the Jacobi polynomial

See Also -------- roots_jacobi : roots and quadrature weights of Jacobi polynomials jacobi : Jacobi polynomial object hyp2f1 : Gauss hypergeometric function

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_laguerre(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_laguerre(n, x, out=None)

Evaluate Laguerre polynomial at a point.

The Laguerre polynomials can be defined via the confluent hypergeometric function :math:`{

}

_1F_1` as

.. math::

L_n(x) = {

}

_1F_1(-n, 1, x).

See 22.5.16 and 22.5.54 in AS_ for details. When :math:`n` is an integer the result is a polynomial of degree :math:`n`.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer the result is determined via the relation to the confluent hypergeometric function. x : array_like Points at which to evaluate the Laguerre polynomial

Returns ------- L : ndarray Values of the Laguerre polynomial

See Also -------- roots_laguerre : roots and quadrature weights of Laguerre polynomials laguerre : Laguerre polynomial object numpy.polynomial.laguerre.Laguerre : Laguerre series eval_genlaguerre : evaluate generalized Laguerre polynomials

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_legendre(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_legendre(n, x, out=None)

Evaluate Legendre polynomial at a point.

The Legendre polynomials can be defined via the Gauss hypergeometric function :math:`{

}

_2F_1` as

.. math::

P_n(x) = {

}

_2F_1(-n, n + 1; 1; (1 - x)/2).

When :math:`n` is an integer the result is a polynomial of degree :math:`n`. See 22.5.49 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to the Gauss hypergeometric function. x : array_like Points at which to evaluate the Legendre polynomial

Returns ------- P : ndarray Values of the Legendre polynomial

See Also -------- roots_legendre : roots and quadrature weights of Legendre polynomials legendre : Legendre polynomial object hyp2f1 : Gauss hypergeometric function numpy.polynomial.legendre.Legendre : Legendre series

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_sh_chebyt(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_sh_chebyt(n, x, out=None)

Evaluate shifted Chebyshev polynomial of the first kind at a point.

These polynomials are defined as

.. math::

T_n^*(x) = T_n(2x - 1)

where :math:`T_n` is a Chebyshev polynomial of the first kind. See 22.5.14 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to `eval_chebyt`. x : array_like Points at which to evaluate the shifted Chebyshev polynomial

Returns ------- T : ndarray Values of the shifted Chebyshev polynomial

See Also -------- roots_sh_chebyt : roots and quadrature weights of shifted Chebyshev polynomials of the first kind sh_chebyt : shifted Chebyshev polynomial object eval_chebyt : evaluate Chebyshev polynomials of the first kind numpy.polynomial.chebyshev.Chebyshev : Chebyshev series

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_sh_chebyu(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_sh_chebyu(n, x, out=None)

Evaluate shifted Chebyshev polynomial of the second kind at a point.

These polynomials are defined as

.. math::

U_n^*(x) = U_n(2x - 1)

where :math:`U_n` is a Chebyshev polynomial of the first kind. See 22.5.15 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the result is determined via the relation to `eval_chebyu`. x : array_like Points at which to evaluate the shifted Chebyshev polynomial

Returns ------- U : ndarray Values of the shifted Chebyshev polynomial

See Also -------- roots_sh_chebyu : roots and quadrature weights of shifted Chebychev polynomials of the second kind sh_chebyu : shifted Chebyshev polynomial object eval_chebyu : evaluate Chebyshev polynomials of the second kind

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_sh_jacobi(x1, x2, x3, x4, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_sh_jacobi(n, p, q, x, out=None)

Evaluate shifted Jacobi polynomial at a point.

Defined by

.. math::

G_n^(p, q)(x) = \binom

n + p - 1

n^

1

}

P_n^(p - q, q - 1)(2x - 1),

where :math:`P_n^(\cdot, \cdot)` is the n-th Jacobi polynomial. See 22.5.2 in AS_ for details.

Parameters ---------- n : int Degree of the polynomial. If not an integer, the result is determined via the relation to `binom` and `eval_jacobi`. p : float Parameter q : float Parameter

Returns ------- G : ndarray Values of the shifted Jacobi polynomial.

See Also -------- roots_sh_jacobi : roots and quadrature weights of shifted Jacobi polynomials sh_jacobi : shifted Jacobi polynomial object eval_jacobi : evaluate Jacobi polynomials

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

eval_sh_legendre(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

eval_sh_legendre(n, x, out=None)

Evaluate shifted Legendre polynomial at a point.

These polynomials are defined as

.. math::

P_n^*(x) = P_n(2x - 1)

where :math:`P_n` is a Legendre polynomial. See 2.2.11 in AS_ for details.

Parameters ---------- n : array_like Degree of the polynomial. If not an integer, the value is determined via the relation to `eval_legendre`. x : array_like Points at which to evaluate the shifted Legendre polynomial

Returns ------- P : ndarray Values of the shifted Legendre polynomial

See Also -------- roots_sh_legendre : roots and quadrature weights of shifted Legendre polynomials sh_legendre : shifted Legendre polynomial object eval_legendre : evaluate Legendre polynomials numpy.polynomial.legendre.Legendre : Legendre series

References ---------- .. AS Milton Abramowitz and Irene A. Stegun, eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

exp1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

exp1(z, out=None)

Exponential integral E1.

For complex :math:`z \ne 0` the exponential integral can be defined as 1_

.. math::

E_1(z) = \int_z^\infty \frac^

t

}

}

dt,

where the path of the integral does not cross the negative real axis or pass through the origin.

Parameters ---------- z: array_like Real or complex argument. out: ndarray, optional Optional output array for the function results

Returns ------- scalar or ndarray Values of the exponential integral E1

See Also -------- expi : exponential integral :math:`Ei` expn : generalization of :math:`E_1`

Notes ----- For :math:`x > 0` it is related to the exponential integral :math:`Ei` (see `expi`) via the relation

.. math::

E_1(x) = -Ei(-x).

References ---------- .. 1 Digital Library of Mathematical Functions, 6.2.1 https://dlmf.nist.gov/6.2#E1

Examples -------- >>> import scipy.special as sc

It has a pole at 0.

>>> sc.exp1(0) inf

It has a branch cut on the negative real axis.

>>> sc.exp1(-1) nan >>> sc.exp1(complex(-1, 0)) (-1.8951178163559368-3.141592653589793j) >>> sc.exp1(complex(-1, -0.0)) (-1.8951178163559368+3.141592653589793j)

It approaches 0 along the positive real axis.

>>> sc.exp1(1, 10, 100, 1000) array(2.19383934e-01, 4.15696893e-06, 3.68359776e-46, 0.00000000e+00)

It is related to `expi`.

>>> x = np.array(1, 2, 3, 4) >>> sc.exp1(x) array(0.21938393, 0.04890051, 0.01304838, 0.00377935) >>> -sc.expi(-x) array(0.21938393, 0.04890051, 0.01304838, 0.00377935)

exp10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

exp10(x)

Compute ``10**x`` element-wise.

Parameters ---------- x : array_like `x` must contain real numbers.

Returns ------- float ``10**x``, computed element-wise.

Examples -------- >>> from scipy.special import exp10

>>> exp10(3) 1000.0 >>> x = np.array([-1, -0.5, 0], [0.5, 1, 1.5]) >>> exp10(x) array([ 0.1 , 0.31622777, 1. ], [ 3.16227766, 10. , 31.6227766 ])

exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

exp2(x)

Compute ``2**x`` element-wise.

Parameters ---------- x : array_like `x` must contain real numbers.

Returns ------- float ``2**x``, computed element-wise.

Examples -------- >>> from scipy.special import exp2

>>> exp2(3) 8.0 >>> x = np.array([-1, -0.5, 0], [0.5, 1, 1.5]) >>> exp2(x) array([ 0.5 , 0.70710678, 1. ], [ 1.41421356, 2. , 2.82842712])

expi(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

expi(x, out=None)

Exponential integral Ei.

For real :math:`x`, the exponential integral is defined as 1_

.. math::

Ei(x) = \int_

\infty

}

^x \frac^t

dt.

For :math:`x > 0` the integral is understood as a Cauchy principle value.

It is extended to the complex plane by analytic continuation of the function on the interval :math:`(0, \infty)`. The complex variant has a branch cut on the negative real axis.

Parameters ---------- x: array_like Real or complex valued argument out: ndarray, optional Optional output array for the function results

Returns ------- scalar or ndarray Values of the exponential integral

Notes ----- The exponential integrals :math:`E_1` and :math:`Ei` satisfy the relation

.. math::

E_1(x) = -Ei(-x)

for :math:`x > 0`.

See Also -------- exp1 : Exponential integral :math:`E_1` expn : Generalized exponential integral :math:`E_n`

References ---------- .. 1 Digital Library of Mathematical Functions, 6.2.5 https://dlmf.nist.gov/6.2#E5

Examples -------- >>> import scipy.special as sc

It is related to `exp1`.

>>> x = np.array(1, 2, 3, 4) >>> -sc.expi(-x) array(0.21938393, 0.04890051, 0.01304838, 0.00377935) >>> sc.exp1(x) array(0.21938393, 0.04890051, 0.01304838, 0.00377935)

The complex variant has a branch cut on the negative real axis.

>>> import scipy.special as sc >>> sc.expi(-1 + 1e-12j) (-0.21938393439552062+3.1415926535894254j) >>> sc.expi(-1 - 1e-12j) (-0.21938393439552062-3.1415926535894254j)

As the complex variant approaches the branch cut, the real parts approach the value of the real variant.

>>> sc.expi(-1) -0.21938393439552062

The SciPy implementation returns the real variant for complex values on the branch cut.

>>> sc.expi(complex(-1, 0.0)) (-0.21938393439552062-0j) >>> sc.expi(complex(-1, -0.0)) (-0.21938393439552062-0j)

expit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

expit(x)

Expit (a.k.a. logistic sigmoid) ufunc for ndarrays.

The expit function, also known as the logistic sigmoid function, is defined as ``expit(x) = 1/(1+exp(-x))``. It is the inverse of the logit function.

Parameters ---------- x : ndarray The ndarray to apply expit to element-wise.

Returns ------- out : ndarray An ndarray of the same shape as x. Its entries are `expit` of the corresponding entry of x.

See Also -------- logit

Notes ----- As a ufunc expit takes a number of optional keyword arguments. For more information see `ufuncs <https://docs.scipy.org/doc/numpy/reference/ufuncs.html>`_

.. versionadded:: 0.10.0

Examples -------- >>> from scipy.special import expit, logit

>>> expit(-np.inf, -1.5, 0, 1.5, np.inf) array( 0. , 0.18242552, 0.5 , 0.81757448, 1. )

`logit` is the inverse of `expit`:

>>> logit(expit(-2.5, 0, 3.1, 5.0)) array(-2.5, 0. , 3.1, 5. )

Plot expit(x) for x in -6, 6:

>>> import matplotlib.pyplot as plt >>> x = np.linspace(-6, 6, 121) >>> y = expit(x) >>> plt.plot(x, y) >>> plt.grid() >>> plt.xlim(-6, 6) >>> plt.xlabel('x') >>> plt.title('expit(x)') >>> plt.show()

expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

expm1(x)

Compute ``exp(x) - 1``.

When `x` is near zero, ``exp(x)`` is near 1, so the numerical calculation of ``exp(x) - 1`` can suffer from catastrophic loss of precision. ``expm1(x)`` is implemented to avoid the loss of precision that occurs when `x` is near zero.

Parameters ---------- x : array_like `x` must contain real numbers.

Returns ------- float ``exp(x) - 1`` computed element-wise.

Examples -------- >>> from scipy.special import expm1

>>> expm1(1.0) 1.7182818284590451 >>> expm1(-0.2, -0.1, 0, 0.1, 0.2) array(-0.18126925, -0.09516258, 0. , 0.10517092, 0.22140276)

The exact value of ``exp(7.5e-13) - 1`` is::

7.5000000000028125000000007031250000001318...*10**-13.

Here is what ``expm1(7.5e-13)`` gives:

>>> expm1(7.5e-13) 7.5000000000028135e-13

Compare that to ``exp(7.5e-13) - 1``, where the subtraction results in a 'catastrophic' loss of precision:

>>> np.exp(7.5e-13) - 1 7.5006667543675576e-13

expn(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

expn(n, x, out=None)

Generalized exponential integral En.

For integer :math:`n \geq 0` and real :math:`x \geq 0` the generalized exponential integral is defined as dlmf_

.. math::

E_n(x) = x^n - 1 \int_x^\infty \frac^

t

}

}

dt.

Parameters ---------- n: array_like Non-negative integers x: array_like Real argument out: ndarray, optional Optional output array for the function results

Returns ------- scalar or ndarray Values of the generalized exponential integral

See Also -------- exp1 : special case of :math:`E_n` for :math:`n = 1` expi : related to :math:`E_n` when :math:`n = 1`

References ---------- .. dlmf Digital Library of Mathematical Functions, 8.19.2 https://dlmf.nist.gov/8.19#E2

Examples -------- >>> import scipy.special as sc

Its domain is nonnegative n and x.

>>> sc.expn(-1, 1.0), sc.expn(1, -1.0) (nan, nan)

It has a pole at ``x = 0`` for ``n = 1, 2``; for larger ``n`` it is equal to ``1 / (n - 1)``.

>>> sc.expn(0, 1, 2, 3, 4, 0) array( inf, inf, 1. , 0.5 , 0.33333333)

For n equal to 0 it reduces to ``exp(-x) / x``.

>>> x = np.array(1, 2, 3, 4) >>> sc.expn(0, x) array(0.36787944, 0.06766764, 0.01659569, 0.00457891) >>> np.exp(-x) / x array(0.36787944, 0.06766764, 0.01659569, 0.00457891)

For n equal to 1 it reduces to `exp1`.

>>> sc.expn(1, x) array(0.21938393, 0.04890051, 0.01304838, 0.00377935) >>> sc.exp1(x) array(0.21938393, 0.04890051, 0.01304838, 0.00377935)

exprel(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

exprel(x)

Relative error exponential, ``(exp(x) - 1)/x``.

When `x` is near zero, ``exp(x)`` is near 1, so the numerical calculation of ``exp(x) - 1`` can suffer from catastrophic loss of precision. ``exprel(x)`` is implemented to avoid the loss of precision that occurs when `x` is near zero.

Parameters ---------- x : ndarray Input array. `x` must contain real numbers.

Returns ------- float ``(exp(x) - 1)/x``, computed element-wise.

See Also -------- expm1

Notes ----- .. versionadded:: 0.17.0

Examples -------- >>> from scipy.special import exprel

>>> exprel(0.01) 1.0050167084168056 >>> exprel(-0.25, -0.1, 0, 0.1, 0.25) array( 0.88479687, 0.95162582, 1. , 1.05170918, 1.13610167)

Compare ``exprel(5e-9)`` to the naive calculation. The exact value is ``1.00000000250000000416...``.

>>> exprel(5e-9) 1.0000000025

>>> (np.exp(5e-9) - 1)/5e-9 0.99999999392252903

fdtr(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

fdtr(dfn, dfd, x)

F cumulative distribution function.

Returns the value of the cumulative distribution function of the F-distribution, also known as Snedecor's F-distribution or the Fisher-Snedecor distribution.

The F-distribution with parameters :math:`d_n` and :math:`d_d` is the distribution of the random variable,

.. math:: X = \fracU_n/d_nU_d/d_d,

where :math:`U_n` and :math:`U_d` are random variables distributed :math:`\chi^2`, with :math:`d_n` and :math:`d_d` degrees of freedom, respectively.

Parameters ---------- dfn : array_like First parameter (positive float). dfd : array_like Second parameter (positive float). x : array_like Argument (nonnegative float).

Returns ------- y : ndarray The CDF of the F-distribution with parameters `dfn` and `dfd` at `x`.

Notes ----- The regularized incomplete beta function is used, according to the formula,

.. math:: F(d_n, d_d; x) = I_xd_n/(d_d + xd_n)(d_n/2, d_d/2).

Wrapper for the Cephes 1_ routine `fdtr`.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

fdtrc(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

fdtrc(dfn, dfd, x)

F survival function.

Returns the complemented F-distribution function (the integral of the density from `x` to infinity).

Parameters ---------- dfn : array_like First parameter (positive float). dfd : array_like Second parameter (positive float). x : array_like Argument (nonnegative float).

Returns ------- y : ndarray The complemented F-distribution function with parameters `dfn` and `dfd` at `x`.

See also -------- fdtr

Notes ----- The regularized incomplete beta function is used, according to the formula,

.. math:: F(d_n, d_d; x) = I_d_d/(d_d + xd_n)(d_d/2, d_n/2).

Wrapper for the Cephes 1_ routine `fdtrc`.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

fdtri(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

fdtri(dfn, dfd, p)

The `p`-th quantile of the F-distribution.

This function is the inverse of the F-distribution CDF, `fdtr`, returning the `x` such that `fdtr(dfn, dfd, x) = p`.

Parameters ---------- dfn : array_like First parameter (positive float). dfd : array_like Second parameter (positive float). p : array_like Cumulative probability, in 0, 1.

Returns ------- x : ndarray The quantile corresponding to `p`.

Notes ----- The computation is carried out using the relation to the inverse regularized beta function, :math:`I^

1

}

_x(a, b)`. Let :math:`z = I^

1

}

_p(d_d/2, d_n/2).` Then,

.. math:: x = \fracd_d (1 - z)d_n z.

If `p` is such that :math:`x < 0.5`, the following relation is used instead for improved stability: let :math:`z' = I^

1

}

_

- p

(d_n/2, d_d/2).` Then,

.. math:: x = \fracd_d z'd_n (1 - z').

Wrapper for the Cephes 1_ routine `fdtri`.

References ---------- .. 1 Cephes Mathematical Functions Library, http://www.netlib.org/cephes/

fdtridfd(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

fdtridfd(dfn, p, x)

Inverse to `fdtr` vs dfd

Finds the F density argument dfd such that ``fdtr(dfn, dfd, x) == p``.

fresnel(x, out1, out2, / , out=(None, None), *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

fresnel(z, out=None)

Fresnel integrals.

The Fresnel integrals are defined as

.. math::

S(z) &= \int_0^z \sin(\pi t^2 /2) dt \\ C(z) &= \int_0^z \cos(\pi t^2 /2) dt.

See dlmf_ for details.

Parameters ---------- z : array_like Real or complex valued argument out : 2-tuple of ndarrays, optional Optional output arrays for the function results

Returns ------- S, C : 2-tuple of scalar or ndarray Values of the Fresnel integrals

See Also -------- fresnel_zeros : zeros of the Fresnel integrals

References ---------- .. dlmf NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/7.2#iii

Examples -------- >>> import scipy.special as sc

As z goes to infinity along the real axis, S and C converge to 0.5.

>>> S, C = sc.fresnel(0.1, 1, 10, 100, np.inf) >>> S array(0.00052359, 0.43825915, 0.46816998, 0.4968169 , 0.5 ) >>> C array(0.09999753, 0.7798934 , 0.49989869, 0.4999999 , 0.5 )

They are related to the error function `erf`.

>>> z = np.array(1, 2, 3, 4) >>> zeta = 0.5 * np.sqrt(np.pi) * (1 - 1j) * z >>> S, C = sc.fresnel(z) >>> C + 1j*S array(0.7798934 +0.43825915j, 0.48825341+0.34341568j, 0.60572079+0.496313j , 0.49842603+0.42051575j) >>> 0.5 * (1 + 1j) * sc.erf(zeta) array(0.7798934 +0.43825915j, 0.48825341+0.34341568j, 0.60572079+0.496313j , 0.49842603+0.42051575j)

gamma(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

gamma(z)

gamma function.

The gamma function is defined as

.. math::

\Gamma(z) = \int_0^\infty t^z-1 e^

t

}

dt

for :math:`\Re(z) > 0` and is extended to the rest of the complex plane by analytic continuation. See dlmf_ for more details.

Parameters ---------- z : array_like Real or complex valued argument

Returns ------- scalar or ndarray Values of the gamma function

Notes ----- The gamma function is often referred to as the generalized factorial since :math:`\Gamma(n + 1) = n!` for natural numbers :math:`n`. More generally it satisfies the recurrence relation :math:`\Gamma(z + 1) = z \cdot \Gamma(z)` for complex :math:`z`, which, combined with the fact that :math:`\Gamma(1) = 1`, implies the above identity for :math:`z = n`.

References ---------- .. dlmf NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/5.2#E1

Examples -------- >>> from scipy.special import gamma, factorial

>>> gamma(0, 0.5, 1, 5) array( inf, 1.77245385, 1. , 24. )

>>> z = 2.5 + 1j >>> gamma(z) (0.77476210455108352+0.70763120437959293j) >>> gamma(z+1), z*gamma(z) # Recurrence property ((1.2292740569981171+2.5438401155000685j), (1.2292740569981158+2.5438401155000658j))

>>> gamma(0.5)**2 # gamma(0.5) = sqrt(pi) 3.1415926535897927

Plot gamma(x) for real x

>>> x = np.linspace(-3.5, 5.5, 2251) >>> y = gamma(x)

>>> import matplotlib.pyplot as plt >>> plt.plot(x, y, 'b', alpha=0.6, label='gamma(x)') >>> k = np.arange(1, 7) >>> plt.plot(k, factorial(k-1), 'k*', alpha=0.6, ... label='(x-1)!, x = 1, 2, ...') >>> plt.xlim(-3.5, 5.5) >>> plt.ylim(-10, 25) >>> plt.grid() >>> plt.xlabel('x') >>> plt.legend(loc='lower right') >>> plt.show()

gammainc(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

gammainc(a, x)

Regularized lower incomplete gamma function.

It is defined as

.. math::

P(a, x) = \frac

\Gamma(a) \int_0^x t^a - 1e^

t

}

dt

for :math:`a > 0` and :math:`x \geq 0`. See dlmf_ for details.

Parameters ---------- a : array_like Positive parameter x : array_like Nonnegative argument

Returns ------- scalar or ndarray Values of the lower incomplete gamma function

Notes ----- The function satisfies the relation ``gammainc(a, x) + gammaincc(a, x) = 1`` where `gammaincc` is the regularized upper incomplete gamma function.

The implementation largely follows that of boost_.

See also -------- gammaincc : regularized upper incomplete gamma function gammaincinv : inverse of the regularized lower incomplete gamma function with respect to `x` gammainccinv : inverse of the regularized upper incomplete gamma function with respect to `x`

References ---------- .. dlmf NIST Digital Library of Mathematical functions https://dlmf.nist.gov/8.2#E4 .. boost Maddock et. al., 'Incomplete Gamma Functions', https://www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/sf_gamma/igamma.html

Examples -------- >>> import scipy.special as sc

It is the CDF of the gamma distribution, so it starts at 0 and monotonically increases to 1.

>>> sc.gammainc(0.5, 0, 1, 10, 100) array(0. , 0.84270079, 0.99999226, 1. )

It is equal to one minus the upper incomplete gamma function.

>>> a, x = 0.5, 0.4 >>> sc.gammainc(a, x) 0.6289066304773024 >>> 1 - sc.gammaincc(a, x) 0.6289066304773024

gammaincc(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

gammaincc(a, x)

Regularized upper incomplete gamma function.

It is defined as

.. math::

Q(a, x) = \frac

\Gamma(a) \int_x^\infty t^a - 1e^

t

}

dt

for :math:`a > 0` and :math:`x \geq 0`. See dlmf_ for details.

Parameters ---------- a : array_like Positive parameter x : array_like Nonnegative argument

Returns ------- scalar or ndarray Values of the upper incomplete gamma function

Notes ----- The function satisfies the relation ``gammainc(a, x) + gammaincc(a, x) = 1`` where `gammainc` is the regularized lower incomplete gamma function.

The implementation largely follows that of boost_.

See also -------- gammainc : regularized lower incomplete gamma function gammaincinv : inverse of the regularized lower incomplete gamma function with respect to `x` gammainccinv : inverse to of the regularized upper incomplete gamma function with respect to `x`

References ---------- .. dlmf NIST Digital Library of Mathematical functions https://dlmf.nist.gov/8.2#E4 .. boost Maddock et. al., 'Incomplete Gamma Functions', https://www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/sf_gamma/igamma.html

Examples -------- >>> import scipy.special as sc

It is the survival function of the gamma distribution, so it starts at 1 and monotonically decreases to 0.

>>> sc.gammaincc(0.5, 0, 1, 10, 100, 1000) array(1.00000000e+00, 1.57299207e-01, 7.74421643e-06, 2.08848758e-45, 0.00000000e+00)

It is equal to one minus the lower incomplete gamma function.

>>> a, x = 0.5, 0.4 >>> sc.gammaincc(a, x) 0.37109336952269756 >>> 1 - sc.gammainc(a, x) 0.37109336952269756

gammainccinv(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

gammainccinv(a, y)

Inverse of the upper incomplete gamma function with respect to `x`

Given an input :math:`y` between 0 and 1, returns :math:`x` such that :math:`y = Q(a, x)`. Here :math:`Q` is the upper incomplete gamma function; see `gammaincc`. This is well-defined because the upper incomplete gamma function is monotonic as can be seen from its definition in dlmf_.

Parameters ---------- a : array_like Positive parameter y : array_like Argument between 0 and 1, inclusive

Returns ------- scalar or ndarray Values of the inverse of the upper incomplete gamma function

See Also -------- gammaincc : regularized upper incomplete gamma function gammainc : regularized lower incomplete gamma function gammaincinv : inverse of the regularized lower incomplete gamma function with respect to `x`

References ---------- .. dlmf NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/8.2#E4

Examples -------- >>> import scipy.special as sc

It starts at infinity and monotonically decreases to 0.

>>> sc.gammainccinv(0.5, 0, 0.1, 0.5, 1) array( inf, 1.35277173, 0.22746821, 0. )

It inverts the upper incomplete gamma function.

>>> a, x = 0.5, 0, 0.1, 0.5, 1 >>> sc.gammaincc(a, sc.gammainccinv(a, x)) array(0. , 0.1, 0.5, 1. )

>>> a, x = 0.5, 0, 10, 50 >>> sc.gammainccinv(a, sc.gammaincc(a, x)) array( 0., 10., 50.)

gammaincinv(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

gammaincinv(a, y)

Inverse to the lower incomplete gamma function with respect to `x`.

Given an input :math:`y` between 0 and 1, returns :math:`x` such that :math:`y = P(a, x)`. Here :math:`P` is the regularized lower incomplete gamma function; see `gammainc`. This is well-defined because the lower incomplete gamma function is monotonic as can be seen from its definition in dlmf_.

Parameters ---------- a : array_like Positive parameter y : array_like Parameter between 0 and 1, inclusive

Returns ------- scalar or ndarray Values of the inverse of the lower incomplete gamma function

See Also -------- gammainc : regularized lower incomplete gamma function gammaincc : regularized upper incomplete gamma function gammainccinv : inverse of the regualizred upper incomplete gamma function with respect to `x`

References ---------- .. dlmf NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/8.2#E4

Examples -------- >>> import scipy.special as sc

It starts at 0 and monotonically increases to infinity.

>>> sc.gammaincinv(0.5, 0, 0.1 ,0.5, 1) array(0. , 0.00789539, 0.22746821, inf)

It inverts the lower incomplete gamma function.

>>> a, x = 0.5, 0, 0.1, 0.5, 1 >>> sc.gammainc(a, sc.gammaincinv(a, x)) array(0. , 0.1, 0.5, 1. )

>>> a, x = 0.5, 0, 10, 25 >>> sc.gammaincinv(a, sc.gammainc(a, x)) array( 0. , 10. , 25.00001465)

gammaln(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

gammaln(x, out=None)

Logarithm of the absolute value of the gamma function.

Defined as

.. math::

\ln(\lvert\Gamma(x)\rvert)

where :math:`\Gamma` is the gamma function. For more details on the gamma function, see dlmf_.

Parameters ---------- x : array_like Real argument out : ndarray, optional Optional output array for the function results

Returns ------- scalar or ndarray Values of the log of the absolute value of gamma

See Also -------- gammasgn : sign of the gamma function loggamma : principal branch of the logarithm of the gamma function

Notes ----- It is the same function as the Python standard library function :func:`math.lgamma`.

When used in conjunction with `gammasgn`, this function is useful for working in logspace on the real axis without having to deal with complex numbers via the relation ``exp(gammaln(x)) = gammasgn(x) * gamma(x)``.

For complex-valued log-gamma, use `loggamma` instead of `gammaln`.

References ---------- .. dlmf NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/5

Examples -------- >>> import scipy.special as sc

It has two positive zeros.

>>> sc.gammaln(1, 2) array(0., 0.)

It has poles at nonpositive integers.

>>> sc.gammaln(0, -1, -2, -3, -4) array(inf, inf, inf, inf, inf)

It asymptotically approaches ``x * log(x)`` (Stirling's formula).

>>> x = np.array(1e10, 1e20, 1e40, 1e80) >>> sc.gammaln(x) array(2.20258509e+11, 4.50517019e+21, 9.11034037e+41, 1.83206807e+82) >>> x * np.log(x) array(2.30258509e+11, 4.60517019e+21, 9.21034037e+41, 1.84206807e+82)

gammasgn(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True, signature, extobj)

gammasgn(x)

Sign of the gamma function.

It is defined as

.. math::

\textgammasgn(x) = \begincases +1 & \Gamma(x) > 0 \\ -1 & \Gamma(x) < 0 \endcases

where :math:`\Gamma` is the gamma function; see `gamma`. This definition is complete since the gamma function is never zero; see the discussion after dlmf_.

Parameters ---------- x : array_like Real argument

Returns ------- scalar or ndarray Sign of the gamma function

Notes ----- The gamma function can be computed as ``gammasgn(x) * np.exp(gammaln(x))``.

See Also -------- gamma : the gamma function gammaln : log of the absolute value of the gamma function loggamma : analytic continuation of the log of the gamma function

References ---------- .. dlmf NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/5.2#E1

Examples -------- >>> import scipy.special as sc

It is 1 for `x > 0`.

>>> sc.gammasgn(1, 2, 3, 4) array(1., 1., 1., 1.)

It alternates between -1 and 1 for negative integers.

>>> sc.gammasgn(-0.5, -1.5, -2.5, -3.5) array(-1., 1., -1., 1.)

It can be used to compute the gamma function.

>>> x = 1.5, 0.5, -0.5, -1.5 >>> sc.gammasgn(x) * np.exp(sc.gammaln(x)) array( 0.88622693, 1.77245385, -3.5449077 , 2.3632718 ) >>> sc.gamma(x) array( 0.88622693, 1.77245385, -3.5449077 , 2.3632718 )