Module Owl_maths

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.

Elliptic functions
val ellipj : float -> float -> float * float * float * float

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

Error functions
val erf : float -> float

Error function. :math:`\int_

\infty

}

^x \frac

\sqrt(2\pi) \exp(-(1/2) y^2) dy`

val erfc : float -> float

Complementary error function, :math:`\int^\infty_x \frac

\sqrt(2\pi) \exp(-(1/2) y^2) dy`

val erfcx : float -> float

Scaled complementary error function, :math:`\exp(x^2) \mathrmrfc(x)`.

val erfinv : float -> float

Inverse function of erf.

val erfcinv : float -> float

Inverse function of erfc.

Dawson & Fresnel integrals
val dawsn : float -> float

Dawson’s integral.

val fresnel : float -> float * float

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

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

Parameters: * a: Shape parameter (:math:`a > 0`). * b: Shape parameter (:math:`a > 0`). * x: Upper limit of integration, in :math:`0, 1`.

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

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

Parameters: * a: Shape parameter (:math:`a > 0`). * b: Shape parameter (:math:`a > 0`). * x: Cumulative probability, in :math:`0, 1`.

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.