Legend:
Library
Module
Module type
Parameter
Class
Class type
Maths: fundamental and advanced mathematical functions.
This module contains some basic and advanced mathematical operations. If you cannot find some function in this module, try Stats module.
Please refer to Scipy documentation.
Basic functions
val add : float ->float -> float
``add x y`` returns :math:`x + y`.
val sub : float ->float -> float
``sub x y`` returns :math:`x - y`.
val mul : float ->float -> float
``mul x y`` returns :math:`x * y`.
val div : float ->float -> float
``div x y`` returns :math:`x / y`.
val fmod : float ->float -> float
``fmod x y`` returns :math:`x % y`.
val atan2 : float ->float -> float
``atan2 y x`` returns :math:`\arctan(y/x)`, accounting for the sign of the arguments; this is the angle to the vector :math:`(x, y)` counting from the x-axis.
val abs : float -> float
``abs x`` returns :math:`|x|`.
val neg : float -> float
``neg x`` returns :math:`-x`.
val reci : float -> float
``reci x`` returns :math:`1/x`.
val floor : float -> float
``floor x`` returns the largest integer :math:`\leq x`.
val ceil : float -> float
``ceil x`` returns the smallest integer :math:`\geq x`.
val round : float -> float
``round x`` rounds, towards the bigger integer when on the fence.
val trunc : float -> float
``trunc x`` integer part.
val sqr : float -> float
``sqr x`` square.
val sqrt : float -> float
``sqrt x`` square root.
val pow : float ->float -> float
``pow x y`` returns :math:`x^y`.
val exp : float -> float
``exp x`` exponential.
val exp2 : float -> float
``exp2 x`` exponential.
val exp10 : float -> float
``exp10 x`` exponential.
val expm1 : float -> float
``expm1 x`` returns :math:`\exp(x) - 1` but more accurate for :math:`x \sim 0`.
val log : float -> float
``log x`` natural logarithm
val log2 : float -> float
``log2 x`` base-2 logarithm.
val log10 : float -> float
``log10 x`` base-10 logarithm.
val logn : float ->float -> float
``logn x`` base-n logarithm.
val log1p : float -> float
``log1p x`` returns :math:`\log (x + 1)` but more accurate for :math:`x \sim 0`. Inverse of ``expm1``.
val logabs : float -> float
``logabs x`` returns :math:`\log(|x|)`.
val sigmoid : float -> float
``sigmoid x`` returns the logistic sigmoid function :math:`1 / (1 + \exp(-x))`.
val signum : float -> float
``signum x`` returns the sign of :math:`x`: -1, 0 or 1.
val softsign : float -> float
Smoothed sign function.
val softplus : float -> float
``softplus x`` returns :math:`\log(1 + \exp(x))`.
val relu : float -> float
``relu x`` returns :math:`\max(0, x)`.
val sin : float -> float
``sin x`` returns :math:`\sin(x)`.
val cos : float -> float
``cos x`` returns :math:`\cos(x)`.
val tan : float -> float
``tan x`` returns :math:`\tan(x)`.
val cot : float -> float
``cot x`` returns :math:`1/\tan(x)`.
val sec : float -> float
``sec x`` returns :math:`1/\cos(x)`.
val csc : float -> float
``csc x`` returns :math:`1/\sin(x)`.
val asin : float -> float
``asin x`` returns :math:`\arcsin(x)`.
val acos : float -> float
``acos x`` returns :math:`\arccos(x)`.
val atan : float -> float
``atan x`` returns :math:`\arctan(x)`.
val acot : float -> float
Inverse function of ``cot``.
val asec : float -> float
Inverse function of ``sec``.
val acsc : float -> float
Inverse function of ``csc``.
val sinh : float -> float
Returns :math:`\sinh(x)`.
val cosh : float -> float
``cosh x`` returns :math:`\cosh(x)`.
val tanh : float -> float
``tanh x`` returns :math:`\tanh(x)`.
val coth : float -> float
``coth x`` returns :math:`\coth(x)`.
val sech : float -> float
``sech x`` returns :math:`1/\cosh(x)`.
val csch : float -> float
``csch x`` returns :math:`1/\sinh(x)`.
val asinh : float -> float
Inverse function of ``sinh``.
val acosh : float -> float
Inverse function of ``cosh``.
val atanh : float -> float
Inverse function of ``tanh``.
val acoth : float -> float
Inverse function of ``coth``.
val asech : float -> float
Inverse function of ``sech``.
val acsch : float -> float
Inverse function of ``csch``.
val sinc : float -> float
``sinc x`` returns :math:`\sin(x)/x` and :math:`1` for :math:`x=0`.
val logsinh : float -> float
``logsinh x`` returns :math:`\log(\sinh(x))` but handles large :math:`|x|`.
val logcosh : float -> float
``logcosh x`` returns :math:`\log(\cosh(x))` but handles large :math:`|x|`.
val sindg : float -> float
Sine of angle given in degrees.
val cosdg : float -> float
Cosine of the angle given in degrees.
val tandg : float -> float
Tangent of angle given in degrees.
val cotdg : float -> float
Cotangent of the angle given in degrees.
val hypot : float ->float -> float
``hypot x y`` returns :math:`\sqrtx^2 + y^2`.
val xlogy : float ->float -> float
``xlogy(x, y)`` returns :math:`x \log(y)`.
val xlog1py : float ->float -> float
``xlog1py(x, y)`` returns :math:`x \log(y+1)`.
val logit : float -> float
``logit(x)`` returns :math:`\logp/(1-p)`.
val expit : float -> float
``expit(x)`` returns :math:`1/(1+\exp(-x))`.
val log1mexp : float -> float
``log1mexp(x)`` returns :math:`log(1-exp(x))`.
val log1pexp : float -> float
``log1pexp(x)`` returns :math:`log(1+exp(x))`.
Airy functions
val airy : float -> float * float * float * float
Airy function ``airy x`` returns ``(Ai, Ai', Bi, Bi')`` evaluated at :math:`x`. ``Ai'`` is the derivative of ``Ai`` whilst ``Bi'`` is the derivative of ``Bi``.
Bessel functions
val j0 : float -> float
Bessel function of the first kind of order 0.
val j1 : float -> float
Bessel function of the first kind of order 1.
val jv : float ->float -> float
Bessel function of real order.
val y0 : float -> float
Bessel function of the second kind of order 0.
val y1 : float -> float
Bessel function of the second kind of order 1.
val yv : float ->float -> float
Bessel function of the second kind of real order.
val yn : int ->float -> float
Bessel function of the second kind of integer order.
val i0 : float -> float
Modified Bessel function of order 0.
val i0e : float -> float
Exponentially scaled modified Bessel function of order 0.
val i1 : float -> float
Modified Bessel function of order 1.
val i1e : float -> float
Exponentially scaled modified Bessel function of order 1.
val iv : float ->float -> float
Modified Bessel function of the first kind of real order.
val k0 : float -> float
Modified Bessel function of the second kind of order 0, :math:`K_0`.
val k0e : float -> float
Exponentially scaled modified Bessel function K of order 0.
val k1 : float -> float
Modified Bessel function of the second kind of order 1, :math:`K_1(x)`.
val k1e : float -> float
Exponentially scaled modified Bessel function K of order 1.
Jacobian Elliptic function ``ellipj u m`` returns ``(sn, cn, dn, phi)``.
val ellipk : float -> float
``ellipk m`` returns the complete elliptic integral of the first kind.
val ellipkm1 : float -> float
FIXME. Complete elliptic integral of the first kind around :math:`m = 1`.
val ellipkinc : float ->float -> float
``ellipkinc phi m`` incomplete elliptic integral of the first kind.
val ellipe : float -> float
``ellipe m`` complete elliptic integral of the second kind.
val ellipeinc : float ->float -> float
``ellipeinc phi m`` incomplete elliptic integral of the second kind.
Gamma Functions
val gamma : float -> float
``gamma z`` returns the value of the Gamma function
.. math:: \Gamma(z) = \int_0^\infty x^z-1 e^
x
}
dx = (z - 1)! .
The gamma function is often referred to as the generalized factorial since :math:`z\ gamma(z) = \gamma(z+1)` and :math:`gamma(n+1) = n!` for natural number :math:`n`.
val rgamma : float -> float
Reciprocal Gamma function.
val loggamma : float -> float
Logarithm of the gamma function.
val gammainc : float ->float -> float
Incomplete gamma function.
val gammaincinv : float ->float -> float
Inverse function of ``gammainc``.
val gammaincc : float ->float -> float
Complemented incomplete gamma integral.
val gammainccinv : float ->float -> float
Inverse function of ``gammaincc``.
val psi : float -> float
The digamma function.
Beta functions
val beta : float ->float -> float
Beta function.
.. math:: \mathrmB(a, b) = \frac\Gamma(a) \Gamma(b)\Gamma(a+b)
val betainc : float ->float ->float -> float
Incomplete beta integral.
val betaincinv : float ->float ->float -> float
Inverse function of ``betainc``.
Factorials
val fact : int -> float
Factorial function ``fact n`` calculates :math:`n!`.
val log_fact : int -> float
Logarithm of factorial function ``log_fact n`` calculates :math:`\log n!`.
val doublefact : int -> float
Double factorial function ``doublefact n`` calculates :math:`n!! = n(n-2)(n-4)\dots 2` or :math:`\dots 1`
val log_doublefact : int -> float
Logarithm of double factorial function.
val permutation : int ->int -> int
``permutation n k`` returns the number :math:`n!/(n-k)!` of ordered subsets * of length :math:`k`, taken from a set of :math:`n` elements.
val permutation_float : int ->int -> float
``permutation_float`` is like ``permutation`` but deals with larger range.
val combination : int ->int -> int
``combination n k`` returns the number :math:`n!/(k!(n-k)!)` of subsets of k elements of a set of n elements. This is the binomial coefficient :math:`\binomnk`
val combination_float : int ->int -> float
``combination_float`` is like ``combination`` but can deal with a larger range.
val log_combination : int ->int -> float
``log_combination n k`` returns the logarithm of :math:`\binomnk`.
Fresnel trigonometric integrals. ``fresnel x`` returns a tuple consisting of ``(Fresnel sin integral, Fresnel cos integral)``.
Struve functions
val struve : float ->float -> float
``struve v x`` returns the value of the Struve function of order :math:`v` at :math:`x`. The Struve function is defined as,
.. math:: H_v(x) = (z/2)^
+ 1} \sum_{n=0}^\infty \frac{(-1)^n (z/2)^{2n}}{\Gamma(n + \frac{3}{2}) \Gamma(n + v + \frac{3}{2})},
where :math:`\Gamma` is the gamma function. :math:`x` must be positive unless :math:`v` is an integer
Other special functions
val expn : int ->float -> float
Exponential integral :math:`E_n`.
val shichi : float -> float * float
Hyperbolic sine and cosine integrals, ``shichi x`` returns * :math:`(\mathrmshi, \mathrmchi)``.
val shi : float -> float
Hyperbolic sine integral.
val chi : float -> float
Hyperbolic cosine integral.
val sici : float -> float * float
Sine and cosine integrals, ``sici x`` returns :math:`(\mathrmsi, \mathrmci)`.
val si : float -> float
Sine integral.
val ci : float -> float
Cosine integral.
val zeta : float ->float -> float
``zeta x q`` returns the Hurwitz zeta function :math:`\zeta(x, q)`, which reduces to the Riemann zeta function :math:`\zeta(x)` when :math:`q=1`.
val zetac : float -> float
Riemann zeta function minus 1.
Raw statistical functions
val bdtr : int ->int ->float -> float
Binomial distribution cumulative distribution function.
``bdtr k n p`` calculates the sum of the terms :math:`0` through :math:`k` of the Binomial probability density.
.. math:: \mathrmdtr(k, n, p) = \sum_j=0^k {n\choosej
}
p^j (1-p)^n-j
Parameters: * ``k``: Number of successes. * ``n``: Number of events. * ``p``: Probability of success in a single event.
Returns: * Probability of :math:`k` or fewer successes in :math:`n` independent events with success probability :math:`p`.
val bdtrc : int ->int ->float -> float
Binomial distribution survival function.
``bdtrc k n p`` calculates the sum of the terms :math:`k + 1` through :math:`n` of the binomial probability density,
.. math:: \mathrmdtrc(k, n, p) = \sum_j=k+1^n {n\choosej
}
p^j (1-p)^n-j
val bdtri : int ->int ->float -> float
Inverse function to ``bdtr`` with respect to :math:`p`.
Finds the event probability :math:`p` such that the sum of the terms 0 through :math:`k` of the binomial probability density is equal to the given cumulative probability :math:`y`.
val btdtr : float ->float ->float -> float
Cumulative density function of the beta distribution.
``btdtr a b x`` returns the integral from 0 to :math:`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
Returns: * Cumulative density function of the beta distribution with :math:`a` and :math:`b` at :math:`x`.
val btdtri : float ->float ->float -> float
The :math:`p`-th quantile of the Beta distribution.
This function is the inverse of the beta cumulative distribution function, ``btdtr``, returning the value of :math:`x` for which :math:`\mathrmtdtr(a, b, x) = p`,
.. math:: p = \int_0^x \frac\Gamma(a + b)\Gamma(a)\Gamma(b) t^a-1 (1-t)^-1\,dt
Returns: * The quantile corresponding to :math:`p`.
Helper functions
val is_nan : float -> bool
``is_nan x`` returns ``true`` exactly if ``x`` is ``nan``.
val is_inf : float -> bool
``is_inf x`` returns ``true`` exactly if ``x`` is ``infinity`` or ``neg_infinity``.
val is_normal : float -> bool
``is_normal x`` returns ``true`` if ``x`` is a normal float number.
val is_subnormal : float -> bool
``is_nan x`` returns ``true`` if ``x`` is subnormal float number.
val is_odd : int -> bool
``is_odd x`` returns ``true`` exactly if ``x`` is odd.
val is_even : int -> bool
``is_even x`` returns ``true`` exactly if ``x`` is even.
val is_pow2 : int -> bool
``is_pow2 x`` return ``true`` exactly if ``x`` is an integer power of 2, e.g. 32, 64, etc.
val same_sign : float ->float -> bool
``same_sign x y`` returns ``true`` if ``x`` and ``y`` have the same sign, otherwise it returns ``false``. Positive and negative zeros are special cases and always returns ``true``.
val is_simplex : float array-> bool
``is_simplex x`` checks whether the vector :math:`x` lies on a simplex. In other words, :math:`\sum_i^K x_i = 1` and :math:`x_i \ge 0, \forall i \in 1,K`, where :math:`K` is the dimension of :math:`x`.
val is_int : float -> bool
val is_sqr : int -> bool
``is_sqr x`` checks if ``x`` is the square of an integer.
val mulmod : int ->int ->int -> int
``mulmod a b m`` computes (a*b) mod m.
val powmod : int ->int ->int -> int
``powmod a b m`` computes (a^b) mod m.
val is_prime : int -> bool
``is_prime x`` returns ``true`` if ``x`` is a prime number. The function is deterministic for all numbers representable by an int. The function uses the Rabin–Miller primality test.
val fermat_fact : int -> int * int
``fermat_fact x`` performs Fermat factorisation over ``x``, i.e. into two roughly equal factors. ``x`` must be an odd number.
val nextafter : float ->float -> float
``nextafter from to`` returns the next representable double precision value of ``from`` in the direction of ``to``. If ``from`` equals ``to``, this value is returned.
val nextafterf : float ->float -> float
``nextafter from to`` returns the next representable single precision value of ``from`` in the direction of ``to``. If ``from`` equals ``to``, this value is returned.