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])

Compute `nt` zeros and values of the Airy function Ai and its derivative.

Computes the first `nt` zeros, `a`, of the Airy function Ai(x); first `nt` zeros, `ap`, of the derivative of the Airy function Ai'(x); the corresponding values Ai(a'); and the corresponding values Ai'(a).

Parameters ---------- nt : int Number of zeros to compute

Returns ------- a : ndarray First `nt` zeros of Ai(x) ap : ndarray First `nt` zeros of Ai'(x) ai : ndarray Values of Ai(x) evaluated at first `nt` zeros of Ai'(x) aip : ndarray Values of Ai'(x) evaluated at first `nt` zeros of Ai(x)

Examples -------- >>> from scipy import special >>> a, ap, ai, aip = special.ai_zeros(3) >>> a array(-2.33810741, -4.08794944, -5.52055983) >>> ap array(-1.01879297, -3.24819758, -4.82009921) >>> ai array( 0.53565666, -0.41901548, 0.38040647) >>> aip array( 0.70121082, -0.80311137, 0.86520403)

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

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)

Compute the generalized (associated) Laguerre polynomial of degree n and order k.

The polynomial :math:`L^(k)_n(x)` is orthogonal over ``0, inf)``, with weighting function ``exp(-x) * x**k`` with ``k > -1``. Notes ----- `assoc_laguerre` is a simple wrapper around `eval_genlaguerre`, with reversed argument order ``(x, n, k=0.0) --> (n, k, x)``.

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)

Compute nt zeros of the Kelvin function bei.

Parameters ---------- nt : int Number of zeros to compute. Must be positive.

Returns ------- ndarray First `nt` zeros of the Kelvin function.

See Also -------- bei

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

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

Compute nt zeros of the derivative of the Kelvin function bei.

Parameters ---------- nt : int Number of zeros to compute. Must be positive.

Returns ------- ndarray First `nt` zeros of the derivative of the Kelvin function.

See Also -------- bei, beip

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

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)

Compute nt zeros of the Kelvin function ber.

Parameters ---------- nt : int Number of zeros to compute. Must be positive.

Returns ------- ndarray First `nt` zeros of the Kelvin function.

See Also -------- ber

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

Bernoulli numbers B0..Bn (inclusive).

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

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

Compute nt zeros of the derivative of the Kelvin function ber.

Parameters ---------- nt : int Number of zeros to compute. Must be positive.

Returns ------- ndarray First `nt` zeros of the derivative of the Kelvin function.

See Also -------- ber, berp

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

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)))``.

Compute `nt` zeros and values of the Airy function Bi and its derivative.

Computes the first `nt` zeros, b, of the Airy function Bi(x); first `nt` zeros, b', of the derivative of the Airy function Bi'(x); the corresponding values Bi(b'); and the corresponding values Bi'(b).

Parameters ---------- nt : int Number of zeros to compute

Returns ------- b : ndarray First `nt` zeros of Bi(x) bp : ndarray First `nt` zeros of Bi'(x) bi : ndarray Values of Bi(x) evaluated at first `nt` zeros of Bi'(x) bip : ndarray Values of Bi'(x) evaluated at first `nt` zeros of Bi(x)

Examples -------- >>> from scipy import special >>> b, bp, bi, bip = special.bi_zeros(3) >>> b array(-1.17371322, -3.2710933 , -4.83073784) >>> bp array(-2.29443968, -4.07315509, -5.51239573) >>> bi array(-0.45494438, 0.39652284, -0.36796916) >>> bip array( 0.60195789, -0.76031014, 0.83699101)

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

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.

Gauss-Chebyshev (first kind) quadrature.

Compute the sample points and weights for Gauss-Chebyshev quadrature. The sample points are the roots of the nth degree Chebyshev polynomial of the first kind, :math:`C_n(x)`. These sample points and weights correctly integrate polynomials of degree :math:`2n - 1` or less over the interval :math:`-2, 2` with weight function :math:`w(x) = 1 / \sqrt

- (x/2)^2

`. See 22.2.6 in AS_ for more details.

Parameters ---------- n : int quadrature order mu : bool, optional If True, return the sum of the weights, optional.

Returns ------- x : ndarray Sample points w : ndarray Weights mu : float Sum of the weights

See Also -------- scipy.integrate.quadrature scipy.integrate.fixed_quad

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

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 )

