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.