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.