Gauss-Gegenbauer quadrature.

Compute the sample points and weights for Gauss-Gegenbauer quadrature. The sample points are the roots of the nth degree Gegenbauer polynomial, :math:`C^\alpha_n(x)`. These sample points and weights correctly integrate polynomials of degree :math:`2n - 1` or less over the interval :math:`-1, 1` with weight function :math:`w(x) = (1 - x^2)^\alpha - 1/2`. See 22.2.3 in AS_ for more details.

Parameters ---------- n : int quadrature order alpha : float alpha must be > -0.5 mu : bool, optional If True, return the sum of the weights, optional.

Returns ------- x : ndarray Sample points w : ndarray Weights mu : float Sum of the weights

See Also -------- scipy.integrate.quadrature scipy.integrate.fixed_quad

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

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

Chebyshev polynomial of the first kind on :math:`-2, 2`.

Defined as :math:`C_n(x) = 2T_n(x/2)`, where :math:`T_n` is the nth Chebychev polynomial of the first kind.

Parameters ---------- n : int Degree of the polynomial. monic : bool, optional If `True`, scale the leading coefficient to be 1. Default is `False`.

Returns ------- C : orthopoly1d Chebyshev polynomial of the first kind on :math:`-2, 2`.

Notes ----- The polynomials :math:`C_n(x)` are orthogonal over :math:`-2, 2` with weight function :math:`1/\sqrt

- (x/2)^2

`.

See Also -------- chebyt : Chebyshev polynomial of the first kind.

References ---------- .. 1 Abramowitz and Stegun, 'Handbook of Mathematical Functions' Section 22. National Bureau of Standards, 1972.

Chebyshev polynomial of the second kind on :math:`-2, 2`.

Defined as :math:`S_n(x) = U_n(x/2)` where :math:`U_n` is the nth Chebychev polynomial of the second kind.

Parameters ---------- n : int Degree of the polynomial. monic : bool, optional If `True`, scale the leading coefficient to be 1. Default is `False`.

Returns ------- S : orthopoly1d Chebyshev polynomial of the second kind on :math:`-2, 2`.

Notes ----- The polynomials :math:`S_n(x)` are orthogonal over :math:`-2, 2` with weight function :math:`\sqrt

- (x/2)

^2`.

See Also -------- chebyu : Chebyshev polynomial of the second kind

References ---------- .. 1 Abramowitz and Stegun, 'Handbook of Mathematical Functions' Section 22. National Bureau of Standards, 1972.

Chebyshev polynomial of the first kind.

Defined to be the solution of

.. math:: (1 - x^2)\fracd^2dx^2T_n - x\fracddxT_n + n^2T_n = 0;

:math:`T_n` is a polynomial of degree :math:`n`.

Parameters ---------- n : int Degree of the polynomial. monic : bool, optional If `True`, scale the leading coefficient to be 1. Default is `False`.

Returns ------- T : orthopoly1d Chebyshev polynomial of the first kind.

Notes ----- The polynomials :math:`T_n` are orthogonal over :math:`-1, 1` with weight function :math:`(1 - x^2)^

1/2

}

`.

See Also -------- chebyu : Chebyshev polynomial of the second kind.

Chebyshev polynomial of the second kind.

Defined to be the solution of

.. math:: (1 - x^2)\fracd^2dx^2U_n - 3x\fracddxU_n

1. n(n + 2)U_n = 0;

:math:`U_n` is a polynomial of degree :math:`n`.

Parameters ---------- n : int Degree of the polynomial. monic : bool, optional If `True`, scale the leading coefficient to be 1. Default is `False`.

Returns ------- U : orthopoly1d Chebyshev polynomial of the second kind.

Notes ----- The polynomials :math:`U_n` are orthogonal over :math:`-1, 1` with weight function :math:`(1 - x^2)^

/2

`.

