/* ----------------------------------------------------------------------- *//**
 *
 * @file prob.sql_in
 *
 * @brief SQL functions for evaluating probability functions
 *
 * @sa For an overview of probability functions, see the module
 *     description \ref grp_prob.
 *
 *//* ----------------------------------------------------------------------- */

m4_include(`SQLCommon.m4')

/**
@addtogroup grp_prob

<div class="toc"><b>Contents</b>
<ul>
<li><a href="#syntax">Function Syntax</a></li>
<li><a href="#examples">Examples</a></li>
<li><a href="#literature">Literature</a></li>
<li><a href="#related">Related Topics</a></li>
</ul>
</div>

@brief Provides cumulative distribution, density/mass, and quantile functions
for a wide range of probability distributions.

The Probability Functions module provides cumulative distribution, density/mass,
and quantile functions for a wide range of probability distributions.

Unless otherwise documented, all of these functions are wrappers around
functionality provided by the boost C++ library [1, “<a href=
"http://www.boost.org/doc/libs/1_49_0/libs/math/doc/sf_and_dist/html/math_toolkit/dist.html"
>Statistical Distributions and Functions</a>”].

For convenience, all cumulative distribution and density/mass functions (CDFs
and PDF/PMFs in short) are defined over the range of all floating-point numbers
including infinity. Inputs that are \c NULL or \c NaN (not a number) will always
produce a \c NULL or \c NaN result, respectively. Inputs that are plus or minus
infinity will return the respective limits.

A quantile function for a probability distrution with CDF \f$ F \f$ takes a
probability argument \f$ p \in [0,1] \f$ and returns the value \f$ x \f$ so that
\f$ F(x) = p \f$, provided such an \f$ x \f$ exists and it is unique. If it does
not, the result will be
\f$
    \sup \{ x \in D \mid F(x) \leq p \}
\f$
(interpreted as 0 if the supremum is over an empty set) if \f$ p < 0.5 \f$, and
\f$
    \inf \{ x \in D \mid F(x) \geq p \}
\f$
if \f$ p \geq 0.5 \f$. Here \f$ D \f$ denotes the domain of the distribution,
which is the set of reals \f$ \mathbb R \f$ for continuous and the set of
nonnegative integers \f$ \mathbb N_0 \f$ for discrete distributions.

Intuitively, the formulas in the previous paragraph deal with the following
special cases. The 0-quantile will always be the “left end” of the support,
and the 1-quantile will be the “right end” of the support of the distribution.
For discrete distributions, most values of \f$ p \in [0,1] \f$ do not admit an
\f$ x \f$ with \f$ F(x) = p \f$. Instead, there is an \f$ x \in \mathbb N_0 \f$
so that \f$ F(x) < p < F(x + 1) \f$. The above formulas mean that the
value returned as \f$ p \f$-quantile is \f$ x \f$ if \f$ p < 0.5 \f$, and it
is \f$ x + 1 \f$ if \f$ p \geq 0.5 \f$. (As a special case, in order to ensure
that quantiles are always within the support, the \f$ p \f$-quantile will be 0
if \f$ p < F(0) \f$).

The rationale for choosing this behavior is that \f$p\f$-quantiles for
\f$ p < 0.5 \f$ are typically requested when interested in the value
\f$ x \f$ such that with confidence level <strong>at least</strong>
\f$ 1 - p \f$ a random variable will be \f$ > x \f$ (or equivalently, with
probability <strong>at most</strong> \f$ p \f$, it will be \f$ \leq x \f$).
Likewise, \f$p\f$-quantiles for \f$ p \geq 0.5 \f$ are typically requested when
interested in the value \f$ x \f$ such that with confidence level <strong>at
least</strong> \f$ p \f$ a random variable will be \f$ \leq x \f$. See also
[1, “<a href=
"http://www.boost.org/doc/libs/1_46_1/libs/math/doc/sf_and_dist/html/math_toolkit/policy/pol_tutorial/understand_dis_quant.html"
>Understanding Quantiles of Discrete Distributions</a>”].

@anchor syntax
@par Function Syntax

Cumulative distribution functions:

<pre class="syntax"><em>distribution</em>_cdf(<em>random variate</em>[, <em>parameter1</em> [, <em>parameter2</em> [, <em>parameter3</em>] ] ])</pre>

Probability density/mass functions:
<pre class="syntax"><em>distribution</em>_{pdf|pmf}(<em>random variate</em>[, <em>parameter1</em> [, <em>parameter2</em> [, <em>parameter3</em>] ] ])</pre>

Quantile functions:
<pre class="syntax"><em>distribution</em>_quantile(<em>probability</em>[, <em>parameter1</em> [, <em>parameter2</em> [, <em>parameter3</em>] ] ])</pre>

For concrete function signatures, see \ref prob.sql_in.

@anchor examples
@examp

<pre class="example">
SELECT madlib.normal_cdf(0);
</pre>
Result:
<pre class="result">
 normal_cdf
&nbsp;-----------
        0.5
</pre>
<pre class="example">
SELECT madlib.normal_quantile(0.5, 0, 1);
</pre>
Result:
<pre class="result">
 normal_quantile
&nbsp;----------------
               0
(1 row)
</pre>

@anchor literature
@literature

[1] John Maddock, Paul A. Bristow, Hubert Holin, Xiaogang Zhang, Bruno Lalande,
    Johan Råde, Gautam Sewani and Thijs van den Berg:
    <em>Boost Math Toolkit</em>, Version 1.49, available at:
    http://www.boost.org/doc/libs/1_49_0/libs/math/doc/sf_and_dist/html/index.html

@par Related Topics
@anchor related
File prob.sql_in documenting the SQL functions.
*/


/**
 * @brief Bernoulli cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param sp Success probability \f$ p \in [0,1] \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Bernoulli-distributed
 *     random variable with success probability \f$ \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.bernoulli_cdf(
    x DOUBLE PRECISION,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Bernoulli probability mass function
 *
 * @param x Random variate \f$ x \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability mass function of
 *     a Bernoulli-distributed random variable with success probability
 *     \f$ \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.bernoulli_pmf(
    x INT4,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Bernoulli quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return 0 if \f$ p \leq 1 - \mathit{sp} \f$ and 1 otherwise
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.bernoulli_quantile(
    p DOUBLE PRECISION,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Beta cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param alpha Shape \f$ \alpha > 0 \f$
 * @param beta Shape \f$ \beta > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a beta distributed random
 *     variable with shape parameters \f$ \alpha \f$ and \f$ \beta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.beta_cdf(
    x DOUBLE PRECISION,
    alpha DOUBLE PRECISION,
    beta DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Beta probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param alpha Shape \f$ \alpha > 0 \f$
 * @param beta Shape \f$ \beta > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a beta random variable with shape parameters \f$ \alpha \f$ and
 *     \f$ \beta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.beta_pdf(
    x DOUBLE PRECISION,
    alpha DOUBLE PRECISION,
    beta DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Beta quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param alpha Shape \f$ \alpha > 0 \f$
 * @param beta Shape \f$ \beta > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     beta distribution random variable with shape parameters \f$ \alpha \f$
 *     and \f$ \beta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.beta_quantile(
    p DOUBLE PRECISION,
    alpha DOUBLE PRECISION,
    beta DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Binomial cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param n The number of trials \f$ n \in \mathbb N_0 \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a binomially distributed
 *     random variable with \f$ n \f$ trials and success probability
 *     \f$ \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.binomial_cdf(
    x DOUBLE PRECISION,
    n INT4,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Binomial probability mass function
 *
 * @param x Random variate \f$ x \f$
 * @param n The number of trials \f$ n \in \mathbb N_0 \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability mass function of
 *     a binomially distributed random variable with \f$ n \f$ trials and
 *     success probability \f$ \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.binomial_pmf(
    x INT4,
    n INT4,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Binomial quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param n The number of trials \f$ n \in \mathbb N_0 \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return If \f$ p < 0.5 \f$ the maximum \f$ x \f$ such that
 *     \f$ p \geq \Pr[X \leq x] \f$. If \f$ p \geq 0.5 \f$ the minimum \f$ x \f$
 *     such that \f$ p \leq \Pr[X \leq x] \f$. Here, \f$ X \f$ is a
 *     binomially distributed random variable with \f$ n \f$ trials and
 *     success probability \f$ \mathit{sp} \f$.
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.binomial_quantile(
    p DOUBLE PRECISION,
    n INT4,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Cauchy cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param location Location \f$ x_0 \f$
 * @param scale Scale \f$ \gamma > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Cauchy-distributed random
 *     variable with location and scale parameters \f$ x_0 \f$ and
 *     \f$ \gamma \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.cauchy_cdf(
    x DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Cauchy probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param location Location \f$ x_0 \f$
 * @param scale Scale \f$ \gamma > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a Cauchy-distributed random variable with location and scale parameters
 *     \f$ x_0 \f$ and \f$ \gamma \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.cauchy_pdf(
    x DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Cauchy quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param location Location \f$ x_0 \f$
 * @param scale Scale \f$ \gamma > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     Cauchy-distributed random variable with location and scale parameters
 *     \f$ x_0 \f$ and \f$ \gamma \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.cauchy_quantile(
    p DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Chi-squared cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a chi-squared distributed
 *     random variable with \f$ \nu \f$ degrees of freedom
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.chi_squared_cdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Chi-squared distribution probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a chi-squared distributed random variable with \f$ \nu \f$ degrees of
 *     freedom
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.chi_squared_pdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Chi-squared distribution quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param df Degrees of freedom \f$ \mu > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     chi-squared distributed random variable with \f$ \nu \f$ degrees of
 *     freedom
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.chi_squared_quantile(
    p DOUBLE PRECISION,
    df DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Exponential cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param lambda Rate parameter \f$ \lambda > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is an exponentially distributed
 *     random variable with rate parameter \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.exponential_cdf(
    x DOUBLE PRECISION,
    lambda DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Exponential probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param lambda Rate parameter \f$ \lambda > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     exponentially distributed random variable with rate parameter
 *     \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.exponential_pdf(
    x DOUBLE PRECISION,
    lambda DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Exponential quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param lambda Rate parameter \f$ \lambda > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     exponentially distributed random variable with rate parameter
 *     \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.exponential_quantile(
    p DOUBLE PRECISION,
    lambda DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Extreme Value cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param location Location \f$ \alpha \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is an extreme-value distributed
 *     random variable with location and scale parameters \f$ \alpha \f$ and
 *     \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.extreme_value_cdf(
    x DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Extreme Value probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param location Location \f$ \alpha \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     an extreme-value distributed random variable with location and scale
 *     parameters \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.extreme_value_pdf(
    x DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Extreme Value quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param location Location \f$ \alpha \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     an extreme-value distributed random variable with location and scale
 *     parameters \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.extreme_value_quantile(
    p DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Fisher F cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param df1 Degrees of freedom in numerator \f$ \nu_1 > 0 \f$
 * @param df2 Degrees of freedom in denominator \f$ \nu_1 > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Fisher F-distributed
 *     random variable with parameters \f$ \nu_1 \f$ and \f$ \nu_2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.fisher_f_cdf(
    x DOUBLE PRECISION,
    df1 DOUBLE PRECISION,
    df2 DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Fisher F probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param df1 Degrees of freedom in numerator \f$ \nu_1 > 0 \f$
 * @param df2 Degrees of freedom in denominator \f$ \nu_1 > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a Fisher F-distributed random variable with parameters \f$ \nu_1 \f$ and
 *     \f$ \nu_2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.fisher_f_pdf(
    x DOUBLE PRECISION,
    df1 DOUBLE PRECISION,
    df2 DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Fisher F quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param df1 Degrees of freedom in numerator \f$ \nu_1 > 0 \f$
 * @param df2 Degrees of freedom in denominator \f$ \nu_1 > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     Fisher F-distributed random variable with parameters \f$ \nu_1 \f$ and
 *     \f$ \nu_2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.fisher_f_quantile(
    p DOUBLE PRECISION,
    df1 DOUBLE PRECISION,
    df2 DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Gamma cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param shape Shape \f$ k > 0 \f$
 * @param scale Scale \f$ \theta > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a gamma distributed random
 *     variable with shape and scale parameters \f$ k \f$ and
 *     \f$ \theta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.gamma_cdf(
    x DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Gamma probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param shape Shape \f$ k > 0 \f$
 * @param scale Scale \f$ \theta > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a gamma distributed random variable with shape and scale parameters
 *     \f$ k \f$ and \f$ \theta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.gamma_pdf(
    x DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Gamma quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param shape Shape \f$ k > 0 \f$
 * @param scale Scale \f$ \theta > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     a gamma distributed random variable with shape and scale parameters
 *     \f$ k \f$ and \f$ \theta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.gamma_quantile(
    p DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Geometric cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a geometrically distributed
 *     random variable with success probability \f$ \mathit{sp} \f$.
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.geometric_cdf(
    x DOUBLE PRECISION,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Geometric probability mass function
 *
 * @param x Random variate \f$ x \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability mass function of a
 *     geometrically distributed random variable with success probability
 *     \f$ \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.geometric_pmf(
    x INT4,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Geometric quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param sp Success probability \f$ \mathit{sp} \in [0,1] \f$
 * @return If \f$ p < 0.5 \f$ the maximum \f$ x \f$ such that
 *     \f$ p \geq \Pr[X \leq x] \f$. If \f$ p \geq 0.5 \f$ the minimum \f$ x \f$
 *     such that \f$ p \leq \Pr[X \leq x] \f$. Here, \f$ X \f$ is a
 *     geometrically distributed random variable with success probability
 *     \f$ \mathit{sp} \f$.
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.geometric_quantile(
    p DOUBLE PRECISION,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Hypergeometric cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param r Number \f$ r \in \{ 0, 1, \dots, N \} \f$ of items with
 *     distinct property (sometimes called the number of <em>success states</em>
 *     in population)
 * @param n Number \f$ n \in \{ 0, 1, \dots, N \} \f$ of draws (without
 *     replacement)
 * @param N Total number \f$ N \in \mathbb N \f$ of items
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a hypergeometrically
 *     distributed random variable with parameters \f$ r, n, N \f$
 *
 * @internal Boost error messages refer to parameters 'r', 'n', 'N', so for now
 *     we use the same identifiers for our function definition.
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.hypergeometric_cdf(
    x DOUBLE PRECISION,
	r INT4,
	n INT4,
	"N" INT4
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Hypergeometric probability mass function
 *
 * @param x Random variate \f$ x \f$
 * @param r Number \f$ r \in \{ 0, 1, \dots, N \} \f$ of items with
 *     distinct property (sometimes called the number of <em>success states</em>
 *     in population)
 * @param n Number \f$ n \in \{ 0, 1, \dots, N \} \f$ of draws (without
 *     replacement)
 * @param N Total number \f$ N \in \mathbb N \f$ of items
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability mass function of
 *     a hypergeometrically distributed random variable with parameters
 *     \f$ r, n, N \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.hypergeometric_pmf(
    x INT4,
	r INT4,
	n INT4,
	"N" INT4
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Hypergeometric quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param r Number \f$ r \in \{ 0, 1, \dots, N \} \f$ of items with
 *     distinct property (sometimes called the number of <em>success states</em>
 *     in population)
 * @param n Number \f$ n \in \{ 0, 1, \dots, N \} \f$ of draws (without
 *     replacement)
 * @param N Total number \f$ N \in \mathbb N \f$ of items
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     a hypergeometrically distributed random variable with parameters
 *     \f$ r, n, N \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.hypergeometric_quantile(
    p DOUBLE PRECISION,
	r INT4,
	n INT4,
	"N" INT4
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Inverse Gamma cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is an inverse-gamma distributed
 *     random variable with shape and scale parameters \f$ \alpha \f$ and
 *     \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.inverse_gamma_cdf(
    x DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Inverse Gamma probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     an inverse-gamma distributed random variable with shape and scale
 *     parameters \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.inverse_gamma_pdf(
    x DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Inverse Gamma quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     an inverse-gamma distributed random variable with shape and scale
 *     parameters \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.inverse_gamma_quantile(
    p DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Kolmogorov cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Kolmogorov distributed
 *     random variable
 *
 * @sa Kolmogorov-Smirnov test: ks_test()
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.kolmogorov_cdf(
    x DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Laplace cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Mean \f$ \mu \f$
 * @param scale Scale \f$ b > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Laplace-distributed random
 *     variable with mean \f$ \mu \f$ and variance \f$ 2 b^2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.laplace_cdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Laplace probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Mean \f$ \mu \f$
 * @param scale Scale \f$ b > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a Laplace-distributed random variable with mean \f$ \mu \f$ and variance
 *     \f$ 2 b^2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.laplace_pdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Laplace quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param mean Mean \f$ \mu \f$
 * @param scale Scale \f$ b > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     Laplace-distributed random variable with mean \f$ \mu \f$ and variance
 *     \f$ 2 b^2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.laplace_quantile(
    p DOUBLE PRECISION,
    mean DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Logistic cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Mean \f$ \mu \f$
 * @param scale Scale \f$ s > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a logistically distributed
 *     random variable with mean \f$ \mu \f$ and scale parameter \f$ s \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.logistic_cdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Logistic probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Mean \f$ \mu \f$
 * @param scale Scale \f$ s > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a logistically distributed random variable with mean \f$ \mu \f$ and
 *     scale parameter \f$ s \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.logistic_pdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Logistic quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param mean Mean \f$ \mu \f$
 * @param scale Scale \f$ s > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     a logistically distributed random variable with mean \f$ \mu \f$ and
 *     scale parameter \f$ s \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.logistic_quantile(
    p DOUBLE PRECISION,
    mean DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Log-normal cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param location Location \f$ m \f$
 * @param scale Scale \f$ s > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a lognormally distributed
 *     random variable with location and scale parameters \f$ m \f$ and
 *     \f$ s \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.lognormal_cdf(
    x DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Log-normal probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param location Location \f$ m \f$
 * @param scale Scale \f$ s > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a lognormally distributed random variable with location and scale
 *     parameters \f$ m \f$ and \f$ s \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.lognormal_pdf(
    x DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Log-normal quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param location Location \f$ m \f$
 * @param scale Scale \f$ s > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     a lognormally distributed random variable with location and scale
 *     parameters \f$ m \f$ and \f$ s \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.lognormal_quantile(
    p DOUBLE PRECISION,
    location DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Negative binomial cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param r Total number \f$ r > 0 \f$ of successes in \f$ x + r \f$ trials
 *     (assuming success in the last trial)
 * @param sp Success probability \f$ \mathit{sp} \in (0,1] \f$ in each trial
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a negative-binomially
 *     distributed random variable with parameters \f$ r, \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.negative_binomial_cdf(
    x DOUBLE PRECISION,
    r DOUBLE PRECISION,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Negative binomial probability mass function
 *
 * @param x Random variate \f$ x \f$
 * @param r Total number \f$ r > 0 \f$ of successes in \f$ x + r \f$ trials
 *     (assuming success in the last trial)
 * @param sp Success probability \f$ \mathit{sp} \in (0,1] \f$ in each trial
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability mass function of
 *     a negative-binomially distributed random variable with parameters
 *     \f$ r, \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.negative_binomial_pmf(
    x INT4,
    r DOUBLE PRECISION,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Negative binomial quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param r Total number \f$ r > 0 \f$ of successes in \f$ x + r \f$ trials
 *     (assuming success in the last trial)
 * @param sp Success probability \f$ \mathit{sp} \in (0,1] \f$ in each trial
 * @return If \f$ p < 0.5 \f$ the maximum \f$ x \f$ such that
 *     \f$ p \geq \Pr[X \leq x] \f$. If \f$ p \geq 0.5 \f$ the minimum \f$ x \f$
 *     such that \f$ p \leq \Pr[X \leq x] \f$. Here, \f$ X \f$ is
 *     a negative-binomially distributed random variable with parameters
 *     \f$ r, \mathit{sp} \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.negative_binomial_quantile(
    p DOUBLE PRECISION,
    r DOUBLE PRECISION,
    sp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Noncentral beta cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param alpha Shape \f$ \alpha > 0 \f$
 * @param beta Shape \f$ \beta > 0 \f$
 * @param ncp Noncentrality parameter \f$ \delta \geq 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a noncentral-beta
 *     distributed random variable with shape parameters \f$ shape_1 \f$ and
 *     \f$ shape_2 \f$ and noncentrality parameter \f$ \delta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_beta_cdf(
    x DOUBLE PRECISION,
    alpha DOUBLE PRECISION,
    beta DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral beta probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param alpha Shape \f$ \alpha > 0 \f$
 * @param beta Shape \f$ \beta > 0 \f$
 * @param ncp Noncentrality parameter \f$ \delta \geq 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a noncentral-beta distributed random variable with shape parameters
 *     \f$ shape_1 \f$ and \f$ shape_2 \f$ and noncentrality parameter
 *     \f$ \delta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_beta_pdf(
    x DOUBLE PRECISION,
    alpha DOUBLE PRECISION,
    beta DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral beta quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param alpha Shape \f$ \alpha > 0 \f$
 * @param beta Shape \f$ \beta > 0 \f$
 * @param ncp Noncentrality parameter \f$ \delta \geq 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is
 *     a noncentral-beta distributed random variable with shape parameters
 *     \f$ shape_1 \f$ and \f$ shape_2 \f$ and noncentrality parameter
 *     \f$ \delta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_beta_quantile(
    p DOUBLE PRECISION,
    alpha DOUBLE PRECISION,
    beta DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Noncentral chi-squared cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @param ncp The noncentrality parameter \f$ \lambda \geq 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a noncentral-chi-squared
 *     distributed random variable with \f$ \nu \f$ degrees of freedom and
 *     noncentrality parameter \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_chi_squared_cdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral chi-squared distribution probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @param ncp The noncentrality parameter \f$ \lambda \geq 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a noncentral-chi-squared distributed random variable with \f$ \nu \f$
 *     degrees of freedom and noncentrality parameter \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_chi_squared_pdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral chi-squared distribution quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @param ncp The noncentrality parameter \f$ \lambda \geq 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     noncentral-chi-squared distributed random variable with \f$ \nu \f$
 *     degrees of freedom and noncentrality parameter \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_chi_squared_quantile(
    p DOUBLE PRECISION,
    df DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Noncentral Fisher F cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param df1 Degrees of freedom in numerator \f$ \nu_1 > 0 \f$
 * @param df2 Degrees of freedom in denominator \f$ \nu_1 > 0 \f$
 * @param ncp The noncentrality parameter \f$ \lambda \geq 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     noncentral Fisher F-distributed random variable with parameters
 *     \f$ \nu_1, \nu_2, \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_f_cdf(
    x DOUBLE PRECISION,
    df1 DOUBLE PRECISION,
    df2 DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral Fisher F probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param df1 Degrees of freedom in numerator \f$ \nu_1 > 0 \f$
 * @param df2 Degrees of freedom in denominator \f$ \nu_1 > 0 \f$
 * @param ncp The noncentrality parameter \f$ \lambda \geq 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of a
 *     noncentral Fisher F-distributed random variable with parameters
 *     \f$ \nu_1, \nu_2, \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_f_pdf(
    x DOUBLE PRECISION,
    df1 DOUBLE PRECISION,
    df2 DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral Fisher F quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param df1 Degrees of freedom in numerator \f$ \nu_1 > 0 \f$
 * @param df2 Degrees of freedom in denominator \f$ \nu_1 > 0 \f$
 * @param ncp The noncentrality parameter \f$ \lambda \geq 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     noncentral Fisher F-distributed random variable with parameters
 *     \f$ \nu_1, \nu_2, \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_f_quantile(
    p DOUBLE PRECISION,
    df1 DOUBLE PRECISION,
    df2 DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Noncentral Student-t cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @param ncp Noncentrality parameter \f$ \delta \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a noncentral Student's
 *     t-distributed random variable with \f$ \nu \f$ degrees of freedom and
 *     noncentrality parameter \f$ \delta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_t_cdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral Student-t probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @param ncp Noncentrality parameter \f$ \delta \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     noncentral Student's t-distributed random variable with \f$ \nu \f$
 *     degrees of freedom and noncentrality parameter \f$ \delta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_t_pdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Noncentral Student-t quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @param ncp Noncentrality parameter \f$ \delta \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     noncentral Student's t-distributed random variable with \f$ \nu \f$
 *     degrees of freedom and noncentrality parameter \f$ \delta \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.non_central_t_quantile(
    p DOUBLE PRECISION,
    df DOUBLE PRECISION,
	ncp DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Normal cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Mean \f$ \mu \f$
 * @param sd Standard deviation \f$ \sigma > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ T \f$ is a normally distributed
 *     random variable with mean \f$ \mu \f$ and variance \f$ \sigma^2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_cdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION /*+ DEFAULT 0 */,
    sd DOUBLE PRECISION  /*+ DEFAULT 1 */
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_cdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
IMMUTABLE
STRICT
LANGUAGE sql AS $$
    SELECT MADLIB_SCHEMA.normal_cdf($1, $2, 1)
$$;

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_cdf(
    x DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
IMMUTABLE
STRICT
LANGUAGE sql AS $$
    SELECT MADLIB_SCHEMA.normal_cdf($1, 0, 1)
$$;

/**
 * @brief Normal probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Mean \f$ \mu \f$
 * @param sd Standard deviation \f$ \sigma > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a normally distributed random variable with mean \f$ \mu \f$ and
 *     variance \f$ \sigma^2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_pdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION /*+ DEFAULT 0 */,
    sd DOUBLE PRECISION  /*+ DEFAULT 1 */
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_pdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
IMMUTABLE
STRICT
LANGUAGE sql AS $$
    SELECT MADLIB_SCHEMA.normal_pdf($1, $2, 1)
$$
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `');

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_pdf(
    x DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
IMMUTABLE
STRICT
LANGUAGE sql AS $$
    SELECT MADLIB_SCHEMA.normal_pdf($1, 0, 1)
$$
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `');

/**
 * @brief Normal quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param mean Mean \f$ \mu \f$
 * @param sd Standard deviation \f$ \sigma > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     normally distributed random variable with mean \f$ \mu \f$ and
 *     variance \f$ \sigma^2 \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_quantile(
    p DOUBLE PRECISION,
    mean DOUBLE PRECISION /*+ DEFAULT 0 */,
    sd DOUBLE PRECISION  /*+ DEFAULT 1 */
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_quantile(
    p DOUBLE PRECISION,
    mean DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
IMMUTABLE
STRICT
LANGUAGE sql AS $$
    SELECT MADLIB_SCHEMA.normal_quantile($1, $2, 1)
$$
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `');

CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.normal_quantile(
    p DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
IMMUTABLE
STRICT
LANGUAGE sql AS $$
    SELECT MADLIB_SCHEMA.normal_quantile($1, 0, 1)
$$
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `CONTAINS SQL', `');


/**
 * @brief Pareto cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Pareto-distributed random
 *     variable with shape and scale parameters \f$ \alpha \f$ and
 *     \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.pareto_cdf(
    x DOUBLE PRECISION,
    scale DOUBLE PRECISION,
    shape DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Pareto probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a Pareto-distributed random variable with shape and scale parameters
 *     \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.pareto_pdf(
    x DOUBLE PRECISION,
    scale DOUBLE PRECISION,
    shape DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Pareto quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     Pareto-distributed random variable with shape and scale parameters
 *     \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.pareto_quantile(
    p DOUBLE PRECISION,
    scale DOUBLE PRECISION,
    shape DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Poisson cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Average occurrence rate \f$ \lambda > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Poisson distributed random
 *     variable with mean \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.poisson_cdf(
    x DOUBLE PRECISION,
    mean DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Poisson probability mass function
 *
 * @param x Random variate \f$ x \f$
 * @param mean Average occurrence rate \f$ \lambda > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability mass function of a
 *     Poisson distributed random variable with mean \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.poisson_pmf(
    x INT4,
    mean DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Poisson quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param mean Average occurrence rate \f$ \lambda > 0 \f$
 * @return If \f$ p < 0.5 \f$ the maximum \f$ x \f$ such that
 *     \f$ p \geq \Pr[X \leq x] \f$. If \f$ p \geq 0.5 \f$ the minimum \f$ x \f$
 *     such that \f$ p \leq \Pr[X \leq x] \f$. Here, \f$ X \f$ is a
 *     Poisson distributed random variable with mean \f$ \lambda \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.poisson_quantile(
    p DOUBLE PRECISION,
    mean DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Rayleigh cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param scale Scale \f$ \sigma > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Rayleigh-distributed
 *     random variable with parameter \f$ \sigma \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.rayleigh_cdf(
    x DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Rayleigh probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param scale Scale \f$ \sigma > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a Rayleigh-distributed random variable with parameter \f$ \sigma \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.rayleigh_pdf(
    x DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Rayleigh quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param scale Scale \f$ \sigma > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     Rayleigh-distributed random variable with parameter \f$ \sigma \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.rayleigh_quantile(
    p DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Student's t cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a Student's t-distributed
 *     random variable with \f$ \nu \f$ degrees of freedom
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.students_t_cdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Student's t probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a Stundent's t-distributed random variable with \f$ \nu \f$ degrees of
 *     freedom
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.students_t_pdf(
    x DOUBLE PRECISION,
    df DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Student's t quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param df Degrees of freedom \f$ \nu > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     Student's t-distributed random variable with \f$ \nu \f$ degrees of
 *     freedom
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.students_t_quantile(
    p DOUBLE PRECISION,
    df DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Triangular cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param lower Lower bound \f$ a \f$
 * @param mode  Mode \f$ c \geq a \f$
 * @param upper Upper bound \f$ b \geq c \f$, where \f$ b > a \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a triangular distributed
 *     random variable with parameters \f$ a, b, c \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.triangular_cdf(
    x DOUBLE PRECISION,
    lower DOUBLE PRECISION,
    mode DOUBLE PRECISION,
    upper DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Triangular probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param lower Lower bound \f$ a \f$
 * @param mode  Mode \f$ c \geq a \f$
 * @param upper Upper bound \f$ b \geq c \f$, where \f$ b > a \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a triangular distributed random variable with parameters \f$ a, b, c \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.triangular_pdf(
    x DOUBLE PRECISION,
    lower DOUBLE PRECISION,
    mode DOUBLE PRECISION,
    upper DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Triangular quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param lower Lower bound \f$ a \f$
 * @param mode  Mode \f$ c \geq a \f$
 * @param upper Upper bound \f$ b \geq c \f$, where \f$ b > a \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     trianbular distributed random variable with parameters \f$ a, b, c \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.triangular_quantile(
    p DOUBLE PRECISION,
    lower DOUBLE PRECISION,
    mode DOUBLE PRECISION,
    upper DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Uniform cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param lower Lower bound \f$ a \f$
 * @param upper Upper bound \f$ b \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a uniform distributed random
 *     variable with support \f$ [a, b] \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.uniform_cdf(
    x DOUBLE PRECISION,
    lower DOUBLE PRECISION,
    upper DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Uniform probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param lower Lower bound \f$ a \f$
 * @param upper Upper bound \f$ b \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a uniform distributed random variable with support \f$ [a, b] \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.uniform_pdf(
    x DOUBLE PRECISION,
    lower DOUBLE PRECISION,
    upper DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Uniform quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param lower Lower bound \f$ a \f$
 * @param upper Upper bound \f$ b \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     uniform distributed random variable with support \f$ [a, b] \f$
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.uniform_quantile(
    p DOUBLE PRECISION,
    lower DOUBLE PRECISION,
    upper DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');


/**
 * @brief Weibull cumulative distribution function
 *
 * @param x Random variate \f$ x \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ \Pr[X \leq x] \f$ where \f$ X \f$ is a weibull distributed random
 *     variable with shape and scale parameters \f$ \alpha \f$ and
 *     \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.weibull_cdf(
    x DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Weibull probability density function
 *
 * @param x Random variate \f$ x \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ f(x) \f$ where \f$ f \f$ is the probability density function of
 *     a weibull distributed random variable with shape and scale parameters
 *     \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.weibull_pdf(
    x DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');

/**
 * @brief Weibull quantile function
 *
 * @param p Probability \f$ p \in [0,1] \f$
 * @param shape Shape \f$ \alpha > 0 \f$
 * @param scale Scale \f$ \beta > 0 \f$
 * @return \f$ x \f$ such that \f$ p = \Pr[X \leq x] \f$ where \f$ X \f$ is a
 *     weibull distributed random variable with shape and scale parameters
 *     \f$ \alpha \f$ and \f$ \beta \f$, respectively
 */
CREATE OR REPLACE FUNCTION MADLIB_SCHEMA.weibull_quantile(
    p DOUBLE PRECISION,
    shape DOUBLE PRECISION,
    scale DOUBLE PRECISION
) RETURNS DOUBLE PRECISION
AS 'MODULE_PATHNAME'
LANGUAGE C
IMMUTABLE STRICT
m4_ifdef(`__HAS_FUNCTION_PROPERTIES__', `NO SQL', `');