See Also -------- chebyt : Chebyshev polynomial of the first kind.

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`

Associated Legendre function of the first kind for complex arguments.

Computes the associated Legendre function of the first kind of order m and degree n, ``Pmn(z)`` = :math:`P_n^m(z)`, and its derivative, ``Pmn'(z)``. Returns two arrays of size ``(m+1, n+1)`` containing ``Pmn(z)`` and ``Pmn'(z)`` for all orders from ``0..m`` and degrees from ``0..n``.

Parameters ---------- m : int ``|m| <= n``; the order of the Legendre function. n : int where ``n >= 0``; the degree of the Legendre function. Often called ``l`` (lower case L) in descriptions of the associated Legendre function z : float or complex Input value. type : int, optional takes values 2 or 3 2: cut on the real axis ``|x| > 1`` 3: cut on the real axis ``-1 < x < 1`` (default)

Returns ------- Pmn_z : (m+1, n+1) array Values for all orders ``0..m`` and degrees ``0..n`` Pmn_d_z : (m+1, n+1) array Derivatives for all orders ``0..m`` and degrees ``0..n``

See Also -------- lpmn: associated Legendre functions of the first kind for real z

Notes ----- By default, i.e. for ``type=3``, phase conventions are chosen according to 1_ such that the function is analytic. The cut lies on the interval (-1, 1). Approaching the cut from above or below in general yields a phase factor with respect to Ferrer's function of the first kind (cf. `lpmn`).

For ``type=2`` a cut at ``|x| > 1`` is chosen. Approaching the real values on the interval (-1, 1) in the complex plane yields Ferrer's function of the first kind.

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html .. 2 NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/14.21

The number of combinations of N things taken k at a time.

This is often expressed as 'N choose k'.

Parameters ---------- N : int, ndarray Number of things. k : int, ndarray Number of elements taken. exact : bool, optional If `exact` is False, then floating point precision is used, otherwise exact long integer is computed. repetition : bool, optional If `repetition` is True, then the number of combinations with repetition is computed.

Returns ------- val : int, float, ndarray The total number of combinations.

See Also -------- binom : Binomial coefficient ufunc

Notes -----

• Array arguments accepted only for exact=False case.
• If N < 0, or k < 0, then 0 is returned.
• If k > N and repetition=False, then 0 is returned.

Examples -------- >>> from scipy.special import comb >>> k = np.array(3, 4) >>> n = np.array(10, 10) >>> comb(n, k, exact=False) array( 120., 210.) >>> comb(10, 3, exact=True) 120 >>> comb(10, 3, exact=True, repetition=True) 220

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()

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

psi(z, out=None)

The digamma function.

The logarithmic derivative of the gamma function evaluated at ``z``.

Parameters ---------- z : array_like Real or complex argument. out : ndarray, optional Array for the computed values of ``psi``.

Returns ------- digamma : ndarray Computed values of ``psi``.

Notes ----- For large values not close to the negative real axis, ``psi`` is computed using the asymptotic series (5.11.2) from 1_. For small arguments not close to the negative real axis, the recurrence relation (5.5.2) from 1_ is used until the argument is large enough to use the asymptotic series. For values close to the negative real axis, the reflection formula (5.5.4) from 1_ is used first. Note that ``psi`` has a family of zeros on the negative real axis which occur between the poles at nonpositive integers. Around the zeros the reflection formula suffers from cancellation and the implementation loses precision. The sole positive zero and the first negative zero, however, are handled separately by precomputing series expansions using 2_, so the function should maintain full accuracy around the origin.

References ---------- .. 1 NIST Digital Library of Mathematical Functions https://dlmf.nist.gov/5 .. 2 Fredrik Johansson and others. 'mpmath: a Python library for arbitrary-precision floating-point arithmetic' (Version 0.19) http://mpmath.org/

Periodic sinc function, also called the Dirichlet function.

The Dirichlet function is defined as::

diric(x, n) = sin(x * n/2) / (n * sin(x / 2)),

where `n` is a positive integer.

Parameters ---------- x : array_like Input data n : int Integer defining the periodicity.

Returns ------- diric : ndarray

Examples -------- >>> from scipy import special >>> import matplotlib.pyplot as plt

>>> x = np.linspace(-8*np.pi, 8*np.pi, num=201) >>> plt.figure(figsize=(8, 8)); >>> for idx, n in enumerate(2, 3, 4, 9): ... plt.subplot(2, 2, idx+1) ... plt.plot(x, special.diric(x, n)) ... plt.title('diric, n={

}

'.format(n)) >>> plt.show()

The following example demonstrates that `diric` gives the magnitudes (modulo the sign and scaling) of the Fourier coefficients of a rectangular pulse.

Suppress output of values that are effectively 0:

>>> np.set_printoptions(suppress=True)

Create a signal `x` of length `m` with `k` ones:

>>> m = 8 >>> k = 3 >>> x = np.zeros(m) >>> x:k = 1

Use the FFT to compute the Fourier transform of `x`, and inspect the magnitudes of the coefficients:

>>> np.abs(np.fft.fft(x)) array( 3. , 2.41421356, 1. , 0.41421356, 1. , 0.41421356, 1. , 2.41421356)

Now find the same values (up to sign) using `diric`. We multiply by `k` to account for the different scaling conventions of `numpy.fft.fft` and `diric`:

>>> theta = np.linspace(0, 2*np.pi, m, endpoint=False) >>> k * special.diric(theta, k) array( 3. , 2.41421356, 1. , -0.41421356, -1. , -0.41421356, 1. , 2.41421356)

Ellipsoidal harmonic functions E^p_n(l)

These are also known as Lame functions of the first kind, and are solutions to the Lame equation:

.. math:: (s^2 - h^2)(s^2 - k^2)E''(s) + s(2s^2 - h^2 - k^2)E'(s) + (a - q s^2)E(s) = 0

where :math:`q = (n+1)n` and :math:`a` is the eigenvalue (not returned) corresponding to the solutions.

Parameters ---------- h2 : float ``h**2`` k2 : float ``k**2``; should be larger than ``h**2`` n : int Degree s : float Coordinate p : int Order, can range between 1,2n+1 signm :

, -1

, optional Sign of prefactor of functions. Can be +/-1. See Notes. signn :

, -1

, optional Sign of prefactor of functions. Can be +/-1. See Notes.

Returns ------- E : float the harmonic :math:`E^p_n(s)`

See Also -------- ellip_harm_2, ellip_normal

Notes ----- The geometric interpretation of the ellipsoidal functions is explained in 2_, 3_, 4_. The `signm` and `signn` arguments control the sign of prefactors for functions according to their type::

K : +1 L : signm M : signn N : signm*signn

.. versionadded:: 0.15.0

References ---------- .. 1 Digital Library of Mathematical Functions 29.12 https://dlmf.nist.gov/29.12 .. 2 Bardhan and Knepley, 'Computational science and re-discovery: open-source implementations of ellipsoidal harmonics for problems in potential theory', Comput. Sci. Disc. 5, 014006 (2012) :doi:`10.1088/1749-4699/5/1/014006`. .. 3 David J.and Dechambre P, 'Computation of Ellipsoidal Gravity Field Harmonics for small solar system bodies' pp. 30-36, 2000 .. 4 George Dassios, 'Ellipsoidal Harmonics: Theory and Applications' pp. 418, 2012

Examples -------- >>> from scipy.special import ellip_harm >>> w = ellip_harm(5,8,1,1,2.5) >>> w 2.5

Check that the functions indeed are solutions to the Lame equation:

>>> from scipy.interpolate import UnivariateSpline >>> def eigenvalue(f, df, ddf): ... r = ((s**2 - h**2)*(s**2 - k**2)*ddf + s*(2*s**2 - h**2 - k**2)*df - n*(n+1)*s**2*f)/f ... return -r.mean(), r.std() >>> s = np.linspace(0.1, 10, 200) >>> k, h, n, p = 8.0, 2.2, 3, 2 >>> E = ellip_harm(h**2, k**2, n, p, s) >>> E_spl = UnivariateSpline(s, E) >>> a, a_err = eigenvalue(E_spl(s), E_spl(s,1), E_spl(s,2)) >>> a, a_err (583.44366156701483, 6.4580890640310646e-11)

Ellipsoidal harmonic functions F^p_n(l)

These are also known as Lame functions of the second kind, and are solutions to the Lame equation:

.. math:: (s^2 - h^2)(s^2 - k^2)F''(s) + s(2s^2 - h^2 - k^2)F'(s) + (a - q s^2)F(s) = 0

where :math:`q = (n+1)n` and :math:`a` is the eigenvalue (not returned) corresponding to the solutions.

Parameters ---------- h2 : float ``h**2`` k2 : float ``k**2``; should be larger than ``h**2`` n : int Degree. p : int Order, can range between 1,2n+1. s : float Coordinate

Returns ------- F : float The harmonic :math:`F^p_n(s)`

Notes ----- Lame functions of the second kind are related to the functions of the first kind:

.. math::

F^p_n(s)=(2n + 1)E^p_n(s)\int_

^

/s

\fracdu(E^p_n(1/u))^2\sqrt{(1-u^2k^2)(1-u^2h^2)

}

.. versionadded:: 0.15.0

See Also -------- ellip_harm, ellip_normal

Examples -------- >>> from scipy.special import ellip_harm_2 >>> w = ellip_harm_2(5,8,2,1,10) >>> w 0.00108056853382

Ellipsoidal harmonic normalization constants gamma^p_n

The normalization constant is defined as

.. math::

\gamma^p_n=8\int_

^hdx\int_h^kdy\frac(y^2-x^2)(E^p_n(y)E^p_n(x))^2\sqrt((k^2-y^2)(y^2-h^2)(h^2-x^2)(k^2-x^2)

Parameters ---------- h2 : float ``h**2`` k2 : float ``k**2``; should be larger than ``h**2`` n : int Degree. p : int Order, can range between 1,2n+1.

Returns ------- gamma : float The normalization constant :math:`\gamma^p_n`

See Also -------- ellip_harm, ellip_harm_2

Notes ----- .. versionadded:: 0.15.0

Examples -------- >>> from scipy.special import ellip_normal >>> w = ellip_normal(5,8,3,7) >>> w 1723.38796997

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()

Compute the first nt zero in the first quadrant, ordered by absolute value.

Zeros in the other quadrants can be obtained by using the symmetries erf(-z) = erf(z) and erf(conj(z)) = conj(erf(z)).

Parameters ---------- nt : int The number of zeros to compute

Returns ------- The locations of the zeros of erf : ndarray (complex) Complex values at which zeros of erf(z)

Examples -------- >>> from scipy import special >>> special.erf_zeros(1) array(1.45061616+1.880943j)

Check that erf is (close to) zero for the value returned by erf_zeros

>>> special.erf(special.erf_zeros(1)) array(4.95159469e-14-1.16407394e-16j)

References ---------- .. 1 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

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)

Euler numbers E(0), E(1), ..., E(n).

The Euler numbers 1_ are also known as the secant numbers.

Because ``euler(n)`` returns floating point values, it does not give exact values for large `n`. The first inexact value is E(22).

Parameters ---------- n : int The highest index of the Euler number to be returned.

Returns ------- ndarray The Euler numbers E(0), E(1), ..., E(n). The odd Euler numbers, which are all zero, are included.

References ---------- .. 1 Sequence A122045, The On-Line Encyclopedia of Integer Sequences, https://oeis.org/A122045 .. 2 Zhang, Shanjie and Jin, Jianming. 'Computation of Special Functions', John Wiley and Sons, 1996. https://people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html

Examples -------- >>> from scipy.special import euler >>> euler(6) array( 1., 0., -1., 0., 5., 0., -61.)

>>> euler(13).astype(np.int64) array( 1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521, 0, 2702765, 0)

>>> euler(22)-1 # Exact value of E(22) is -69348874393137901. -69348874393137976.0

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])