package scipy

Get an attribute of this module as a Py.Object.t. This is useful to pass a Python function to another function.

An alpha continuous random variable.

As an instance of the `rv_continuous` class, `alpha` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, loc=0, scale=1) Probability density function. logpdf(x, a, loc=0, scale=1) Log of the probability density function. cdf(x, a, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, loc=0, scale=1) Log of the survival function. ppf(q, a, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, loc=0, scale=1) Non-central moment of order n stats(a, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, loc=0, scale=1) Median of the distribution. mean(a, loc=0, scale=1) Mean of the distribution. var(a, loc=0, scale=1) Variance of the distribution. std(a, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `alpha` (1_, 2_) is:

.. math::

f(x, a) = \frac

x^2 \Phi(a) \sqrt{2\pi

}

* \exp(-\frac

(a-1/x)^2)

where :math:`\Phi` is the normal CDF, :math:`x > 0`, and :math:`a > 0`.

`alpha` takes ``a`` as a shape parameter.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``alpha.pdf(x, a, loc, scale)`` is identically equivalent to ``alpha.pdf(y, a) / scale`` with ``y = (x - loc) / scale``.

References ---------- .. 1 Johnson, Kotz, and Balakrishnan, 'Continuous Univariate Distributions, Volume 1', Second Edition, John Wiley and Sons, p. 173 (1994). .. 2 Anthony A. Salvia, 'Reliability applications of the Alpha Distribution', IEEE Transactions on Reliability, Vol. R-34, No. 3, pp. 251-252 (1985).

Examples -------- >>> from scipy.stats import alpha >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a = 3.57 >>> mean, var, skew, kurt = alpha.stats(a, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(alpha.ppf(0.01, a), ... alpha.ppf(0.99, a), 100) >>> ax.plot(x, alpha.pdf(x, a), ... 'r-', lw=5, alpha=0.6, label='alpha pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = alpha(a) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = alpha.ppf(0.001, 0.5, 0.999, a) >>> np.allclose(0.001, 0.5, 0.999, alpha.cdf(vals, a)) True

Generate random numbers:

>>> r = alpha.rvs(a, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Anderson-Darling test for data coming from a particular distribution.

The Anderson-Darling tests the null hypothesis that a sample is drawn from a population that follows a particular distribution. For the Anderson-Darling test, the critical values depend on which distribution is being tested against. This function works for normal, exponential, logistic, or Gumbel (Extreme Value Type I) distributions.

Parameters ---------- x : array_like Array of sample data. dist : 'norm','expon','logistic','gumbel','gumbel_l', gumbel_r', 'extreme1', optional the type of distribution to test against. The default is 'norm' and 'extreme1', 'gumbel_l' and 'gumbel' are synonyms.

Returns ------- statistic : float The Anderson-Darling test statistic. critical_values : list The critical values for this distribution. significance_level : list The significance levels for the corresponding critical values in percents. The function returns critical values for a differing set of significance levels depending on the distribution that is being tested against.

See Also -------- kstest : The Kolmogorov-Smirnov test for goodness-of-fit.

Notes ----- Critical values provided are for the following significance levels:

normal/exponenential 15%, 10%, 5%, 2.5%, 1% logistic 25%, 10%, 5%, 2.5%, 1%, 0.5% Gumbel 25%, 10%, 5%, 2.5%, 1%

If the returned statistic is larger than these critical values then for the corresponding significance level, the null hypothesis that the data come from the chosen distribution can be rejected. The returned statistic is referred to as 'A2' in the references.

References ---------- .. 1 https://www.itl.nist.gov/div898/handbook/prc/section2/prc213.htm .. 2 Stephens, M. A. (1974). EDF Statistics for Goodness of Fit and Some Comparisons, Journal of the American Statistical Association, Vol. 69, pp. 730-737. .. 3 Stephens, M. A. (1976). Asymptotic Results for Goodness-of-Fit Statistics with Unknown Parameters, Annals of Statistics, Vol. 4, pp. 357-369. .. 4 Stephens, M. A. (1977). Goodness of Fit for the Extreme Value Distribution, Biometrika, Vol. 64, pp. 583-588. .. 5 Stephens, M. A. (1977). Goodness of Fit with Special Reference to Tests for Exponentiality , Technical Report No. 262, Department of Statistics, Stanford University, Stanford, CA. .. 6 Stephens, M. A. (1979). Tests of Fit for the Logistic Distribution Based on the Empirical Distribution Function, Biometrika, Vol. 66, pp. 591-595.

The Anderson-Darling test for k-samples.

The k-sample Anderson-Darling test is a modification of the one-sample Anderson-Darling test. It tests the null hypothesis that k-samples are drawn from the same population without having to specify the distribution function of that population. The critical values depend on the number of samples.

Parameters ---------- samples : sequence of 1-D array_like Array of sample data in arrays. midrank : bool, optional Type of Anderson-Darling test which is computed. Default (True) is the midrank test applicable to continuous and discrete populations. If False, the right side empirical distribution is used.

Returns ------- statistic : float Normalized k-sample Anderson-Darling test statistic. critical_values : array The critical values for significance levels 25%, 10%, 5%, 2.5%, 1%, 0.5%, 0.1%. significance_level : float An approximate significance level at which the null hypothesis for the provided samples can be rejected. The value is floored / capped at 0.1% / 25%.

Raises ------ ValueError If less than 2 samples are provided, a sample is empty, or no distinct observations are in the samples.

See Also -------- ks_2samp : 2 sample Kolmogorov-Smirnov test anderson : 1 sample Anderson-Darling test

Notes ----- 1_ defines three versions of the k-sample Anderson-Darling test: one for continuous distributions and two for discrete distributions, in which ties between samples may occur. The default of this routine is to compute the version based on the midrank empirical distribution function. This test is applicable to continuous and discrete data. If midrank is set to False, the right side empirical distribution is used for a test for discrete data. According to 1_, the two discrete test statistics differ only slightly if a few collisions due to round-off errors occur in the test not adjusted for ties between samples.

The critical values corresponding to the significance levels from 0.01 to 0.25 are taken from 1_. p-values are floored / capped at 0.1% / 25%. Since the range of critical values might be extended in future releases, it is recommended not to test ``p == 0.25``, but rather ``p >= 0.25`` (analogously for the lower bound).

.. versionadded:: 0.14.0

References ---------- .. 1 Scholz, F. W and Stephens, M. A. (1987), K-Sample Anderson-Darling Tests, Journal of the American Statistical Association, Vol. 82, pp. 918-924.

Examples -------- >>> from scipy import stats >>> np.random.seed(314159)

The null hypothesis that the two random samples come from the same distribution can be rejected at the 5% level because the returned test value is greater than the critical value for 5% (1.961) but not at the 2.5% level. The interpolation gives an approximate significance level of 3.2%:

>>> stats.anderson_ksamp(np.random.normal(size=50), ... np.random.normal(loc=0.5, size=30)) (2.4615796189876105, array( 0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546), 0.03176687568842282)

The null hypothesis cannot be rejected for three samples from an identical distribution. The reported p-value (25%) has been capped and may not be very accurate (since it corresponds to the value 0.449 whereas the statistic is -0.731):

>>> stats.anderson_ksamp(np.random.normal(size=50), ... np.random.normal(size=30), np.random.normal(size=20)) (-0.73091722665244196, array( 0.44925884, 1.3052767 , 1.9434184 , 2.57696569, 3.41634856, 4.07210043, 5.56419101), 0.25)

An anglit continuous random variable.

As an instance of the `rv_continuous` class, `anglit` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, loc=0, scale=1) Probability density function. logpdf(x, loc=0, scale=1) Log of the probability density function. cdf(x, loc=0, scale=1) Cumulative distribution function. logcdf(x, loc=0, scale=1) Log of the cumulative distribution function. sf(x, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, loc=0, scale=1) Log of the survival function. ppf(q, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, loc=0, scale=1) Non-central moment of order n stats(loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(loc=0, scale=1) (Differential) entropy of the RV. fit(data, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(loc=0, scale=1) Median of the distribution. mean(loc=0, scale=1) Mean of the distribution. var(loc=0, scale=1) Variance of the distribution. std(loc=0, scale=1) Standard deviation of the distribution. interval(alpha, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `anglit` is:

.. math::

f(x) = \sin(2x + \pi/2) = \cos(2x)

for :math:`-\pi/4 \le x \le \pi/4`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``anglit.pdf(x, loc, scale)`` is identically equivalent to ``anglit.pdf(y) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import anglit >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> mean, var, skew, kurt = anglit.stats(moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(anglit.ppf(0.01), ... anglit.ppf(0.99), 100) >>> ax.plot(x, anglit.pdf(x), ... 'r-', lw=5, alpha=0.6, label='anglit pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = anglit() >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = anglit.ppf(0.001, 0.5, 0.999) >>> np.allclose(0.001, 0.5, 0.999, anglit.cdf(vals)) True

Generate random numbers:

>>> r = anglit.rvs(size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Perform the Ansari-Bradley test for equal scale parameters.

The Ansari-Bradley test is a non-parametric test for the equality of the scale parameter of the distributions from which two samples were drawn.

Parameters ---------- x, y : array_like Arrays of sample data.

Returns ------- statistic : float The Ansari-Bradley test statistic. pvalue : float The p-value of the hypothesis test.

See Also -------- fligner : A non-parametric test for the equality of k variances mood : A non-parametric test for the equality of two scale parameters

Notes ----- The p-value given is exact when the sample sizes are both less than 55 and there are no ties, otherwise a normal approximation for the p-value is used.

References ---------- .. 1 Sprent, Peter and N.C. Smeeton. Applied nonparametric statistical methods. 3rd ed. Chapman and Hall/CRC. 2001. Section 5.8.2.

An arcsine continuous random variable.

As an instance of the `rv_continuous` class, `arcsine` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, loc=0, scale=1) Probability density function. logpdf(x, loc=0, scale=1) Log of the probability density function. cdf(x, loc=0, scale=1) Cumulative distribution function. logcdf(x, loc=0, scale=1) Log of the cumulative distribution function. sf(x, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, loc=0, scale=1) Log of the survival function. ppf(q, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, loc=0, scale=1) Non-central moment of order n stats(loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(loc=0, scale=1) (Differential) entropy of the RV. fit(data, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(loc=0, scale=1) Median of the distribution. mean(loc=0, scale=1) Mean of the distribution. var(loc=0, scale=1) Variance of the distribution. std(loc=0, scale=1) Standard deviation of the distribution. interval(alpha, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `arcsine` is:

.. math::

f(x) = \frac

\pi \sqrt{x (1-x)

}

for :math:`0 < x < 1`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``arcsine.pdf(x, loc, scale)`` is identically equivalent to ``arcsine.pdf(y) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import arcsine >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> mean, var, skew, kurt = arcsine.stats(moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(arcsine.ppf(0.01), ... arcsine.ppf(0.99), 100) >>> ax.plot(x, arcsine.pdf(x), ... 'r-', lw=5, alpha=0.6, label='arcsine pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = arcsine() >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = arcsine.ppf(0.001, 0.5, 0.999) >>> np.allclose(0.001, 0.5, 0.999, arcsine.cdf(vals)) True

Generate random numbers:

>>> r = arcsine.rvs(size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Argus distribution

As an instance of the `rv_continuous` class, `argus` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(chi, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, chi, loc=0, scale=1) Probability density function. logpdf(x, chi, loc=0, scale=1) Log of the probability density function. cdf(x, chi, loc=0, scale=1) Cumulative distribution function. logcdf(x, chi, loc=0, scale=1) Log of the cumulative distribution function. sf(x, chi, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, chi, loc=0, scale=1) Log of the survival function. ppf(q, chi, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, chi, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, chi, loc=0, scale=1) Non-central moment of order n stats(chi, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(chi, loc=0, scale=1) (Differential) entropy of the RV. fit(data, chi, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(chi,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(chi, loc=0, scale=1) Median of the distribution. mean(chi, loc=0, scale=1) Mean of the distribution. var(chi, loc=0, scale=1) Variance of the distribution. std(chi, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, chi, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `argus` is:

.. math::

f(x, \chi) = \frac\chi^3\sqrt{2\pi \Psi(\chi)

}

x \sqrt

-x^2

\exp(-\chi^2 (1 - x^2)/2)

for :math:`0 < x < 1`, where

.. math::

\Psi(\chi) = \Phi(\chi) - \chi \phi(\chi) - 1/2

with :math:`\Phi` and :math:`\phi` being the CDF and PDF of a standard normal distribution, respectively.

`argus` takes :math:`\chi` as shape a parameter.

References ----------

.. 1 'ARGUS distribution', https://en.wikipedia.org/wiki/ARGUS_distribution

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``argus.pdf(x, chi, loc, scale)`` is identically equivalent to ``argus.pdf(y, chi) / scale`` with ``y = (x - loc) / scale``.

.. versionadded:: 0.19.0

Examples -------- >>> from scipy.stats import argus >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> chi = 1 >>> mean, var, skew, kurt = argus.stats(chi, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(argus.ppf(0.01, chi), ... argus.ppf(0.99, chi), 100) >>> ax.plot(x, argus.pdf(x, chi), ... 'r-', lw=5, alpha=0.6, label='argus pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = argus(chi) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = argus.ppf(0.001, 0.5, 0.999, chi) >>> np.allclose(0.001, 0.5, 0.999, argus.cdf(vals, chi)) True

Generate random numbers:

>>> r = argus.rvs(chi, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Perform Bartlett's test for equal variances.

Bartlett's test tests the null hypothesis that all input samples are from populations with equal variances. For samples from significantly non-normal populations, Levene's test `levene` is more robust.

Parameters ---------- sample1, sample2,... : array_like arrays of sample data. Only 1d arrays are accepted, they may have different lengths.

Returns ------- statistic : float The test statistic. pvalue : float The p-value of the test.

See Also -------- fligner : A non-parametric test for the equality of k variances levene : A robust parametric test for equality of k variances

Notes ----- Conover et al. (1981) examine many of the existing parametric and nonparametric tests by extensive simulations and they conclude that the tests proposed by Fligner and Killeen (1976) and Levene (1960) appear to be superior in terms of robustness of departures from normality and power (3_).

References ---------- .. 1 https://www.itl.nist.gov/div898/handbook/eda/section3/eda357.htm

.. 2 Snedecor, George W. and Cochran, William G. (1989), Statistical Methods, Eighth Edition, Iowa State University Press.

.. 3 Park, C. and Lindsay, B. G. (1999). Robust Scale Estimation and Hypothesis Testing based on Quadratic Inference Function. Technical Report #99-03, Center for Likelihood Studies, Pennsylvania State University.

.. 4 Bartlett, M. S. (1937). Properties of Sufficiency and Statistical Tests. Proceedings of the Royal Society of London. Series A, Mathematical and Physical Sciences, Vol. 160, No.901, pp. 268-282.

Bayesian confidence intervals for the mean, var, and std.

Parameters ---------- data : array_like Input data, if multi-dimensional it is flattened to 1-D by `bayes_mvs`. Requires 2 or more data points. alpha : float, optional Probability that the returned confidence interval contains the true parameter.

Returns ------- mean_cntr, var_cntr, std_cntr : tuple The three results are for the mean, variance and standard deviation, respectively. Each result is a tuple of the form::

(center, (lower, upper))

with `center` the mean of the conditional pdf of the value given the data, and `(lower, upper)` a confidence interval, centered on the median, containing the estimate to a probability ``alpha``.

See Also -------- mvsdist

Notes ----- Each tuple of mean, variance, and standard deviation estimates represent the (center, (lower, upper)) with center the mean of the conditional pdf of the value given the data and (lower, upper) is a confidence interval centered on the median, containing the estimate to a probability ``alpha``.

Converts data to 1-D and assumes all data has the same mean and variance. Uses Jeffrey's prior for variance and std.

Equivalent to ``tuple((x.mean(), x.interval(alpha)) for x in mvsdist(dat))``

References ---------- T.E. Oliphant, 'A Bayesian perspective on estimating mean, variance, and standard-deviation from data', https://scholarsarchive.byu.edu/facpub/278, 2006.

Examples -------- First a basic example to demonstrate the outputs:

>>> from scipy import stats >>> data = 6, 9, 12, 7, 8, 8, 13 >>> mean, var, std = stats.bayes_mvs(data) >>> mean Mean(statistic=9.0, minmax=(7.103650222612533, 10.896349777387467)) >>> var Variance(statistic=10.0, minmax=(3.176724206..., 24.45910382...)) >>> std Std_dev(statistic=2.9724954732045084, minmax=(1.7823367265645143, 4.945614605014631))

Now we generate some normally distributed random data, and get estimates of mean and standard deviation with 95% confidence intervals for those estimates:

>>> n_samples = 100000 >>> data = stats.norm.rvs(size=n_samples) >>> res_mean, res_var, res_std = stats.bayes_mvs(data, alpha=0.95)

>>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax = fig.add_subplot(111) >>> ax.hist(data, bins=100, density=True, label='Histogram of data') >>> ax.vlines(res_mean.statistic, 0, 0.5, colors='r', label='Estimated mean') >>> ax.axvspan(res_mean.minmax0,res_mean.minmax1, facecolor='r', ... alpha=0.2, label=r'Estimated mean (95% limits)') >>> ax.vlines(res_std.statistic, 0, 0.5, colors='g', label='Estimated scale') >>> ax.axvspan(res_std.minmax0,res_std.minmax1, facecolor='g', alpha=0.2, ... label=r'Estimated scale (95% limits)')

>>> ax.legend(fontsize=10) >>> ax.set_xlim(-4, 4) >>> ax.set_ylim(0, 0.5) >>> plt.show()

A Bernoulli discrete random variable.

As an instance of the `rv_discrete` class, `bernoulli` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(p, loc=0, size=1, random_state=None) Random variates. pmf(k, p, loc=0) Probability mass function. logpmf(k, p, loc=0) Log of the probability mass function. cdf(k, p, loc=0) Cumulative distribution function. logcdf(k, p, loc=0) Log of the cumulative distribution function. sf(k, p, loc=0) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(k, p, loc=0) Log of the survival function. ppf(q, p, loc=0) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, p, loc=0) Inverse survival function (inverse of ``sf``). stats(p, loc=0, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(p, loc=0) (Differential) entropy of the RV. expect(func, args=(p,), loc=0, lb=None, ub=None, conditional=False) Expected value of a function (of one argument) with respect to the distribution. median(p, loc=0) Median of the distribution. mean(p, loc=0) Mean of the distribution. var(p, loc=0) Variance of the distribution. std(p, loc=0) Standard deviation of the distribution. interval(alpha, p, loc=0) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability mass function for `bernoulli` is:

.. math::

f(k) = \begincases1-p &\textf k = 0\\ p &\textf k = 1\endcases

for :math:`k` in :math:`{0, 1}`.

`bernoulli` takes :math:`p` as shape parameter.

The probability mass function above is defined in the 'standardized' form. To shift distribution use the ``loc`` parameter. Specifically, ``bernoulli.pmf(k, p, loc)`` is identically equivalent to ``bernoulli.pmf(k - loc, p)``.

Examples -------- >>> from scipy.stats import bernoulli >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> p = 0.3 >>> mean, var, skew, kurt = bernoulli.stats(p, moments='mvsk')

Display the probability mass function (``pmf``):

>>> x = np.arange(bernoulli.ppf(0.01, p), ... bernoulli.ppf(0.99, p)) >>> ax.plot(x, bernoulli.pmf(x, p), 'bo', ms=8, label='bernoulli pmf') >>> ax.vlines(x, 0, bernoulli.pmf(x, p), colors='b', lw=5, alpha=0.5)

Alternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pmf``:

>>> rv = bernoulli(p) >>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1, ... label='frozen pmf') >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Check accuracy of ``cdf`` and ``ppf``:

>>> prob = bernoulli.cdf(x, p) >>> np.allclose(x, bernoulli.ppf(prob, p)) True

Generate random numbers:

>>> r = bernoulli.rvs(p, size=1000)

A beta continuous random variable.

As an instance of the `rv_continuous` class, `beta` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, b, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, b, loc=0, scale=1) Probability density function. logpdf(x, a, b, loc=0, scale=1) Log of the probability density function. cdf(x, a, b, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, b, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, b, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, b, loc=0, scale=1) Log of the survival function. ppf(q, a, b, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, b, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, b, loc=0, scale=1) Non-central moment of order n stats(a, b, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, b, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, b, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a, b), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, b, loc=0, scale=1) Median of the distribution. mean(a, b, loc=0, scale=1) Mean of the distribution. var(a, b, loc=0, scale=1) Variance of the distribution. std(a, b, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, b, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `beta` is:

.. math::

f(x, a, b) = \frac\Gamma(a+b) x^{a-1 (1-x)^-1

}

\Gamma(a) \Gamma(b)

for :math:`0 <= x <= 1`, :math:`a > 0`, :math:`b > 0`, where :math:`\Gamma` is the gamma function (`scipy.special.gamma`).

`beta` takes :math:`a` and :math:`b` as shape parameters.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``beta.pdf(x, a, b, loc, scale)`` is identically equivalent to ``beta.pdf(y, a, b) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import beta >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a, b = 2.31, 0.627 >>> mean, var, skew, kurt = beta.stats(a, b, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(beta.ppf(0.01, a, b), ... beta.ppf(0.99, a, b), 100) >>> ax.plot(x, beta.pdf(x, a, b), ... 'r-', lw=5, alpha=0.6, label='beta pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = beta(a, b) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = beta.ppf(0.001, 0.5, 0.999, a, b) >>> np.allclose(0.001, 0.5, 0.999, beta.cdf(vals, a, b)) True

Generate random numbers:

>>> r = beta.rvs(a, b, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A beta-binomial discrete random variable.

As an instance of the `rv_discrete` class, `betabinom` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(n, a, b, loc=0, size=1, random_state=None) Random variates. pmf(k, n, a, b, loc=0) Probability mass function. logpmf(k, n, a, b, loc=0) Log of the probability mass function. cdf(k, n, a, b, loc=0) Cumulative distribution function. logcdf(k, n, a, b, loc=0) Log of the cumulative distribution function. sf(k, n, a, b, loc=0) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(k, n, a, b, loc=0) Log of the survival function. ppf(q, n, a, b, loc=0) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, n, a, b, loc=0) Inverse survival function (inverse of ``sf``). stats(n, a, b, loc=0, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(n, a, b, loc=0) (Differential) entropy of the RV. expect(func, args=(n, a, b), loc=0, lb=None, ub=None, conditional=False) Expected value of a function (of one argument) with respect to the distribution. median(n, a, b, loc=0) Median of the distribution. mean(n, a, b, loc=0) Mean of the distribution. var(n, a, b, loc=0) Variance of the distribution. std(n, a, b, loc=0) Standard deviation of the distribution. interval(alpha, n, a, b, loc=0) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The beta-binomial distribution is a binomial distribution with a probability of success `p` that follows a beta distribution.

The probability mass function for `betabinom` is:

.. math::

f(k) = \binomnk \fracB(k + a, n - k + b)B(a, b)

for ``k`` in ``

, 1,..., n

``, :math:`n \geq 0`, :math:`a > 0`, :math:`b > 0`, where :math:`B(a, b)` is the beta function.

`betabinom` takes :math:`n`, :math:`a`, and :math:`b` as shape parameters.

References ---------- .. 1 https://en.wikipedia.org/wiki/Beta-binomial_distribution

The probability mass function above is defined in the 'standardized' form. To shift distribution use the ``loc`` parameter. Specifically, ``betabinom.pmf(k, n, a, b, loc)`` is identically equivalent to ``betabinom.pmf(k - loc, n, a, b)``.

.. versionadded:: 1.4.0

See Also -------- beta, binom

Examples -------- >>> from scipy.stats import betabinom >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> n, a, b = 5, 2.3, 0.63 >>> mean, var, skew, kurt = betabinom.stats(n, a, b, moments='mvsk')

Display the probability mass function (``pmf``):

>>> x = np.arange(betabinom.ppf(0.01, n, a, b), ... betabinom.ppf(0.99, n, a, b)) >>> ax.plot(x, betabinom.pmf(x, n, a, b), 'bo', ms=8, label='betabinom pmf') >>> ax.vlines(x, 0, betabinom.pmf(x, n, a, b), colors='b', lw=5, alpha=0.5)

Alternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pmf``:

>>> rv = betabinom(n, a, b) >>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1, ... label='frozen pmf') >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Check accuracy of ``cdf`` and ``ppf``:

>>> prob = betabinom.cdf(x, n, a, b) >>> np.allclose(x, betabinom.ppf(prob, n, a, b)) True

Generate random numbers:

>>> r = betabinom.rvs(n, a, b, size=1000)

A beta prime continuous random variable.

As an instance of the `rv_continuous` class, `betaprime` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, b, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, b, loc=0, scale=1) Probability density function. logpdf(x, a, b, loc=0, scale=1) Log of the probability density function. cdf(x, a, b, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, b, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, b, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, b, loc=0, scale=1) Log of the survival function. ppf(q, a, b, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, b, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, b, loc=0, scale=1) Non-central moment of order n stats(a, b, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, b, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, b, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a, b), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, b, loc=0, scale=1) Median of the distribution. mean(a, b, loc=0, scale=1) Mean of the distribution. var(a, b, loc=0, scale=1) Variance of the distribution. std(a, b, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, b, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `betaprime` is:

.. math::

f(x, a, b) = \fracx^{a-1 (1+x)^

a-b

}

}

\beta(a, b)

for :math:`x >= 0`, :math:`a > 0`, :math:`b > 0`, where :math:`\beta(a, b)` is the beta function (see `scipy.special.beta`).

`betaprime` takes ``a`` and ``b`` as shape parameters.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``betaprime.pdf(x, a, b, loc, scale)`` is identically equivalent to ``betaprime.pdf(y, a, b) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import betaprime >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a, b = 5, 6 >>> mean, var, skew, kurt = betaprime.stats(a, b, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(betaprime.ppf(0.01, a, b), ... betaprime.ppf(0.99, a, b), 100) >>> ax.plot(x, betaprime.pdf(x, a, b), ... 'r-', lw=5, alpha=0.6, label='betaprime pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = betaprime(a, b) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = betaprime.ppf(0.001, 0.5, 0.999, a, b) >>> np.allclose(0.001, 0.5, 0.999, betaprime.cdf(vals, a, b)) True

Generate random numbers:

>>> r = betaprime.rvs(a, b, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Compute a binned statistic for one or more sets of data.

This is a generalization of a histogram function. A histogram divides the space into bins, and returns the count of the number of points in each bin. This function allows the computation of the sum, mean, median, or other statistic of the values (or set of values) within each bin.

Parameters ---------- x : (N,) array_like A sequence of values to be binned. values : (N,) array_like or list of (N,) array_like The data on which the statistic will be computed. This must be the same shape as `x`, or a set of sequences - each the same shape as `x`. If `values` is a set of sequences, the statistic will be computed on each independently. statistic : string or callable, optional The statistic to compute (default is 'mean'). The following statistics are available:

* 'mean' : compute the mean of values for points within each bin. Empty bins will be represented by NaN. * 'std' : compute the standard deviation within each bin. This is implicitly calculated with ddof=0. * 'median' : compute the median of values for points within each bin. Empty bins will be represented by NaN. * 'count' : compute the count of points within each bin. This is identical to an unweighted histogram. `values` array is not referenced. * 'sum' : compute the sum of values for points within each bin. This is identical to a weighted histogram. * 'min' : compute the minimum of values for points within each bin. Empty bins will be represented by NaN. * 'max' : compute the maximum of values for point within each bin. Empty bins will be represented by NaN. * function : a user-defined function which takes a 1D array of values, and outputs a single numerical statistic. This function will be called on the values in each bin. Empty bins will be represented by function(), or NaN if this returns an error.

bins : int or sequence of scalars, optional If `bins` is an int, it defines the number of equal-width bins in the given range (10 by default). If `bins` is a sequence, it defines the bin edges, including the rightmost edge, allowing for non-uniform bin widths. Values in `x` that are smaller than lowest bin edge are assigned to bin number 0, values beyond the highest bin are assigned to ``bins-1``. If the bin edges are specified, the number of bins will be, (nx = len(bins)-1). range : (float, float) or (float, float), optional The lower and upper range of the bins. If not provided, range is simply ``(x.min(), x.max())``. Values outside the range are ignored.

Returns ------- statistic : array The values of the selected statistic in each bin. bin_edges : array of dtype float Return the bin edges ``(length(statistic)+1)``. binnumber: 1-D ndarray of ints Indices of the bins (corresponding to `bin_edges`) in which each value of `x` belongs. Same length as `values`. A binnumber of `i` means the corresponding value is between (bin_edgesi-1, bin_edgesi).

See Also -------- numpy.digitize, numpy.histogram, binned_statistic_2d, binned_statistic_dd

Notes ----- All but the last (righthand-most) bin is half-open. In other words, if `bins` is ``1, 2, 3, 4``, then the first bin is ``1, 2)`` (including 1, but excluding 2) and the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which *includes* 4. .. versionadded:: 0.11.0 Examples -------- >>> from scipy import stats >>> import matplotlib.pyplot as plt First some basic examples: Create two evenly spaced bins in the range of the given sample, and sum the corresponding values in each of those bins: >>> values = [1.0, 1.0, 2.0, 1.5, 3.0] >>> stats.binned_statistic([1, 1, 2, 5, 7], values, 'sum', bins=2) BinnedStatisticResult(statistic=array([4. , 4.5]), bin_edges=array([1., 4., 7.]), binnumber=array([1, 1, 1, 2, 2])) Multiple arrays of values can also be passed. The statistic is calculated on each set independently: >>> values = [[1.0, 1.0, 2.0, 1.5, 3.0], [2.0, 2.0, 4.0, 3.0, 6.0]] >>> stats.binned_statistic([1, 1, 2, 5, 7], values, 'sum', bins=2) BinnedStatisticResult(statistic=array([[4. , 4.5], [8. , 9. ]]), bin_edges=array([1., 4., 7.]), binnumber=array([1, 1, 1, 2, 2])) >>> stats.binned_statistic([1, 2, 1, 2, 4], np.arange(5), statistic='mean', ... bins=3) BinnedStatisticResult(statistic=array([1., 2., 4.]), bin_edges=array([1., 2., 3., 4.]), binnumber=array([1, 2, 1, 2, 3])) As a second example, we now generate some random data of sailing boat speed as a function of wind speed, and then determine how fast our boat is for certain wind speeds: >>> windspeed = 8 * np.random.rand(500) >>> boatspeed = .3 * windspeed**.5 + .2 * np.random.rand(500) >>> bin_means, bin_edges, binnumber = stats.binned_statistic(windspeed, ... boatspeed, statistic='median', bins=[1,2,3,4,5,6,7]) >>> plt.figure() >>> plt.plot(windspeed, boatspeed, 'b.', label='raw data') >>> plt.hlines(bin_means, bin_edges[:-1], bin_edges[1:], colors='g', lw=5, ... label='binned statistic of data') >>> plt.legend() Now we can use ``binnumber`` to select all datapoints with a windspeed below 1: >>> low_boatspeed = boatspeed[binnumber == 0] As a final example, we will use ``bin_edges`` and ``binnumber`` to make a plot of a distribution that shows the mean and distribution around that mean per bin, on top of a regular histogram and the probability distribution function: >>> x = np.linspace(0, 5, num=500) >>> x_pdf = stats.maxwell.pdf(x) >>> samples = stats.maxwell.rvs(size=10000) >>> bin_means, bin_edges, binnumber = stats.binned_statistic(x, x_pdf, ... statistic='mean', bins=25) >>> bin_width = (bin_edges[1] - bin_edges[0]) >>> bin_centers = bin_edges[1:] - bin_width/2 >>> plt.figure() >>> plt.hist(samples, bins=50, density=True, histtype='stepfilled', ... alpha=0.2, label='histogram of data') >>> plt.plot(x, x_pdf, 'r-', label='analytical pdf') >>> plt.hlines(bin_means, bin_edges[:-1], bin_edges[1:], colors='g', lw=2, ... label='binned statistic of data') >>> plt.plot((binnumber - 0.5) * bin_width, x_pdf, 'g.', alpha=0.5) >>> plt.legend(fontsize=10) >>> plt.show()

Compute a bidimensional binned statistic for one or more sets of data.

This is a generalization of a histogram2d function. A histogram divides the space into bins, and returns the count of the number of points in each bin. This function allows the computation of the sum, mean, median, or other statistic of the values (or set of values) within each bin.

Parameters ---------- x : (N,) array_like A sequence of values to be binned along the first dimension. y : (N,) array_like A sequence of values to be binned along the second dimension. values : (N,) array_like or list of (N,) array_like The data on which the statistic will be computed. This must be the same shape as `x`, or a list of sequences - each with the same shape as `x`. If `values` is such a list, the statistic will be computed on each independently. statistic : string or callable, optional The statistic to compute (default is 'mean'). The following statistics are available:

* 'mean' : compute the mean of values for points within each bin. Empty bins will be represented by NaN. * 'std' : compute the standard deviation within each bin. This is implicitly calculated with ddof=0. * 'median' : compute the median of values for points within each bin. Empty bins will be represented by NaN. * 'count' : compute the count of points within each bin. This is identical to an unweighted histogram. `values` array is not referenced. * 'sum' : compute the sum of values for points within each bin. This is identical to a weighted histogram. * 'min' : compute the minimum of values for points within each bin. Empty bins will be represented by NaN. * 'max' : compute the maximum of values for point within each bin. Empty bins will be represented by NaN. * function : a user-defined function which takes a 1D array of values, and outputs a single numerical statistic. This function will be called on the values in each bin. Empty bins will be represented by function(), or NaN if this returns an error.

bins : int or int, int or array_like or array, array, optional The bin specification:

* the number of bins for the two dimensions (nx = ny = bins), * the number of bins in each dimension (nx, ny = bins), * the bin edges for the two dimensions (x_edge = y_edge = bins), * the bin edges in each dimension (x_edge, y_edge = bins).

If the bin edges are specified, the number of bins will be, (nx = len(x_edge)-1, ny = len(y_edge)-1).

range : (2,2) array_like, optional The leftmost and rightmost edges of the bins along each dimension (if not specified explicitly in the `bins` parameters): [xmin, xmax], [ymin, ymax]. All values outside of this range will be considered outliers and not tallied in the histogram. expand_binnumbers : bool, optional 'False' (default): the returned `binnumber` is a shape (N,) array of linearized bin indices. 'True': the returned `binnumber` is 'unraveled' into a shape (2,N) ndarray, where each row gives the bin numbers in the corresponding dimension. See the `binnumber` returned value, and the `Examples` section.

.. versionadded:: 0.17.0

Returns ------- statistic : (nx, ny) ndarray The values of the selected statistic in each two-dimensional bin. x_edge : (nx + 1) ndarray The bin edges along the first dimension. y_edge : (ny + 1) ndarray The bin edges along the second dimension. binnumber : (N,) array of ints or (2,N) ndarray of ints This assigns to each element of `sample` an integer that represents the bin in which this observation falls. The representation depends on the `expand_binnumbers` argument. See `Notes` for details.

See Also -------- numpy.digitize, numpy.histogram2d, binned_statistic, binned_statistic_dd

Notes ----- Binedges: All but the last (righthand-most) bin is half-open. In other words, if `bins` is ``1, 2, 3, 4``, then the first bin is ``1, 2)`` (including 1, but excluding 2) and the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which *includes* 4. `binnumber`: This returned argument assigns to each element of `sample` an integer that represents the bin in which it belongs. The representation depends on the `expand_binnumbers` argument. If 'False' (default): The returned `binnumber` is a shape (N,) array of linearized indices mapping each element of `sample` to its corresponding bin (using row-major ordering). If 'True': The returned `binnumber` is a shape (2,N) ndarray where each row indicates bin placements for each dimension respectively. In each dimension, a binnumber of `i` means the corresponding value is between (D_edge[i-1], D_edge[i]), where 'D' is either 'x' or 'y'. .. versionadded:: 0.11.0 Examples -------- >>> from scipy import stats Calculate the counts with explicit bin-edges: >>> x = [0.1, 0.1, 0.1, 0.6] >>> y = [2.1, 2.6, 2.1, 2.1] >>> binx = [0.0, 0.5, 1.0] >>> biny = [2.0, 2.5, 3.0] >>> ret = stats.binned_statistic_2d(x, y, x, 'count', bins=[binx,biny]) >>> ret.statistic array([[2., 1.], [1., 0.]]) The bin in which each sample is placed is given by the `binnumber` returned parameter. By default, these are the linearized bin indices: >>> ret.binnumber array([5, 6, 5, 9]) The bin indices can also be expanded into separate entries for each dimension using the `expand_binnumbers` parameter: >>> ret = stats.binned_statistic_2d(x, y, x, 'count', bins=[binx,biny], ... expand_binnumbers=True) >>> ret.binnumber array([[1, 1, 1, 2], [1, 2, 1, 1]]) Which shows that the first three elements belong in the xbin 1, and the fourth into xbin 2; and so on for y.

Compute a multidimensional binned statistic for a set of data.

This is a generalization of a histogramdd function. A histogram divides the space into bins, and returns the count of the number of points in each bin. This function allows the computation of the sum, mean, median, or other statistic of the values within each bin.

Parameters ---------- sample : array_like Data to histogram passed as a sequence of N arrays of length D, or as an (N,D) array. values : (N,) array_like or list of (N,) array_like The data on which the statistic will be computed. This must be the same shape as `sample`, or a list of sequences - each with the same shape as `sample`. If `values` is such a list, the statistic will be computed on each independently. statistic : string or callable, optional The statistic to compute (default is 'mean'). The following statistics are available:

* 'mean' : compute the mean of values for points within each bin. Empty bins will be represented by NaN. * 'median' : compute the median of values for points within each bin. Empty bins will be represented by NaN. * 'count' : compute the count of points within each bin. This is identical to an unweighted histogram. `values` array is not referenced. * 'sum' : compute the sum of values for points within each bin. This is identical to a weighted histogram. * 'std' : compute the standard deviation within each bin. This is implicitly calculated with ddof=0. * 'min' : compute the minimum of values for points within each bin. Empty bins will be represented by NaN. * 'max' : compute the maximum of values for point within each bin. Empty bins will be represented by NaN. * function : a user-defined function which takes a 1D array of values, and outputs a single numerical statistic. This function will be called on the values in each bin. Empty bins will be represented by function(), or NaN if this returns an error.

bins : sequence or positive int, optional The bin specification must be in one of the following forms:

* A sequence of arrays describing the bin edges along each dimension. * The number of bins for each dimension (nx, ny, ... = bins). * The number of bins for all dimensions (nx = ny = ... = bins). range : sequence, optional A sequence of lower and upper bin edges to be used if the edges are not given explicitly in `bins`. Defaults to the minimum and maximum values along each dimension. expand_binnumbers : bool, optional 'False' (default): the returned `binnumber` is a shape (N,) array of linearized bin indices. 'True': the returned `binnumber` is 'unraveled' into a shape (D,N) ndarray, where each row gives the bin numbers in the corresponding dimension. See the `binnumber` returned value, and the `Examples` section of `binned_statistic_2d`. binned_statistic_result : binnedStatisticddResult Result of a previous call to the function in order to reuse bin edges and bin numbers with new values and/or a different statistic. To reuse bin numbers, `expand_binnumbers` must have been set to False (the default)

.. versionadded:: 0.17.0

Returns ------- statistic : ndarray, shape(nx1, nx2, nx3,...) The values of the selected statistic in each two-dimensional bin. bin_edges : list of ndarrays A list of D arrays describing the (nxi + 1) bin edges for each dimension. binnumber : (N,) array of ints or (D,N) ndarray of ints This assigns to each element of `sample` an integer that represents the bin in which this observation falls. The representation depends on the `expand_binnumbers` argument. See `Notes` for details.

See Also -------- numpy.digitize, numpy.histogramdd, binned_statistic, binned_statistic_2d

Notes ----- Binedges: All but the last (righthand-most) bin is half-open in each dimension. In other words, if `bins` is ``1, 2, 3, 4``, then the first bin is ``1, 2)`` (including 1, but excluding 2) and the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which *includes* 4. `binnumber`: This returned argument assigns to each element of `sample` an integer that represents the bin in which it belongs. The representation depends on the `expand_binnumbers` argument. If 'False' (default): The returned `binnumber` is a shape (N,) array of linearized indices mapping each element of `sample` to its corresponding bin (using row-major ordering). If 'True': The returned `binnumber` is a shape (D,N) ndarray where each row indicates bin placements for each dimension respectively. In each dimension, a binnumber of `i` means the corresponding value is between (bin_edges[D][i-1], bin_edges[D][i]), for each dimension 'D'. .. versionadded:: 0.11.0 Examples -------- >>> from scipy import stats >>> import matplotlib.pyplot as plt >>> from mpl_toolkits.mplot3d import Axes3D Take an array of 600 (x, y) coordinates as an example. `binned_statistic_dd` can handle arrays of higher dimension `D`. But a plot of dimension `D+1` is required. >>> mu = np.array([0., 1.]) >>> sigma = np.array([[1., -0.5],[-0.5, 1.5]]) >>> multinormal = stats.multivariate_normal(mu, sigma) >>> data = multinormal.rvs(size=600, random_state=235412) >>> data.shape (600, 2) Create bins and count how many arrays fall in each bin: >>> N = 60 >>> x = np.linspace(-3, 3, N) >>> y = np.linspace(-3, 4, N) >>> ret = stats.binned_statistic_dd(data, np.arange(600), bins=[x, y], ... statistic='count') >>> bincounts = ret.statistic Set the volume and the location of bars: >>> dx = x[1] - x[0] >>> dy = y[1] - y[0] >>> x, y = np.meshgrid(x[:-1]+dx/2, y[:-1]+dy/2) >>> z = 0 >>> bincounts = bincounts.ravel() >>> x = x.ravel() >>> y = y.ravel() >>> fig = plt.figure() >>> ax = fig.add_subplot(111, projection='3d') >>> with np.errstate(divide='ignore'): # silence random axes3d warning ... ax.bar3d(x, y, z, dx, dy, bincounts) Reuse bin numbers and bin edges with new values: >>> ret2 = stats.binned_statistic_dd(data, -np.arange(600), ... binned_statistic_result=ret, ... statistic='mean')

A binomial discrete random variable.

As an instance of the `rv_discrete` class, `binom` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(n, p, loc=0, size=1, random_state=None) Random variates. pmf(k, n, p, loc=0) Probability mass function. logpmf(k, n, p, loc=0) Log of the probability mass function. cdf(k, n, p, loc=0) Cumulative distribution function. logcdf(k, n, p, loc=0) Log of the cumulative distribution function. sf(k, n, p, loc=0) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(k, n, p, loc=0) Log of the survival function. ppf(q, n, p, loc=0) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, n, p, loc=0) Inverse survival function (inverse of ``sf``). stats(n, p, loc=0, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(n, p, loc=0) (Differential) entropy of the RV. expect(func, args=(n, p), loc=0, lb=None, ub=None, conditional=False) Expected value of a function (of one argument) with respect to the distribution. median(n, p, loc=0) Median of the distribution. mean(n, p, loc=0) Mean of the distribution. var(n, p, loc=0) Variance of the distribution. std(n, p, loc=0) Standard deviation of the distribution. interval(alpha, n, p, loc=0) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability mass function for `binom` is:

.. math::

f(k) = \binomnk p^k (1-p)^n-k

for ``k`` in ``

, 1,..., n

``.

`binom` takes ``n`` and ``p`` as shape parameters.

The probability mass function above is defined in the 'standardized' form. To shift distribution use the ``loc`` parameter. Specifically, ``binom.pmf(k, n, p, loc)`` is identically equivalent to ``binom.pmf(k - loc, n, p)``.

Examples -------- >>> from scipy.stats import binom >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> n, p = 5, 0.4 >>> mean, var, skew, kurt = binom.stats(n, p, moments='mvsk')

Display the probability mass function (``pmf``):

>>> x = np.arange(binom.ppf(0.01, n, p), ... binom.ppf(0.99, n, p)) >>> ax.plot(x, binom.pmf(x, n, p), 'bo', ms=8, label='binom pmf') >>> ax.vlines(x, 0, binom.pmf(x, n, p), colors='b', lw=5, alpha=0.5)

Alternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pmf``:

>>> rv = binom(n, p) >>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1, ... label='frozen pmf') >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Check accuracy of ``cdf`` and ``ppf``:

>>> prob = binom.cdf(x, n, p) >>> np.allclose(x, binom.ppf(prob, n, p)) True

Generate random numbers:

>>> r = binom.rvs(n, p, size=1000)

Perform a test that the probability of success is p.

This is an exact, two-sided test of the null hypothesis that the probability of success in a Bernoulli experiment is `p`.

Parameters ---------- x : int or array_like The number of successes, or if x has length 2, it is the number of successes and the number of failures. n : int The number of trials. This is ignored if x gives both the number of successes and failures. p : float, optional The hypothesized probability of success. ``0 <= p <= 1``. The default value is ``p = 0.5``. alternative : 'two-sided', 'greater', 'less', optional Indicates the alternative hypothesis. The default value is 'two-sided'.

Returns ------- p-value : float The p-value of the hypothesis test.

References ---------- .. 1 https://en.wikipedia.org/wiki/Binomial_test

Examples -------- >>> from scipy import stats

A car manufacturer claims that no more than 10% of their cars are unsafe. 15 cars are inspected for safety, 3 were found to be unsafe. Test the manufacturer's claim:

>>> stats.binom_test(3, n=15, p=0.1, alternative='greater') 0.18406106910639114

The null hypothesis cannot be rejected at the 5% level of significance because the returned p-value is greater than the critical value of 5%.

A Boltzmann (Truncated Discrete Exponential) random variable.

As an instance of the `rv_discrete` class, `boltzmann` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(lambda_, N, loc=0, size=1, random_state=None) Random variates. pmf(k, lambda_, N, loc=0) Probability mass function. logpmf(k, lambda_, N, loc=0) Log of the probability mass function. cdf(k, lambda_, N, loc=0) Cumulative distribution function. logcdf(k, lambda_, N, loc=0) Log of the cumulative distribution function. sf(k, lambda_, N, loc=0) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(k, lambda_, N, loc=0) Log of the survival function. ppf(q, lambda_, N, loc=0) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, lambda_, N, loc=0) Inverse survival function (inverse of ``sf``). stats(lambda_, N, loc=0, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(lambda_, N, loc=0) (Differential) entropy of the RV. expect(func, args=(lambda_, N), loc=0, lb=None, ub=None, conditional=False) Expected value of a function (of one argument) with respect to the distribution. median(lambda_, N, loc=0) Median of the distribution. mean(lambda_, N, loc=0) Mean of the distribution. var(lambda_, N, loc=0) Variance of the distribution. std(lambda_, N, loc=0) Standard deviation of the distribution. interval(alpha, lambda_, N, loc=0) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability mass function for `boltzmann` is:

.. math::

f(k) = (1-\exp(-\lambda)) \exp(-\lambda k) / (1-\exp(-\lambda N))

for :math:`k = 0,..., N-1`.

`boltzmann` takes :math:`\lambda > 0` and :math:`N > 0` as shape parameters.

The probability mass function above is defined in the 'standardized' form. To shift distribution use the ``loc`` parameter. Specifically, ``boltzmann.pmf(k, lambda_, N, loc)`` is identically equivalent to ``boltzmann.pmf(k - loc, lambda_, N)``.

Examples -------- >>> from scipy.stats import boltzmann >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> lambda_, N = 1.4, 19 >>> mean, var, skew, kurt = boltzmann.stats(lambda_, N, moments='mvsk')

Display the probability mass function (``pmf``):

>>> x = np.arange(boltzmann.ppf(0.01, lambda_, N), ... boltzmann.ppf(0.99, lambda_, N)) >>> ax.plot(x, boltzmann.pmf(x, lambda_, N), 'bo', ms=8, label='boltzmann pmf') >>> ax.vlines(x, 0, boltzmann.pmf(x, lambda_, N), colors='b', lw=5, alpha=0.5)

Alternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pmf``:

>>> rv = boltzmann(lambda_, N) >>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1, ... label='frozen pmf') >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Check accuracy of ``cdf`` and ``ppf``:

>>> prob = boltzmann.cdf(x, lambda_, N) >>> np.allclose(x, boltzmann.ppf(prob, lambda_, N)) True

Generate random numbers:

>>> r = boltzmann.rvs(lambda_, N, size=1000)

Return a dataset transformed by a Box-Cox power transformation.

Parameters ---------- x : ndarray Input array. Must be positive 1-dimensional. Must not be constant. lmbda : None, scalar, optional If `lmbda` is not None, do the transformation for that value.

If `lmbda` is None, find the lambda that maximizes the log-likelihood function and return it as the second output argument. alpha : None, float, optional If ``alpha`` is not None, return the ``100 * (1-alpha)%`` confidence interval for `lmbda` as the third output argument. Must be between 0.0 and 1.0.

Returns ------- boxcox : ndarray Box-Cox power transformed array. maxlog : float, optional If the `lmbda` parameter is None, the second returned argument is the lambda that maximizes the log-likelihood function. (min_ci, max_ci) : tuple of float, optional If `lmbda` parameter is None and ``alpha`` is not None, this returned tuple of floats represents the minimum and maximum confidence limits given ``alpha``.

See Also -------- probplot, boxcox_normplot, boxcox_normmax, boxcox_llf

Notes ----- The Box-Cox transform is given by::

y = (x**lmbda - 1) / lmbda, for lmbda > 0 log(x), for lmbda = 0

`boxcox` requires the input data to be positive. Sometimes a Box-Cox transformation provides a shift parameter to achieve this; `boxcox` does not. Such a shift parameter is equivalent to adding a positive constant to `x` before calling `boxcox`.

The confidence limits returned when ``alpha`` is provided give the interval where:

.. math::

llf(\hat\lambda) - llf(\lambda) < \frac

\chi^2(1 - \alpha, 1),

with ``llf`` the log-likelihood function and :math:`\chi^2` the chi-squared function.

References ---------- G.E.P. Box and D.R. Cox, 'An Analysis of Transformations', Journal of the Royal Statistical Society B, 26, 211-252 (1964).

Examples -------- >>> from scipy import stats >>> import matplotlib.pyplot as plt

We generate some random variates from a non-normal distribution and make a probability plot for it, to show it is non-normal in the tails:

>>> fig = plt.figure() >>> ax1 = fig.add_subplot(211) >>> x = stats.loggamma.rvs(5, size=500) + 5 >>> prob = stats.probplot(x, dist=stats.norm, plot=ax1) >>> ax1.set_xlabel('') >>> ax1.set_title('Probplot against normal distribution')

We now use `boxcox` to transform the data so it's closest to normal:

>>> ax2 = fig.add_subplot(212) >>> xt, _ = stats.boxcox(x) >>> prob = stats.probplot(xt, dist=stats.norm, plot=ax2) >>> ax2.set_title('Probplot after Box-Cox transformation')

>>> plt.show()

The boxcox log-likelihood function.

Parameters ---------- lmb : scalar Parameter for Box-Cox transformation. See `boxcox` for details. data : array_like Data to calculate Box-Cox log-likelihood for. If `data` is multi-dimensional, the log-likelihood is calculated along the first axis.

Returns ------- llf : float or ndarray Box-Cox log-likelihood of `data` given `lmb`. A float for 1-D `data`, an array otherwise.

See Also -------- boxcox, probplot, boxcox_normplot, boxcox_normmax

Notes ----- The Box-Cox log-likelihood function is defined here as

.. math::

llf = (\lambda - 1) \sum_i(\log(x_i)) - N/2 \log(\sum_i (y_i - \bary)^2 / N),

where ``y`` is the Box-Cox transformed input data ``x``.

Examples -------- >>> from scipy import stats >>> import matplotlib.pyplot as plt >>> from mpl_toolkits.axes_grid1.inset_locator import inset_axes >>> np.random.seed(1245)

Generate some random variates and calculate Box-Cox log-likelihood values for them for a range of ``lmbda`` values:

>>> x = stats.loggamma.rvs(5, loc=10, size=1000) >>> lmbdas = np.linspace(-2, 10) >>> llf = np.zeros(lmbdas.shape, dtype=float) >>> for ii, lmbda in enumerate(lmbdas): ... llfii = stats.boxcox_llf(lmbda, x)

Also find the optimal lmbda value with `boxcox`:

>>> x_most_normal, lmbda_optimal = stats.boxcox(x)

Plot the log-likelihood as function of lmbda. Add the optimal lmbda as a horizontal line to check that that's really the optimum:

>>> fig = plt.figure() >>> ax = fig.add_subplot(111) >>> ax.plot(lmbdas, llf, 'b.-') >>> ax.axhline(stats.boxcox_llf(lmbda_optimal, x), color='r') >>> ax.set_xlabel('lmbda parameter') >>> ax.set_ylabel('Box-Cox log-likelihood')

Now add some probability plots to show that where the log-likelihood is maximized the data transformed with `boxcox` looks closest to normal:

>>> locs = 3, 10, 4 # 'lower left', 'center', 'lower right' >>> for lmbda, loc in zip(-1, lmbda_optimal, 9, locs): ... xt = stats.boxcox(x, lmbda=lmbda) ... (osm, osr), (slope, intercept, r_sq) = stats.probplot(xt) ... ax_inset = inset_axes(ax, width='20%', height='20%', loc=loc) ... ax_inset.plot(osm, osr, 'c.', osm, slope*osm + intercept, 'k-') ... ax_inset.set_xticklabels() ... ax_inset.set_yticklabels() ... ax_inset.set_title(r'$\lambda=%1.2f$' % lmbda)

>>> plt.show()

Compute optimal Box-Cox transform parameter for input data.

Parameters ---------- x : array_like Input array. brack : 2-tuple, optional The starting interval for a downhill bracket search with `optimize.brent`. Note that this is in most cases not critical; the final result is allowed to be outside this bracket. method : str, optional The method to determine the optimal transform parameter (`boxcox` ``lmbda`` parameter). Options are:

'pearsonr' (default) Maximizes the Pearson correlation coefficient between ``y = boxcox(x)`` and the expected values for ``y`` if `x` would be normally-distributed.

'mle' Minimizes the log-likelihood `boxcox_llf`. This is the method used in `boxcox`.

'all' Use all optimization methods available, and return all results. Useful to compare different methods.

Returns ------- maxlog : float or ndarray The optimal transform parameter found. An array instead of a scalar for ``method='all'``.

See Also -------- boxcox, boxcox_llf, boxcox_normplot

Examples -------- >>> from scipy import stats >>> import matplotlib.pyplot as plt >>> np.random.seed(1234) # make this example reproducible

Generate some data and determine optimal ``lmbda`` in various ways:

>>> x = stats.loggamma.rvs(5, size=30) + 5 >>> y, lmax_mle = stats.boxcox(x) >>> lmax_pearsonr = stats.boxcox_normmax(x)

>>> lmax_mle 7.177... >>> lmax_pearsonr 7.916... >>> stats.boxcox_normmax(x, method='all') array( 7.91667384, 7.17718692)

>>> fig = plt.figure() >>> ax = fig.add_subplot(111) >>> prob = stats.boxcox_normplot(x, -10, 10, plot=ax) >>> ax.axvline(lmax_mle, color='r') >>> ax.axvline(lmax_pearsonr, color='g', ls='--')

>>> plt.show()

Compute parameters for a Box-Cox normality plot, optionally show it.

A Box-Cox normality plot shows graphically what the best transformation parameter is to use in `boxcox` to obtain a distribution that is close to normal.

Parameters ---------- x : array_like Input array. la, lb : scalar The lower and upper bounds for the ``lmbda`` values to pass to `boxcox` for Box-Cox transformations. These are also the limits of the horizontal axis of the plot if that is generated. plot : object, optional If given, plots the quantiles and least squares fit. `plot` is an object that has to have methods 'plot' and 'text'. The `matplotlib.pyplot` module or a Matplotlib Axes object can be used, or a custom object with the same methods. Default is None, which means that no plot is created. N : int, optional Number of points on the horizontal axis (equally distributed from `la` to `lb`).

Returns ------- lmbdas : ndarray The ``lmbda`` values for which a Box-Cox transform was done. ppcc : ndarray Probability Plot Correlelation Coefficient, as obtained from `probplot` when fitting the Box-Cox transformed input `x` against a normal distribution.

See Also -------- probplot, boxcox, boxcox_normmax, boxcox_llf, ppcc_max

Notes ----- Even if `plot` is given, the figure is not shown or saved by `boxcox_normplot`; ``plt.show()`` or ``plt.savefig('figname.png')`` should be used after calling `probplot`.

Examples -------- >>> from scipy import stats >>> import matplotlib.pyplot as plt

Generate some non-normally distributed data, and create a Box-Cox plot:

>>> x = stats.loggamma.rvs(5, size=500) + 5 >>> fig = plt.figure() >>> ax = fig.add_subplot(111) >>> prob = stats.boxcox_normplot(x, -20, 20, plot=ax)

Determine and plot the optimal ``lmbda`` to transform ``x`` and plot it in the same plot:

>>> _, maxlog = stats.boxcox(x) >>> ax.axvline(maxlog, color='r')

>>> plt.show()

A Bradford continuous random variable.

As an instance of the `rv_continuous` class, `bradford` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `bradford` is:

.. math::

f(x, c) = \fracc\log(1+c) (1+cx)

for :math:`0 <= x <= 1` and :math:`c > 0`.

`bradford` takes ``c`` as a shape parameter for :math:`c`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``bradford.pdf(x, c, loc, scale)`` is identically equivalent to ``bradford.pdf(y, c) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import bradford >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 0.299 >>> mean, var, skew, kurt = bradford.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(bradford.ppf(0.01, c), ... bradford.ppf(0.99, c), 100) >>> ax.plot(x, bradford.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='bradford pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = bradford(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = bradford.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, bradford.cdf(vals, c)) True

Generate random numbers:

>>> r = bradford.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Compute the Brunner-Munzel test on samples x and y.

The Brunner-Munzel test is a nonparametric test of the null hypothesis that when values are taken one by one from each group, the probabilities of getting large values in both groups are equal. Unlike the Wilcoxon-Mann-Whitney's U test, this does not require the assumption of equivariance of two groups. Note that this does not assume the distributions are same. This test works on two independent samples, which may have different sizes.

Parameters ---------- x, y : array_like Array of samples, should be one-dimensional. alternative : 'two-sided', 'less', 'greater', optional Defines the alternative hypothesis. The following options are available (default is 'two-sided'):

* 'two-sided' * 'less': one-sided * 'greater': one-sided distribution : 't', 'normal', optional Defines how to get the p-value. The following options are available (default is 't'):

* 't': get the p-value by t-distribution * 'normal': get the p-value by standard normal distribution. nan_policy : 'propagate', 'raise', 'omit', optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'):

* 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values

Returns ------- statistic : float The Brunner-Munzer W statistic. pvalue : float p-value assuming an t distribution. One-sided or two-sided, depending on the choice of `alternative` and `distribution`.

See Also -------- mannwhitneyu : Mann-Whitney rank test on two samples.

Notes ----- Brunner and Munzel recommended to estimate the p-value by t-distribution when the size of data is 50 or less. If the size is lower than 10, it would be better to use permuted Brunner Munzel test (see 2_).

References ---------- .. 1 Brunner, E. and Munzel, U. 'The nonparametric Benhrens-Fisher problem: Asymptotic theory and a small-sample approximation'. Biometrical Journal. Vol. 42(2000): 17-25. .. 2 Neubert, K. and Brunner, E. 'A studentized permutation test for the non-parametric Behrens-Fisher problem'. Computational Statistics and Data Analysis. Vol. 51(2007): 5192-5204.

Examples -------- >>> from scipy import stats >>> x1 = 1,2,1,1,1,1,1,1,1,1,2,4,1,1 >>> x2 = 3,3,4,3,1,2,3,1,1,5,4 >>> w, p_value = stats.brunnermunzel(x1, x2) >>> w 3.1374674823029505 >>> p_value 0.0057862086661515377

A Burr (Type III) continuous random variable.

As an instance of the `rv_continuous` class, `burr` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, d, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, d, loc=0, scale=1) Probability density function. logpdf(x, c, d, loc=0, scale=1) Log of the probability density function. cdf(x, c, d, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, d, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, d, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, d, loc=0, scale=1) Log of the survival function. ppf(q, c, d, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, d, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, d, loc=0, scale=1) Non-central moment of order n stats(c, d, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, d, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, d, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c, d), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, d, loc=0, scale=1) Median of the distribution. mean(c, d, loc=0, scale=1) Mean of the distribution. var(c, d, loc=0, scale=1) Variance of the distribution. std(c, d, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, d, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

See Also -------- fisk : a special case of either `burr` or `burr12` with ``d=1`` burr12 : Burr Type XII distribution mielke : Mielke Beta-Kappa / Dagum distribution

Notes ----- The probability density function for `burr` is:

.. math::

f(x, c, d) = c d x^

c - 1

}

/ (1 + x^

c

}

)^d + 1

for :math:`x >= 0` and :math:`c, d > 0`.

`burr` takes :math:`c` and :math:`d` as shape parameters.

This is the PDF corresponding to the third CDF given in Burr's list; specifically, it is equation (11) in Burr's paper 1_. The distribution is also commonly referred to as the Dagum distribution 2_. If the parameter :math:`c < 1` then the mean of the distribution does not exist and if :math:`c < 2` the variance does not exist 2_. The PDF is finite at the left endpoint :math:`x = 0` if :math:`c * d >= 1`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``burr.pdf(x, c, d, loc, scale)`` is identically equivalent to ``burr.pdf(y, c, d) / scale`` with ``y = (x - loc) / scale``.

References ---------- .. 1 Burr, I. W. 'Cumulative frequency functions', Annals of Mathematical Statistics, 13(2), pp 215-232 (1942). .. 2 https://en.wikipedia.org/wiki/Dagum_distribution .. 3 Kleiber, Christian. 'A guide to the Dagum distributions.' Modeling Income Distributions and Lorenz Curves pp 97-117 (2008).

Examples -------- >>> from scipy.stats import burr >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c, d = 10.5, 4.3 >>> mean, var, skew, kurt = burr.stats(c, d, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(burr.ppf(0.01, c, d), ... burr.ppf(0.99, c, d), 100) >>> ax.plot(x, burr.pdf(x, c, d), ... 'r-', lw=5, alpha=0.6, label='burr pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = burr(c, d) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = burr.ppf(0.001, 0.5, 0.999, c, d) >>> np.allclose(0.001, 0.5, 0.999, burr.cdf(vals, c, d)) True

Generate random numbers:

>>> r = burr.rvs(c, d, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A Burr (Type XII) continuous random variable.

As an instance of the `rv_continuous` class, `burr12` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, d, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, d, loc=0, scale=1) Probability density function. logpdf(x, c, d, loc=0, scale=1) Log of the probability density function. cdf(x, c, d, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, d, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, d, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, d, loc=0, scale=1) Log of the survival function. ppf(q, c, d, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, d, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, d, loc=0, scale=1) Non-central moment of order n stats(c, d, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, d, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, d, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c, d), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, d, loc=0, scale=1) Median of the distribution. mean(c, d, loc=0, scale=1) Mean of the distribution. var(c, d, loc=0, scale=1) Variance of the distribution. std(c, d, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, d, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

See Also -------- fisk : a special case of either `burr` or `burr12` with ``d=1`` burr : Burr Type III distribution

Notes ----- The probability density function for `burr` is:

.. math::

f(x, c, d) = c d x^c-1 / (1 + x^c)^d + 1

for :math:`x >= 0` and :math:`c, d > 0`.

`burr12` takes ``c`` and ``d`` as shape parameters for :math:`c` and :math:`d`.

This is the PDF corresponding to the twelfth CDF given in Burr's list; specifically, it is equation (20) in Burr's paper 1_.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``burr12.pdf(x, c, d, loc, scale)`` is identically equivalent to ``burr12.pdf(y, c, d) / scale`` with ``y = (x - loc) / scale``.

The Burr type 12 distribution is also sometimes referred to as the Singh-Maddala distribution from NIST 2_.

References ---------- .. 1 Burr, I. W. 'Cumulative frequency functions', Annals of Mathematical Statistics, 13(2), pp 215-232 (1942).

.. 2 https://www.itl.nist.gov/div898/software/dataplot/refman2/auxillar/b12pdf.htm

.. 3 'Burr distribution', https://en.wikipedia.org/wiki/Burr_distribution

Examples -------- >>> from scipy.stats import burr12 >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c, d = 10, 4 >>> mean, var, skew, kurt = burr12.stats(c, d, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(burr12.ppf(0.01, c, d), ... burr12.ppf(0.99, c, d), 100) >>> ax.plot(x, burr12.pdf(x, c, d), ... 'r-', lw=5, alpha=0.6, label='burr12 pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = burr12(c, d) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = burr12.ppf(0.001, 0.5, 0.999, c, d) >>> np.allclose(0.001, 0.5, 0.999, burr12.cdf(vals, c, d)) True

Generate random numbers:

>>> r = burr12.rvs(c, d, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A Cauchy continuous random variable.

As an instance of the `rv_continuous` class, `cauchy` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, loc=0, scale=1) Probability density function. logpdf(x, loc=0, scale=1) Log of the probability density function. cdf(x, loc=0, scale=1) Cumulative distribution function. logcdf(x, loc=0, scale=1) Log of the cumulative distribution function. sf(x, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, loc=0, scale=1) Log of the survival function. ppf(q, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, loc=0, scale=1) Non-central moment of order n stats(loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(loc=0, scale=1) (Differential) entropy of the RV. fit(data, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(loc=0, scale=1) Median of the distribution. mean(loc=0, scale=1) Mean of the distribution. var(loc=0, scale=1) Variance of the distribution. std(loc=0, scale=1) Standard deviation of the distribution. interval(alpha, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `cauchy` is

.. math::

f(x) = \frac

\pi (1 + x^2)

for a real number :math:`x`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``cauchy.pdf(x, loc, scale)`` is identically equivalent to ``cauchy.pdf(y) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import cauchy >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> mean, var, skew, kurt = cauchy.stats(moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(cauchy.ppf(0.01), ... cauchy.ppf(0.99), 100) >>> ax.plot(x, cauchy.pdf(x), ... 'r-', lw=5, alpha=0.6, label='cauchy pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = cauchy() >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = cauchy.ppf(0.001, 0.5, 0.999) >>> np.allclose(0.001, 0.5, 0.999, cauchy.cdf(vals)) True

Generate random numbers:

>>> r = cauchy.rvs(size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A chi continuous random variable.

As an instance of the `rv_continuous` class, `chi` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(df, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, df, loc=0, scale=1) Probability density function. logpdf(x, df, loc=0, scale=1) Log of the probability density function. cdf(x, df, loc=0, scale=1) Cumulative distribution function. logcdf(x, df, loc=0, scale=1) Log of the cumulative distribution function. sf(x, df, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, df, loc=0, scale=1) Log of the survival function. ppf(q, df, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, df, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, df, loc=0, scale=1) Non-central moment of order n stats(df, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(df, loc=0, scale=1) (Differential) entropy of the RV. fit(data, df, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(df,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(df, loc=0, scale=1) Median of the distribution. mean(df, loc=0, scale=1) Mean of the distribution. var(df, loc=0, scale=1) Variance of the distribution. std(df, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, df, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `chi` is:

.. math::

f(x, k) = \frac

^k/2-1 \Gamma \left( k/2 \right)

x^k-1 \exp \left( -x^2/2 \right)

for :math:`x >= 0` and :math:`k > 0` (degrees of freedom, denoted ``df`` in the implementation). :math:`\Gamma` is the gamma function (`scipy.special.gamma`).

Special cases of `chi` are:

• ``chi(1, loc, scale)`` is equivalent to `halfnorm`
• ``chi(2, 0, scale)`` is equivalent to `rayleigh`
• ``chi(3, 0, scale)`` is equivalent to `maxwell`

`chi` takes ``df`` as a shape parameter.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``chi.pdf(x, df, loc, scale)`` is identically equivalent to ``chi.pdf(y, df) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import chi >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> df = 78 >>> mean, var, skew, kurt = chi.stats(df, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(chi.ppf(0.01, df), ... chi.ppf(0.99, df), 100) >>> ax.plot(x, chi.pdf(x, df), ... 'r-', lw=5, alpha=0.6, label='chi pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = chi(df) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = chi.ppf(0.001, 0.5, 0.999, df) >>> np.allclose(0.001, 0.5, 0.999, chi.cdf(vals, df)) True

Generate random numbers:

>>> r = chi.rvs(df, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A chi-squared continuous random variable.

As an instance of the `rv_continuous` class, `chi2` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(df, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, df, loc=0, scale=1) Probability density function. logpdf(x, df, loc=0, scale=1) Log of the probability density function. cdf(x, df, loc=0, scale=1) Cumulative distribution function. logcdf(x, df, loc=0, scale=1) Log of the cumulative distribution function. sf(x, df, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, df, loc=0, scale=1) Log of the survival function. ppf(q, df, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, df, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, df, loc=0, scale=1) Non-central moment of order n stats(df, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(df, loc=0, scale=1) (Differential) entropy of the RV. fit(data, df, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(df,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(df, loc=0, scale=1) Median of the distribution. mean(df, loc=0, scale=1) Mean of the distribution. var(df, loc=0, scale=1) Variance of the distribution. std(df, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, df, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `chi2` is:

.. math::

f(x, k) = \frac

^k/2 \Gamma \left( k/2 \right)

x^k/2-1 \exp \left( -x/2 \right)

for :math:`x > 0` and :math:`k > 0` (degrees of freedom, denoted ``df`` in the implementation).

`chi2` takes ``df`` as a shape parameter.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``chi2.pdf(x, df, loc, scale)`` is identically equivalent to ``chi2.pdf(y, df) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import chi2 >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> df = 55 >>> mean, var, skew, kurt = chi2.stats(df, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(chi2.ppf(0.01, df), ... chi2.ppf(0.99, df), 100) >>> ax.plot(x, chi2.pdf(x, df), ... 'r-', lw=5, alpha=0.6, label='chi2 pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = chi2(df) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = chi2.ppf(0.001, 0.5, 0.999, df) >>> np.allclose(0.001, 0.5, 0.999, chi2.cdf(vals, df)) True

Generate random numbers:

>>> r = chi2.rvs(df, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Chi-square test of independence of variables in a contingency table.

This function computes the chi-square statistic and p-value for the hypothesis test of independence of the observed frequencies in the contingency table 1_ `observed`. The expected frequencies are computed based on the marginal sums under the assumption of independence; see `scipy.stats.contingency.expected_freq`. The number of degrees of freedom is (expressed using numpy functions and attributes)::

dof = observed.size - sum(observed.shape) + observed.ndim - 1

Parameters ---------- observed : array_like The contingency table. The table contains the observed frequencies (i.e. number of occurrences) in each category. In the two-dimensional case, the table is often described as an 'R x C table'. correction : bool, optional If True, *and* the degrees of freedom is 1, apply Yates' correction for continuity. The effect of the correction is to adjust each observed value by 0.5 towards the corresponding expected value. lambda_ : float or str, optional. By default, the statistic computed in this test is Pearson's chi-squared statistic 2_. `lambda_` allows a statistic from the Cressie-Read power divergence family 3_ to be used instead. See `power_divergence` for details.

Returns ------- chi2 : float The test statistic. p : float The p-value of the test dof : int Degrees of freedom expected : ndarray, same shape as `observed` The expected frequencies, based on the marginal sums of the table.

See Also -------- contingency.expected_freq fisher_exact chisquare power_divergence

Notes ----- An often quoted guideline for the validity of this calculation is that the test should be used only if the observed and expected frequencies in each cell are at least 5.

This is a test for the independence of different categories of a population. The test is only meaningful when the dimension of `observed` is two or more. Applying the test to a one-dimensional table will always result in `expected` equal to `observed` and a chi-square statistic equal to 0.

This function does not handle masked arrays, because the calculation does not make sense with missing values.

Like stats.chisquare, this function computes a chi-square statistic; the convenience this function provides is to figure out the expected frequencies and degrees of freedom from the given contingency table. If these were already known, and if the Yates' correction was not required, one could use stats.chisquare. That is, if one calls::

chi2, p, dof, ex = chi2_contingency(obs, correction=False)

then the following is true::

(chi2, p) == stats.chisquare(obs.ravel(), f_exp=ex.ravel(), ddof=obs.size - 1 - dof)

The `lambda_` argument was added in version 0.13.0 of scipy.

References ---------- .. 1 'Contingency table', https://en.wikipedia.org/wiki/Contingency_table .. 2 'Pearson's chi-squared test', https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test .. 3 Cressie, N. and Read, T. R. C., 'Multinomial Goodness-of-Fit Tests', J. Royal Stat. Soc. Series B, Vol. 46, No. 3 (1984), pp. 440-464.

Examples -------- A two-way example (2 x 3):

>>> from scipy.stats import chi2_contingency >>> obs = np.array([10, 10, 20], [20, 20, 20]) >>> chi2_contingency(obs) (2.7777777777777777, 0.24935220877729619, 2, array([ 12., 12., 16.], [ 18., 18., 24.]))

Perform the test using the log-likelihood ratio (i.e. the 'G-test') instead of Pearson's chi-squared statistic.

>>> g, p, dof, expctd = chi2_contingency(obs, lambda_='log-likelihood') >>> g, p (2.7688587616781319, 0.25046668010954165)

A four-way example (2 x 2 x 2 x 2):

>>> obs = np.array( ... [[[12, 17], ... [11, 16]], ... [[11, 12], ... [15, 16]]], ... [[[23, 15], ... [30, 22]], ... [[14, 17], ... [15, 16]]]) >>> chi2_contingency(obs) (8.7584514426741897, 0.64417725029295503, 11, array([[[ 14.15462386, 14.15462386], [ 16.49423111, 16.49423111]], [[ 11.2461395 , 11.2461395 ], [ 13.10500554, 13.10500554]]], [[[ 19.5591166 , 19.5591166 ], [ 22.79202844, 22.79202844]], [[ 15.54012004, 15.54012004], [ 18.10873492, 18.10873492]]]))

Calculate a one-way chi-square test.

The chi-square test tests the null hypothesis that the categorical data has the given frequencies.

Parameters ---------- f_obs : array_like Observed frequencies in each category. f_exp : array_like, optional Expected frequencies in each category. By default the categories are assumed to be equally likely. ddof : int, optional 'Delta degrees of freedom': adjustment to the degrees of freedom for the p-value. The p-value is computed using a chi-squared distribution with ``k - 1 - ddof`` degrees of freedom, where `k` is the number of observed frequencies. The default value of `ddof` is 0. axis : int or None, optional The axis of the broadcast result of `f_obs` and `f_exp` along which to apply the test. If axis is None, all values in `f_obs` are treated as a single data set. Default is 0.

Returns ------- chisq : float or ndarray The chi-squared test statistic. The value is a float if `axis` is None or `f_obs` and `f_exp` are 1-D. p : float or ndarray The p-value of the test. The value is a float if `ddof` and the return value `chisq` are scalars.

See Also -------- scipy.stats.power_divergence

Notes ----- This test is invalid when the observed or expected frequencies in each category are too small. A typical rule is that all of the observed and expected frequencies should be at least 5.

The default degrees of freedom, k-1, are for the case when no parameters of the distribution are estimated. If p parameters are estimated by efficient maximum likelihood then the correct degrees of freedom are k-1-p. If the parameters are estimated in a different way, then the dof can be between k-1-p and k-1. However, it is also possible that the asymptotic distribution is not chi-square, in which case this test is not appropriate.

References ---------- .. 1 Lowry, Richard. 'Concepts and Applications of Inferential Statistics'. Chapter 8. https://web.archive.org/web/20171022032306/http://vassarstats.net:80/textbook/ch8pt1.html .. 2 'Chi-squared test', https://en.wikipedia.org/wiki/Chi-squared_test

Examples -------- When just `f_obs` is given, it is assumed that the expected frequencies are uniform and given by the mean of the observed frequencies.

>>> from scipy.stats import chisquare >>> chisquare(16, 18, 16, 14, 12, 12) (2.0, 0.84914503608460956)

With `f_exp` the expected frequencies can be given.

>>> chisquare(16, 18, 16, 14, 12, 12, f_exp=16, 16, 16, 16, 16, 8) (3.5, 0.62338762774958223)

When `f_obs` is 2-D, by default the test is applied to each column.

>>> obs = np.array([16, 18, 16, 14, 12, 12], [32, 24, 16, 28, 20, 24]).T >>> obs.shape (6, 2) >>> chisquare(obs) (array( 2. , 6.66666667), array( 0.84914504, 0.24663415))

By setting ``axis=None``, the test is applied to all data in the array, which is equivalent to applying the test to the flattened array.

>>> chisquare(obs, axis=None) (23.31034482758621, 0.015975692534127565) >>> chisquare(obs.ravel()) (23.31034482758621, 0.015975692534127565)

`ddof` is the change to make to the default degrees of freedom.

>>> chisquare(16, 18, 16, 14, 12, 12, ddof=1) (2.0, 0.73575888234288467)

The calculation of the p-values is done by broadcasting the chi-squared statistic with `ddof`.

>>> chisquare(16, 18, 16, 14, 12, 12, ddof=0,1,2) (2.0, array( 0.84914504, 0.73575888, 0.5724067 ))

`f_obs` and `f_exp` are also broadcast. In the following, `f_obs` has shape (6,) and `f_exp` has shape (2, 6), so the result of broadcasting `f_obs` and `f_exp` has shape (2, 6). To compute the desired chi-squared statistics, we use ``axis=1``:

>>> chisquare(16, 18, 16, 14, 12, 12, ... f_exp=[16, 16, 16, 16, 16, 8], [8, 20, 20, 16, 12, 12], ... axis=1) (array( 3.5 , 9.25), array( 0.62338763, 0.09949846))

Compute the circular mean for samples in a range.

Parameters ---------- samples : array_like Input array. high : float or int, optional High boundary for circular mean range. Default is ``2*pi``. low : float or int, optional Low boundary for circular mean range. Default is 0. axis : int, optional Axis along which means are computed. The default is to compute the mean of the flattened array. nan_policy : 'propagate', 'raise', 'omit', optional Defines how to handle when input contains nan. 'propagate' returns nan, 'raise' throws an error, 'omit' performs the calculations ignoring nan values. Default is 'propagate'.

Returns ------- circmean : float Circular mean.

Examples -------- >>> from scipy.stats import circmean >>> circmean(0.1, 2*np.pi+0.2, 6*np.pi+0.3) 0.2

>>> from scipy.stats import circmean >>> circmean(0.2, 1.4, 2.6, high = 1, low = 0) 0.4

Compute the circular standard deviation for samples assumed to be in the range low to high.

Parameters ---------- samples : array_like Input array. high : float or int, optional High boundary for circular standard deviation range. Default is ``2*pi``. low : float or int, optional Low boundary for circular standard deviation range. Default is 0. axis : int, optional Axis along which standard deviations are computed. The default is to compute the standard deviation of the flattened array. nan_policy : 'propagate', 'raise', 'omit', optional Defines how to handle when input contains nan. 'propagate' returns nan, 'raise' throws an error, 'omit' performs the calculations ignoring nan values. Default is 'propagate'.

Returns ------- circstd : float Circular standard deviation.

Notes ----- This uses a definition of circular standard deviation that in the limit of small angles returns a number close to the 'linear' standard deviation.

Examples -------- >>> from scipy.stats import circstd >>> circstd(0, 0.1*np.pi/2, 0.001*np.pi, 0.03*np.pi/2) 0.063564063306

Compute the circular variance for samples assumed to be in a range.

Parameters ---------- samples : array_like Input array. high : float or int, optional High boundary for circular variance range. Default is ``2*pi``. low : float or int, optional Low boundary for circular variance range. Default is 0. axis : int, optional Axis along which variances are computed. The default is to compute the variance of the flattened array. nan_policy : 'propagate', 'raise', 'omit', optional Defines how to handle when input contains nan. 'propagate' returns nan, 'raise' throws an error, 'omit' performs the calculations ignoring nan values. Default is 'propagate'.

Returns ------- circvar : float Circular variance.

Notes ----- This uses a definition of circular variance that in the limit of small angles returns a number close to the 'linear' variance.

Examples -------- >>> from scipy.stats import circvar >>> circvar(0, 2*np.pi/3, 5*np.pi/3) 2.19722457734

Combine p-values from independent tests bearing upon the same hypothesis.

Parameters ---------- pvalues : array_like, 1-D Array of p-values assumed to come from independent tests. method : 'fisher', 'pearson', 'tippett', 'stouffer', 'mudholkar_george', optional Name of method to use to combine p-values. The following methods are available (default is 'fisher'):

* 'fisher': Fisher's method (Fisher's combined probability test), the sum of the logarithm of the p-values * 'pearson': Pearson's method (similar to Fisher's but uses sum of the complement of the p-values inside the logarithms) * 'tippett': Tippett's method (minimum of p-values) * 'stouffer': Stouffer's Z-score method * 'mudholkar_george': the difference of Fisher's and Pearson's methods divided by 2 weights : array_like, 1-D, optional Optional array of weights used only for Stouffer's Z-score method.

Returns ------- statistic: float The statistic calculated by the specified method. pval: float The combined p-value.

Notes ----- Fisher's method (also known as Fisher's combined probability test) 1_ uses a chi-squared statistic to compute a combined p-value. The closely related Stouffer's Z-score method 2_ uses Z-scores rather than p-values. The advantage of Stouffer's method is that it is straightforward to introduce weights, which can make Stouffer's method more powerful than Fisher's method when the p-values are from studies of different size 6_ 7_. The Pearson's method uses :math:`log(1-p_i)` inside the sum whereas Fisher's method uses :math:`log(p_i)` 4_. For Fisher's and Pearson's method, the sum of the logarithms is multiplied by -2 in the implementation. This quantity has a chi-square distribution that determines the p-value. The `mudholkar_george` method is the difference of the Fisher's and Pearson's test statistics, each of which include the -2 factor 4_. However, the `mudholkar_george` method does not include these -2 factors. The test statistic of `mudholkar_george` is the sum of logisitic random variables and equation 3.6 in 3_ is used to approximate the p-value based on Student's t-distribution.

Fisher's method may be extended to combine p-values from dependent tests 5_. Extensions such as Brown's method and Kost's method are not currently implemented.

.. versionadded:: 0.15.0

References ---------- .. 1 https://en.wikipedia.org/wiki/Fisher%27s_method .. 2 https://en.wikipedia.org/wiki/Fisher%27s_method#Relation_to_Stouffer.27s_Z-score_method .. 3 George, E. O., and G. S. Mudholkar. 'On the convolution of logistic random variables.' Metrika 30.1 (1983): 1-13. .. 4 Heard, N. and Rubin-Delanchey, P. 'Choosing between methods of combining p-values.' Biometrika 105.1 (2018): 239-246. .. 5 Whitlock, M. C. 'Combining probability from independent tests: the weighted Z-method is superior to Fisher's approach.' Journal of Evolutionary Biology 18, no. 5 (2005): 1368-1373. .. 6 Zaykin, Dmitri V. 'Optimally weighted Z-test is a powerful method for combining probabilities in meta-analysis.' Journal of Evolutionary Biology 24, no. 8 (2011): 1836-1841. .. 7 https://en.wikipedia.org/wiki/Extensions_of_Fisher%27s_method

A cosine continuous random variable.

As an instance of the `rv_continuous` class, `cosine` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, loc=0, scale=1) Probability density function. logpdf(x, loc=0, scale=1) Log of the probability density function. cdf(x, loc=0, scale=1) Cumulative distribution function. logcdf(x, loc=0, scale=1) Log of the cumulative distribution function. sf(x, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, loc=0, scale=1) Log of the survival function. ppf(q, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, loc=0, scale=1) Non-central moment of order n stats(loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(loc=0, scale=1) (Differential) entropy of the RV. fit(data, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(loc=0, scale=1) Median of the distribution. mean(loc=0, scale=1) Mean of the distribution. var(loc=0, scale=1) Variance of the distribution. std(loc=0, scale=1) Standard deviation of the distribution. interval(alpha, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The cosine distribution is an approximation to the normal distribution. The probability density function for `cosine` is:

.. math::

f(x) = \frac

\pi

(1+\cos(x))

for :math:`-\pi \le x \le \pi`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``cosine.pdf(x, loc, scale)`` is identically equivalent to ``cosine.pdf(y) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import cosine >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> mean, var, skew, kurt = cosine.stats(moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(cosine.ppf(0.01), ... cosine.ppf(0.99), 100) >>> ax.plot(x, cosine.pdf(x), ... 'r-', lw=5, alpha=0.6, label='cosine pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = cosine() >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = cosine.ppf(0.001, 0.5, 0.999) >>> np.allclose(0.001, 0.5, 0.999, cosine.cdf(vals)) True

Generate random numbers:

>>> r = cosine.rvs(size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Crystalball distribution

As an instance of the `rv_continuous` class, `crystalball` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(beta, m, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, beta, m, loc=0, scale=1) Probability density function. logpdf(x, beta, m, loc=0, scale=1) Log of the probability density function. cdf(x, beta, m, loc=0, scale=1) Cumulative distribution function. logcdf(x, beta, m, loc=0, scale=1) Log of the cumulative distribution function. sf(x, beta, m, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, beta, m, loc=0, scale=1) Log of the survival function. ppf(q, beta, m, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, beta, m, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, beta, m, loc=0, scale=1) Non-central moment of order n stats(beta, m, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(beta, m, loc=0, scale=1) (Differential) entropy of the RV. fit(data, beta, m, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(beta, m), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(beta, m, loc=0, scale=1) Median of the distribution. mean(beta, m, loc=0, scale=1) Mean of the distribution. var(beta, m, loc=0, scale=1) Variance of the distribution. std(beta, m, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, beta, m, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `crystalball` is:

.. math::

f(x, \beta, m) = \begincases N \exp(-x^2 / 2), &\textfor x > -\beta\\ N A (B - x)^

m

}

&\textfor x \le -\beta \endcases

where :math:`A = (m / |\beta|)^n \exp(-\beta^2 / 2)`, :math:`B = m/|\beta| - |\beta|` and :math:`N` is a normalisation constant.

`crystalball` takes :math:`\beta > 0` and :math:`m > 1` as shape parameters. :math:`\beta` defines the point where the pdf changes from a power-law to a Gaussian distribution. :math:`m` is the power of the power-law tail.

References ---------- .. 1 'Crystal Ball Function', https://en.wikipedia.org/wiki/Crystal_Ball_function

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``crystalball.pdf(x, beta, m, loc, scale)`` is identically equivalent to ``crystalball.pdf(y, beta, m) / scale`` with ``y = (x - loc) / scale``.

.. versionadded:: 0.19.0

Examples -------- >>> from scipy.stats import crystalball >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> beta, m = 2, 3 >>> mean, var, skew, kurt = crystalball.stats(beta, m, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(crystalball.ppf(0.01, beta, m), ... crystalball.ppf(0.99, beta, m), 100) >>> ax.plot(x, crystalball.pdf(x, beta, m), ... 'r-', lw=5, alpha=0.6, label='crystalball pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = crystalball(beta, m) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = crystalball.ppf(0.001, 0.5, 0.999, beta, m) >>> np.allclose(0.001, 0.5, 0.999, crystalball.cdf(vals, beta, m)) True

Generate random numbers:

>>> r = crystalball.rvs(beta, m, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Return a cumulative frequency histogram, using the histogram function.

A cumulative histogram is a mapping that counts the cumulative number of observations in all of the bins up to the specified bin.

Parameters ---------- a : array_like Input array. numbins : int, optional The number of bins to use for the histogram. Default is 10. defaultreallimits : tuple (lower, upper), optional The lower and upper values for the range of the histogram. If no value is given, a range slightly larger than the range of the values in `a` is used. Specifically ``(a.min() - s, a.max() + s)``, where ``s = (1/2)(a.max() - a.min()) / (numbins - 1)``. weights : array_like, optional The weights for each value in `a`. Default is None, which gives each value a weight of 1.0

Returns ------- cumcount : ndarray Binned values of cumulative frequency. lowerlimit : float Lower real limit binsize : float Width of each bin. extrapoints : int Extra points.

Examples -------- >>> import matplotlib.pyplot as plt >>> from scipy import stats >>> x = 1, 4, 2, 1, 3, 1 >>> res = stats.cumfreq(x, numbins=4, defaultreallimits=(1.5, 5)) >>> res.cumcount array( 1., 2., 3., 3.) >>> res.extrapoints 3

Create a normal distribution with 1000 random values

>>> rng = np.random.RandomState(seed=12345) >>> samples = stats.norm.rvs(size=1000, random_state=rng)

Calculate cumulative frequencies

>>> res = stats.cumfreq(samples, numbins=25)

Calculate space of values for x

>>> x = res.lowerlimit + np.linspace(0, res.binsize*res.cumcount.size, ... res.cumcount.size)

Plot histogram and cumulative histogram

>>> fig = plt.figure(figsize=(10, 4)) >>> ax1 = fig.add_subplot(1, 2, 1) >>> ax2 = fig.add_subplot(1, 2, 2) >>> ax1.hist(samples, bins=25) >>> ax1.set_title('Histogram') >>> ax2.bar(x, res.cumcount, width=res.binsize) >>> ax2.set_title('Cumulative histogram') >>> ax2.set_xlim(x.min(), x.max())

>>> plt.show()

Compute several descriptive statistics of the passed array.

Parameters ---------- a : array_like Input data. axis : int or None, optional Axis along which statistics are calculated. Default is 0. If None, compute over the whole array `a`. ddof : int, optional Delta degrees of freedom (only for variance). Default is 1. bias : bool, optional If False, then the skewness and kurtosis calculations are corrected for statistical bias. nan_policy : 'propagate', 'raise', 'omit', optional Defines how to handle when input contains nan. The following options are available (default is 'propagate'):

* 'propagate': returns nan * 'raise': throws an error * 'omit': performs the calculations ignoring nan values

Returns ------- nobs : int or ndarray of ints Number of observations (length of data along `axis`). When 'omit' is chosen as nan_policy, each column is counted separately. minmax: tuple of ndarrays or floats Minimum and maximum value of data array. mean : ndarray or float Arithmetic mean of data along axis. variance : ndarray or float Unbiased variance of the data along axis, denominator is number of observations minus one. skewness : ndarray or float Skewness, based on moment calculations with denominator equal to the number of observations, i.e. no degrees of freedom correction. kurtosis : ndarray or float Kurtosis (Fisher). The kurtosis is normalized so that it is zero for the normal distribution. No degrees of freedom are used.

See Also -------- skew, kurtosis

Examples -------- >>> from scipy import stats >>> a = np.arange(10) >>> stats.describe(a) DescribeResult(nobs=10, minmax=(0, 9), mean=4.5, variance=9.166666666666666, skewness=0.0, kurtosis=-1.2242424242424244) >>> b = [1, 2], [3, 4] >>> stats.describe(b) DescribeResult(nobs=2, minmax=(array(1, 2), array(3, 4)), mean=array(2., 3.), variance=array(2., 2.), skewness=array(0., 0.), kurtosis=array(-2., -2.))

A double gamma continuous random variable.

As an instance of the `rv_continuous` class, `dgamma` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, loc=0, scale=1) Probability density function. logpdf(x, a, loc=0, scale=1) Log of the probability density function. cdf(x, a, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, loc=0, scale=1) Log of the survival function. ppf(q, a, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, loc=0, scale=1) Non-central moment of order n stats(a, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, loc=0, scale=1) Median of the distribution. mean(a, loc=0, scale=1) Mean of the distribution. var(a, loc=0, scale=1) Variance of the distribution. std(a, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `dgamma` is:

.. math::

f(x, a) = \frac

\Gamma(a)

|x|^a-1 \exp(-|x|)

for a real number :math:`x` and :math:`a > 0`. :math:`\Gamma` is the gamma function (`scipy.special.gamma`).

`dgamma` takes ``a`` as a shape parameter for :math:`a`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``dgamma.pdf(x, a, loc, scale)`` is identically equivalent to ``dgamma.pdf(y, a) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import dgamma >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a = 1.1 >>> mean, var, skew, kurt = dgamma.stats(a, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(dgamma.ppf(0.01, a), ... dgamma.ppf(0.99, a), 100) >>> ax.plot(x, dgamma.pdf(x, a), ... 'r-', lw=5, alpha=0.6, label='dgamma pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = dgamma(a) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = dgamma.ppf(0.001, 0.5, 0.999, a) >>> np.allclose(0.001, 0.5, 0.999, dgamma.cdf(vals, a)) True

Generate random numbers:

>>> r = dgamma.rvs(a, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A Dirichlet random variable.

The `alpha` keyword specifies the concentration parameters of the distribution.

.. versionadded:: 0.15.0

Methods ------- ``pdf(x, alpha)`` Probability density function. ``logpdf(x, alpha)`` Log of the probability density function. ``rvs(alpha, size=1, random_state=None)`` Draw random samples from a Dirichlet distribution. ``mean(alpha)`` The mean of the Dirichlet distribution ``var(alpha)`` The variance of the Dirichlet distribution ``entropy(alpha)`` Compute the differential entropy of the Dirichlet distribution.

Parameters ---------- x : array_like Quantiles, with the last axis of `x` denoting the components. alpha : array_like The concentration parameters. The number of entries determines the dimensionality of the distribution. random_state : None or int or np.random.RandomState instance, optional If int or RandomState, use it for drawing the random variates. If None (or np.random), the global np.random state is used. Default is None.

Alternatively, the object may be called (as a function) to fix concentration parameters, returning a 'frozen' Dirichlet random variable:

rv = dirichlet(alpha)

• Frozen object with the same methods but holding the given concentration parameters fixed.

Notes ----- Each :math:`\alpha` entry must be positive. The distribution has only support on the simplex defined by

.. math:: \sum_=1^K x_i \le 1

The probability density function for `dirichlet` is

.. math::

f(x) = \frac

\mathrm{B(\boldsymbol\alpha)

}

\prod_=1^K x_i^\alpha_i - 1

where

.. math::

\mathrmB(\boldsymbol\alpha) = \frac\prod_{i=1^K \Gamma(\alpha_i)

}

\Gamma\bigl(\sum_{i=1^K \alpha_i\bigr)

}

and :math:`\boldsymbol\alpha=(\alpha_1,\ldots,\alpha_K)`, the concentration parameters and :math:`K` is the dimension of the space where :math:`x` takes values.

Note that the dirichlet interface is somewhat inconsistent. The array returned by the rvs function is transposed with respect to the format expected by the pdf and logpdf.

Examples -------- >>> from scipy.stats import dirichlet

Generate a dirichlet random variable

>>> quantiles = np.array(0.2, 0.2, 0.6) # specify quantiles >>> alpha = np.array(0.4, 5, 15) # specify concentration parameters >>> dirichlet.pdf(quantiles, alpha) 0.2843831684937255

The same PDF but following a log scale

>>> dirichlet.logpdf(quantiles, alpha) -1.2574327653159187

Once we specify the dirichlet distribution we can then calculate quantities of interest

>>> dirichlet.mean(alpha) # get the mean of the distribution array(0.01960784, 0.24509804, 0.73529412) >>> dirichlet.var(alpha) # get variance array(0.00089829, 0.00864603, 0.00909517) >>> dirichlet.entropy(alpha) # calculate the differential entropy -4.3280162474082715

We can also return random samples from the distribution

>>> dirichlet.rvs(alpha, size=1, random_state=1) array([0.00766178, 0.24670518, 0.74563305]) >>> dirichlet.rvs(alpha, size=2, random_state=2) array([0.01639427, 0.1292273 , 0.85437844], [0.00156917, 0.19033695, 0.80809388])

A Laplacian discrete random variable.

As an instance of the `rv_discrete` class, `dlaplace` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, loc=0, size=1, random_state=None) Random variates. pmf(k, a, loc=0) Probability mass function. logpmf(k, a, loc=0) Log of the probability mass function. cdf(k, a, loc=0) Cumulative distribution function. logcdf(k, a, loc=0) Log of the cumulative distribution function. sf(k, a, loc=0) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(k, a, loc=0) Log of the survival function. ppf(q, a, loc=0) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, loc=0) Inverse survival function (inverse of ``sf``). stats(a, loc=0, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, loc=0) (Differential) entropy of the RV. expect(func, args=(a,), loc=0, lb=None, ub=None, conditional=False) Expected value of a function (of one argument) with respect to the distribution. median(a, loc=0) Median of the distribution. mean(a, loc=0) Mean of the distribution. var(a, loc=0) Variance of the distribution. std(a, loc=0) Standard deviation of the distribution. interval(alpha, a, loc=0) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability mass function for `dlaplace` is:

.. math::

f(k) = \tanh(a/2) \exp(-a |k|)

for integers :math:`k` and :math:`a > 0`.

`dlaplace` takes :math:`a` as shape parameter.

The probability mass function above is defined in the 'standardized' form. To shift distribution use the ``loc`` parameter. Specifically, ``dlaplace.pmf(k, a, loc)`` is identically equivalent to ``dlaplace.pmf(k - loc, a)``.

Examples -------- >>> from scipy.stats import dlaplace >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a = 0.8 >>> mean, var, skew, kurt = dlaplace.stats(a, moments='mvsk')

Display the probability mass function (``pmf``):

>>> x = np.arange(dlaplace.ppf(0.01, a), ... dlaplace.ppf(0.99, a)) >>> ax.plot(x, dlaplace.pmf(x, a), 'bo', ms=8, label='dlaplace pmf') >>> ax.vlines(x, 0, dlaplace.pmf(x, a), colors='b', lw=5, alpha=0.5)

Alternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pmf``:

>>> rv = dlaplace(a) >>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1, ... label='frozen pmf') >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Check accuracy of ``cdf`` and ``ppf``:

>>> prob = dlaplace.cdf(x, a) >>> np.allclose(x, dlaplace.ppf(prob, a)) True

Generate random numbers:

>>> r = dlaplace.rvs(a, size=1000)

A double Weibull continuous random variable.

As an instance of the `rv_continuous` class, `dweibull` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `dweibull` is given by

.. math::

f(x, c) = c / 2 |x|^c-1 \exp(-|x|^c)

for a real number :math:`x` and :math:`c > 0`.

`dweibull` takes ``c`` as a shape parameter for :math:`c`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``dweibull.pdf(x, c, loc, scale)`` is identically equivalent to ``dweibull.pdf(y, c) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import dweibull >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 2.07 >>> mean, var, skew, kurt = dweibull.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(dweibull.ppf(0.01, c), ... dweibull.ppf(0.99, c), 100) >>> ax.plot(x, dweibull.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='dweibull pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = dweibull(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = dweibull.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, dweibull.cdf(vals, c)) True

Generate random numbers:

>>> r = dweibull.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Compute the energy distance between two 1D distributions.

.. versionadded:: 1.0.0

Parameters ---------- u_values, v_values : array_like Values observed in the (empirical) distribution. u_weights, v_weights : array_like, optional Weight for each value. If unspecified, each value is assigned the same weight. `u_weights` (resp. `v_weights`) must have the same length as `u_values` (resp. `v_values`). If the weight sum differs from 1, it must still be positive and finite so that the weights can be normalized to sum to 1.

Returns ------- distance : float The computed distance between the distributions.

Notes ----- The energy distance between two distributions :math:`u` and :math:`v`, whose respective CDFs are :math:`U` and :math:`V`, equals to:

.. math::

D(u, v) = \left( 2\mathbb E|X - Y| - \mathbb E|X - X'| - \mathbb E|Y - Y'| \right)^

/2

where :math:`X` and :math:`X'` (resp. :math:`Y` and :math:`Y'`) are independent random variables whose probability distribution is :math:`u` (resp. :math:`v`).

As shown in 2_, for one-dimensional real-valued variables, the energy distance is linked to the non-distribution-free version of the Cramer-von Mises distance:

.. math::

D(u, v) = \sqrt

l_2(u, v) = \left( 2 \int_

\infty

}

^+\infty (U-V)^2 \right)^

/2

Note that the common Cramer-von Mises criterion uses the distribution-free version of the distance. See 2_ (section 2), for more details about both versions of the distance.

The input distributions can be empirical, therefore coming from samples whose values are effectively inputs of the function, or they can be seen as generalized functions, in which case they are weighted sums of Dirac delta functions located at the specified values.

References ---------- .. 1 'Energy distance', https://en.wikipedia.org/wiki/Energy_distance .. 2 Szekely 'E-statistics: The energy of statistical samples.' Bowling Green State University, Department of Mathematics and Statistics, Technical Report 02-16 (2002). .. 3 Rizzo, Szekely 'Energy distance.' Wiley Interdisciplinary Reviews: Computational Statistics, 8(1):27-38 (2015). .. 4 Bellemare, Danihelka, Dabney, Mohamed, Lakshminarayanan, Hoyer, Munos 'The Cramer Distance as a Solution to Biased Wasserstein Gradients' (2017). :arXiv:`1705.10743`.

Examples -------- >>> from scipy.stats import energy_distance >>> energy_distance(0, 2) 2.0000000000000004 >>> energy_distance(0, 8, 0, 8, 3, 1, 2, 2) 1.0000000000000002 >>> energy_distance(0.7, 7.4, 2.4, 6.8, 1.4, 8. , ... 2.1, 4.2, 7.4, 8. , 7.6, 8.8) 0.88003340976158217

Calculate the entropy of a distribution for given probability values.

If only probabilities `pk` are given, the entropy is calculated as ``S = -sum(pk * log(pk), axis=axis)``.

If `qk` is not None, then compute the Kullback-Leibler divergence ``S = sum(pk * log(pk / qk), axis=axis)``.

This routine will normalize `pk` and `qk` if they don't sum to 1.

Parameters ---------- pk : sequence Defines the (discrete) distribution. ``pki`` is the (possibly unnormalized) probability of event ``i``. qk : sequence, optional Sequence against which the relative entropy is computed. Should be in the same format as `pk`. base : float, optional The logarithmic base to use, defaults to ``e`` (natural logarithm). axis: int, optional The axis along which the entropy is calculated. Default is 0.

Returns ------- S : float The calculated entropy.

Examples --------

>>> from scipy.stats import entropy

Bernoulli trial with different p. The outcome of a fair coin is the most uncertain:

>>> entropy(1/2, 1/2, base=2) 1.0

The outcome of a biased coin is less uncertain:

>>> entropy(9/10, 1/10, base=2) 0.46899559358928117

Relative entropy:

>>> entropy(1/2, 1/2, qk=9/10, 1/10) 0.5108256237659907

Compute the Epps-Singleton (ES) test statistic.

Test the null hypothesis that two samples have the same underlying probability distribution.

Parameters ---------- x, y : array-like The two samples of observations to be tested. Input must not have more than one dimension. Samples can have different lengths. t : array-like, optional The points (t1, ..., tn) where the empirical characteristic function is to be evaluated. It should be positive distinct numbers. The default value (0.4, 0.8) is proposed in 1_. Input must not have more than one dimension.

Returns ------- statistic : float The test statistic. pvalue : float The associated p-value based on the asymptotic chi2-distribution.

See Also -------- ks_2samp, anderson_ksamp

Notes ----- Testing whether two samples are generated by the same underlying distribution is a classical question in statistics. A widely used test is the Kolmogorov-Smirnov (KS) test which relies on the empirical distribution function. Epps and Singleton introduce a test based on the empirical characteristic function in 1_.

One advantage of the ES test compared to the KS test is that is does not assume a continuous distribution. In 1_, the authors conclude that the test also has a higher power than the KS test in many examples. They recommend the use of the ES test for discrete samples as well as continuous samples with at least 25 observations each, whereas `anderson_ksamp` is recommended for smaller sample sizes in the continuous case.

The p-value is computed from the asymptotic distribution of the test statistic which follows a `chi2` distribution. If the sample size of both `x` and `y` is below 25, the small sample correction proposed in 1_ is applied to the test statistic.

The default values of `t` are determined in 1_ by considering various distributions and finding good values that lead to a high power of the test in general. Table III in 1_ gives the optimal values for the distributions tested in that study. The values of `t` are scaled by the semi-interquartile range in the implementation, see 1_.

References ---------- .. 1 T. W. Epps and K. J. Singleton, 'An omnibus test for the two-sample problem using the empirical characteristic function', Journal of Statistical Computation and Simulation 26, p. 177--203, 1986.

.. 2 S. J. Goerg and J. Kaiser, 'Nonparametric testing of distributions

• the Epps-Singleton two-sample test using the empirical characteristic function', The Stata Journal 9(3), p. 454--465, 2009.

An Erlang continuous random variable.

As an instance of the `rv_continuous` class, `erlang` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, loc=0, scale=1) Probability density function. logpdf(x, a, loc=0, scale=1) Log of the probability density function. cdf(x, a, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, loc=0, scale=1) Log of the survival function. ppf(q, a, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, loc=0, scale=1) Non-central moment of order n stats(a, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, loc=0, scale=1) Median of the distribution. mean(a, loc=0, scale=1) Mean of the distribution. var(a, loc=0, scale=1) Variance of the distribution. std(a, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

See Also -------- gamma

Notes ----- The Erlang distribution is a special case of the Gamma distribution, with the shape parameter `a` an integer. Note that this restriction is not enforced by `erlang`. It will, however, generate a warning the first time a non-integer value is used for the shape parameter.

Refer to `gamma` for examples.

An exponential continuous random variable.

As an instance of the `rv_continuous` class, `expon` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, loc=0, scale=1) Probability density function. logpdf(x, loc=0, scale=1) Log of the probability density function. cdf(x, loc=0, scale=1) Cumulative distribution function. logcdf(x, loc=0, scale=1) Log of the cumulative distribution function. sf(x, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, loc=0, scale=1) Log of the survival function. ppf(q, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, loc=0, scale=1) Non-central moment of order n stats(loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(loc=0, scale=1) (Differential) entropy of the RV. fit(data, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(loc=0, scale=1) Median of the distribution. mean(loc=0, scale=1) Mean of the distribution. var(loc=0, scale=1) Variance of the distribution. std(loc=0, scale=1) Standard deviation of the distribution. interval(alpha, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `expon` is:

.. math::

f(x) = \exp(-x)

for :math:`x \ge 0`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``expon.pdf(x, loc, scale)`` is identically equivalent to ``expon.pdf(y) / scale`` with ``y = (x - loc) / scale``.

A common parameterization for `expon` is in terms of the rate parameter ``lambda``, such that ``pdf = lambda * exp(-lambda * x)``. This parameterization corresponds to using ``scale = 1 / lambda``.

Examples -------- >>> from scipy.stats import expon >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> mean, var, skew, kurt = expon.stats(moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(expon.ppf(0.01), ... expon.ppf(0.99), 100) >>> ax.plot(x, expon.pdf(x), ... 'r-', lw=5, alpha=0.6, label='expon pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = expon() >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = expon.ppf(0.001, 0.5, 0.999) >>> np.allclose(0.001, 0.5, 0.999, expon.cdf(vals)) True

Generate random numbers:

>>> r = expon.rvs(size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

An exponentially modified Normal continuous random variable.

As an instance of the `rv_continuous` class, `exponnorm` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(K, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, K, loc=0, scale=1) Probability density function. logpdf(x, K, loc=0, scale=1) Log of the probability density function. cdf(x, K, loc=0, scale=1) Cumulative distribution function. logcdf(x, K, loc=0, scale=1) Log of the cumulative distribution function. sf(x, K, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, K, loc=0, scale=1) Log of the survival function. ppf(q, K, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, K, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, K, loc=0, scale=1) Non-central moment of order n stats(K, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(K, loc=0, scale=1) (Differential) entropy of the RV. fit(data, K, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(K,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(K, loc=0, scale=1) Median of the distribution. mean(K, loc=0, scale=1) Mean of the distribution. var(K, loc=0, scale=1) Variance of the distribution. std(K, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, K, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `exponnorm` is:

.. math::

f(x, K) = \frac

K

\exp\left(\frac

K^2

• x / K \right) \textrfc\left(-\fracx - 1/K\sqrt{2

}

\right)

where :math:`x` is a real number and :math:`K > 0`.

It can be thought of as the sum of a standard normal random variable and an independent exponentially distributed random variable with rate ``1/K``.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``exponnorm.pdf(x, K, loc, scale)`` is identically equivalent to ``exponnorm.pdf(y, K) / scale`` with ``y = (x - loc) / scale``.

An alternative parameterization of this distribution (for example, in `Wikipedia <https://en.wikipedia.org/wiki/Exponentially_modified_Gaussian_distribution>`_) involves three parameters, :math:`\mu`, :math:`\lambda` and :math:`\sigma`. In the present parameterization this corresponds to having ``loc`` and ``scale`` equal to :math:`\mu` and :math:`\sigma`, respectively, and shape parameter :math:`K = 1/(\sigma\lambda)`.

.. versionadded:: 0.16.0

Examples -------- >>> from scipy.stats import exponnorm >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> K = 1.5 >>> mean, var, skew, kurt = exponnorm.stats(K, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(exponnorm.ppf(0.01, K), ... exponnorm.ppf(0.99, K), 100) >>> ax.plot(x, exponnorm.pdf(x, K), ... 'r-', lw=5, alpha=0.6, label='exponnorm pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = exponnorm(K) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = exponnorm.ppf(0.001, 0.5, 0.999, K) >>> np.allclose(0.001, 0.5, 0.999, exponnorm.cdf(vals, K)) True

Generate random numbers:

>>> r = exponnorm.rvs(K, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

An exponential power continuous random variable.

As an instance of the `rv_continuous` class, `exponpow` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(b, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, b, loc=0, scale=1) Probability density function. logpdf(x, b, loc=0, scale=1) Log of the probability density function. cdf(x, b, loc=0, scale=1) Cumulative distribution function. logcdf(x, b, loc=0, scale=1) Log of the cumulative distribution function. sf(x, b, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, b, loc=0, scale=1) Log of the survival function. ppf(q, b, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, b, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, b, loc=0, scale=1) Non-central moment of order n stats(b, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(b, loc=0, scale=1) (Differential) entropy of the RV. fit(data, b, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(b,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(b, loc=0, scale=1) Median of the distribution. mean(b, loc=0, scale=1) Mean of the distribution. var(b, loc=0, scale=1) Variance of the distribution. std(b, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, b, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `exponpow` is:

.. math::

f(x, b) = b x^-1 \exp(1 + x^b - \exp(x^b))

for :math:`x \ge 0`, :math:`b > 0`. Note that this is a different distribution from the exponential power distribution that is also known under the names 'generalized normal' or 'generalized Gaussian'.

`exponpow` takes ``b`` as a shape parameter for :math:`b`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``exponpow.pdf(x, b, loc, scale)`` is identically equivalent to ``exponpow.pdf(y, b) / scale`` with ``y = (x - loc) / scale``.

References ---------- http://www.math.wm.edu/~leemis/chart/UDR/PDFs/Exponentialpower.pdf

Examples -------- >>> from scipy.stats import exponpow >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> b = 2.7 >>> mean, var, skew, kurt = exponpow.stats(b, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(exponpow.ppf(0.01, b), ... exponpow.ppf(0.99, b), 100) >>> ax.plot(x, exponpow.pdf(x, b), ... 'r-', lw=5, alpha=0.6, label='exponpow pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = exponpow(b) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = exponpow.ppf(0.001, 0.5, 0.999, b) >>> np.allclose(0.001, 0.5, 0.999, exponpow.cdf(vals, b)) True

Generate random numbers:

>>> r = exponpow.rvs(b, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

An exponentiated Weibull continuous random variable.

As an instance of the `rv_continuous` class, `exponweib` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, c, loc=0, scale=1) Probability density function. logpdf(x, a, c, loc=0, scale=1) Log of the probability density function. cdf(x, a, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, c, loc=0, scale=1) Log of the survival function. ppf(q, a, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, c, loc=0, scale=1) Non-central moment of order n stats(a, c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a, c), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, c, loc=0, scale=1) Median of the distribution. mean(a, c, loc=0, scale=1) Mean of the distribution. var(a, c, loc=0, scale=1) Variance of the distribution. std(a, c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

See Also -------- weibull_min, numpy.random.mtrand.RandomState.weibull

Notes ----- The probability density function for `exponweib` is:

.. math::

f(x, a, c) = a c 1-\exp(-x^c)^a-1 \exp(-x^c) x^c-1

and its cumulative distribution function is:

.. math::

F(x, a, c) = 1-\exp(-x^c)^a

for :math:`x > 0`, :math:`a > 0`, :math:`c > 0`.

`exponweib` takes :math:`a` and :math:`c` as shape parameters:

* :math:`a` is the exponentiation parameter, with the special case :math:`a=1` corresponding to the (non-exponentiated) Weibull distribution `weibull_min`. * :math:`c` is the shape parameter of the non-exponentiated Weibull law.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``exponweib.pdf(x, a, c, loc, scale)`` is identically equivalent to ``exponweib.pdf(y, a, c) / scale`` with ``y = (x - loc) / scale``.

References ---------- https://en.wikipedia.org/wiki/Exponentiated_Weibull_distribution

Examples -------- >>> from scipy.stats import exponweib >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a, c = 2.89, 1.95 >>> mean, var, skew, kurt = exponweib.stats(a, c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(exponweib.ppf(0.01, a, c), ... exponweib.ppf(0.99, a, c), 100) >>> ax.plot(x, exponweib.pdf(x, a, c), ... 'r-', lw=5, alpha=0.6, label='exponweib pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = exponweib(a, c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = exponweib.ppf(0.001, 0.5, 0.999, a, c) >>> np.allclose(0.001, 0.5, 0.999, exponweib.cdf(vals, a, c)) True

Generate random numbers:

>>> r = exponweib.rvs(a, c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

An F continuous random variable.

As an instance of the `rv_continuous` class, `f` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(dfn, dfd, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, dfn, dfd, loc=0, scale=1) Probability density function. logpdf(x, dfn, dfd, loc=0, scale=1) Log of the probability density function. cdf(x, dfn, dfd, loc=0, scale=1) Cumulative distribution function. logcdf(x, dfn, dfd, loc=0, scale=1) Log of the cumulative distribution function. sf(x, dfn, dfd, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, dfn, dfd, loc=0, scale=1) Log of the survival function. ppf(q, dfn, dfd, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, dfn, dfd, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, dfn, dfd, loc=0, scale=1) Non-central moment of order n stats(dfn, dfd, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(dfn, dfd, loc=0, scale=1) (Differential) entropy of the RV. fit(data, dfn, dfd, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(dfn, dfd), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(dfn, dfd, loc=0, scale=1) Median of the distribution. mean(dfn, dfd, loc=0, scale=1) Mean of the distribution. var(dfn, dfd, loc=0, scale=1) Variance of the distribution. std(dfn, dfd, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, dfn, dfd, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `f` is:

.. math::

f(x, df_1, df_2) = \fracdf_2^{df_2/2 df_1^df_1/2 x^df_1 / 2-1

}

(df_2+df_1 x)^{(df_1+df_2)/2 B(df_1/2, df_2/2)

}

for :math:`x > 0`.

`f` takes ``dfn`` and ``dfd`` as shape parameters.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``f.pdf(x, dfn, dfd, loc, scale)`` is identically equivalent to ``f.pdf(y, dfn, dfd) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import f >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> dfn, dfd = 29, 18 >>> mean, var, skew, kurt = f.stats(dfn, dfd, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(f.ppf(0.01, dfn, dfd), ... f.ppf(0.99, dfn, dfd), 100) >>> ax.plot(x, f.pdf(x, dfn, dfd), ... 'r-', lw=5, alpha=0.6, label='f pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = f(dfn, dfd) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = f.ppf(0.001, 0.5, 0.999, dfn, dfd) >>> np.allclose(0.001, 0.5, 0.999, f.cdf(vals, dfn, dfd)) True

Generate random numbers:

>>> r = f.rvs(dfn, dfd, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Perform one-way ANOVA.

The one-way ANOVA tests the null hypothesis that two or more groups have the same population mean. The test is applied to samples from two or more groups, possibly with differing sizes.

Parameters ---------- sample1, sample2, ... : array_like The sample measurements for each group.

Returns ------- statistic : float The computed F-value of the test. pvalue : float The associated p-value from the F-distribution.

Notes ----- The ANOVA test has important assumptions that must be satisfied in order for the associated p-value to be valid.

1. The samples are independent. 2. Each sample is from a normally distributed population. 3. The population standard deviations of the groups are all equal. This property is known as homoscedasticity.

If these assumptions are not true for a given set of data, it may still be possible to use the Kruskal-Wallis H-test (`scipy.stats.kruskal`) although with some loss of power.

The algorithm is from Heiman2, pp.394-7.

References ---------- .. 1 R. Lowry, 'Concepts and Applications of Inferential Statistics', Chapter 14, 2014, http://vassarstats.net/textbook/

.. 2 G.W. Heiman, 'Understanding research methods and statistics: An integrated introduction for psychology', Houghton, Mifflin and Company, 2001.

.. 3 G.H. McDonald, 'Handbook of Biological Statistics', One-way ANOVA. http://www.biostathandbook.com/onewayanova.html

Examples -------- >>> import scipy.stats as stats

3_ Here are some data on a shell measurement (the length of the anterior adductor muscle scar, standardized by dividing by length) in the mussel Mytilus trossulus from five locations: Tillamook, Oregon; Newport, Oregon; Petersburg, Alaska; Magadan, Russia; and Tvarminne, Finland, taken from a much larger data set used in McDonald et al. (1991).

>>> tillamook = 0.0571, 0.0813, 0.0831, 0.0976, 0.0817, 0.0859, 0.0735, ... 0.0659, 0.0923, 0.0836 >>> newport = 0.0873, 0.0662, 0.0672, 0.0819, 0.0749, 0.0649, 0.0835, ... 0.0725 >>> petersburg = 0.0974, 0.1352, 0.0817, 0.1016, 0.0968, 0.1064, 0.105 >>> magadan = 0.1033, 0.0915, 0.0781, 0.0685, 0.0677, 0.0697, 0.0764, ... 0.0689 >>> tvarminne = 0.0703, 0.1026, 0.0956, 0.0973, 0.1039, 0.1045 >>> stats.f_oneway(tillamook, newport, petersburg, magadan, tvarminne) (7.1210194716424473, 0.00028122423145345439)

A fatigue-life (Birnbaum-Saunders) continuous random variable.

As an instance of the `rv_continuous` class, `fatiguelife` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `fatiguelife` is:

.. math::

f(x, c) = \fracx+1

c\sqrt

\pi x^3

}

\exp(-\frac(x-1)^2

x c^2

)

for :math:`x >= 0` and :math:`c > 0`.

`fatiguelife` takes ``c`` as a shape parameter for :math:`c`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``fatiguelife.pdf(x, c, loc, scale)`` is identically equivalent to ``fatiguelife.pdf(y, c) / scale`` with ``y = (x - loc) / scale``.

References ---------- .. 1 'Birnbaum-Saunders distribution', https://en.wikipedia.org/wiki/Birnbaum-Saunders_distribution

Examples -------- >>> from scipy.stats import fatiguelife >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 29 >>> mean, var, skew, kurt = fatiguelife.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(fatiguelife.ppf(0.01, c), ... fatiguelife.ppf(0.99, c), 100) >>> ax.plot(x, fatiguelife.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='fatiguelife pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = fatiguelife(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = fatiguelife.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, fatiguelife.cdf(vals, c)) True

Generate random numbers:

>>> r = fatiguelife.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Find repeats and repeat counts.

Parameters ---------- arr : array_like Input array. This is cast to float64.

Returns ------- values : ndarray The unique values from the (flattened) input that are repeated.

counts : ndarray Number of times the corresponding 'value' is repeated.

Notes ----- In numpy >= 1.9 `numpy.unique` provides similar functionality. The main difference is that `find_repeats` only returns repeated values.

Examples -------- >>> from scipy import stats >>> stats.find_repeats(2, 1, 2, 3, 2, 2, 5) RepeatedResults(values=array(2.), counts=array(4))

>>> stats.find_repeats([10, 20, 1, 2], [5, 5, 4, 4]) RepeatedResults(values=array(4., 5.), counts=array(2, 2))

Perform a Fisher exact test on a 2x2 contingency table.

Parameters ---------- table : array_like of ints A 2x2 contingency table. Elements should be non-negative integers. alternative : 'two-sided', 'less', 'greater', optional Defines the alternative hypothesis. The following options are available (default is 'two-sided'):

* 'two-sided' * 'less': one-sided * 'greater': one-sided

Returns ------- oddsratio : float This is prior odds ratio and not a posterior estimate. p_value : float P-value, the probability of obtaining a distribution at least as extreme as the one that was actually observed, assuming that the null hypothesis is true.

See Also -------- chi2_contingency : Chi-square test of independence of variables in a contingency table.

Notes ----- The calculated odds ratio is different from the one R uses. This scipy implementation returns the (more common) 'unconditional Maximum Likelihood Estimate', while R uses the 'conditional Maximum Likelihood Estimate'.

For tables with large numbers, the (inexact) chi-square test implemented in the function `chi2_contingency` can also be used.

Examples -------- Say we spend a few days counting whales and sharks in the Atlantic and Indian oceans. In the Atlantic ocean we find 8 whales and 1 shark, in the Indian ocean 2 whales and 5 sharks. Then our contingency table is::

Atlantic Indian whales 8 2 sharks 1 5

We use this table to find the p-value:

>>> import scipy.stats as stats >>> oddsratio, pvalue = stats.fisher_exact([8, 2], [1, 5]) >>> pvalue 0.0349...

The probability that we would observe this or an even more imbalanced ratio by chance is about 3.5%. A commonly used significance level is 5%--if we adopt that, we can therefore conclude that our observed imbalance is statistically significant; whales prefer the Atlantic while sharks prefer the Indian ocean.

A Fisk continuous random variable.

The Fisk distribution is also known as the log-logistic distribution.

As an instance of the `rv_continuous` class, `fisk` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `fisk` is:

.. math::

f(x, c) = c x^

c-1

}

(1 + x^

c

}

)^

2

}

for :math:`x >= 0` and :math:`c > 0`.

`fisk` takes ``c`` as a shape parameter for :math:`c`.

`fisk` is a special case of `burr` or `burr12` with ``d=1``.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``fisk.pdf(x, c, loc, scale)`` is identically equivalent to ``fisk.pdf(y, c) / scale`` with ``y = (x - loc) / scale``.

See Also -------- burr

Examples -------- >>> from scipy.stats import fisk >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 3.09 >>> mean, var, skew, kurt = fisk.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(fisk.ppf(0.01, c), ... fisk.ppf(0.99, c), 100) >>> ax.plot(x, fisk.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='fisk pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = fisk(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = fisk.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, fisk.cdf(vals, c)) True

Generate random numbers:

>>> r = fisk.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Perform Fligner-Killeen test for equality of variance.

Fligner's test tests the null hypothesis that all input samples are from populations with equal variances. Fligner-Killeen's test is distribution free when populations are identical 2_.

Parameters ---------- sample1, sample2, ... : array_like Arrays of sample data. Need not be the same length. center : 'mean', 'median', 'trimmed', optional Keyword argument controlling which function of the data is used in computing the test statistic. The default is 'median'. proportiontocut : float, optional When `center` is 'trimmed', this gives the proportion of data points to cut from each end. (See `scipy.stats.trim_mean`.) Default is 0.05.

Returns ------- statistic : float The test statistic. pvalue : float The p-value for the hypothesis test.

See Also -------- bartlett : A parametric test for equality of k variances in normal samples levene : A robust parametric test for equality of k variances

Notes ----- As with Levene's test there are three variants of Fligner's test that differ by the measure of central tendency used in the test. See `levene` for more information.

Conover et al. (1981) examine many of the existing parametric and nonparametric tests by extensive simulations and they conclude that the tests proposed by Fligner and Killeen (1976) and Levene (1960) appear to be superior in terms of robustness of departures from normality and power 3_.

References ---------- .. 1 Park, C. and Lindsay, B. G. (1999). Robust Scale Estimation and Hypothesis Testing based on Quadratic Inference Function. Technical Report #99-03, Center for Likelihood Studies, Pennsylvania State University. https://cecas.clemson.edu/~cspark/cv/paper/qif/draftqif2.pdf

.. 2 Fligner, M.A. and Killeen, T.J. (1976). Distribution-free two-sample tests for scale. 'Journal of the American Statistical Association.' 71(353), 210-213.

.. 3 Park, C. and Lindsay, B. G. (1999). Robust Scale Estimation and Hypothesis Testing based on Quadratic Inference Function. Technical Report #99-03, Center for Likelihood Studies, Pennsylvania State University.

.. 4 Conover, W. J., Johnson, M. E. and Johnson M. M. (1981). A comparative study of tests for homogeneity of variances, with applications to the outer continental shelf biding data. Technometrics, 23(4), 351-361.

A folded Cauchy continuous random variable.

As an instance of the `rv_continuous` class, `foldcauchy` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `foldcauchy` is:

.. math::

f(x, c) = \frac

\pi (1+(x-c)^2) + \frac

\pi (1+(x+c)^2)

for :math:`x \ge 0`.

`foldcauchy` takes ``c`` as a shape parameter for :math:`c`.

Examples -------- >>> from scipy.stats import foldcauchy >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 4.72 >>> mean, var, skew, kurt = foldcauchy.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(foldcauchy.ppf(0.01, c), ... foldcauchy.ppf(0.99, c), 100) >>> ax.plot(x, foldcauchy.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='foldcauchy pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = foldcauchy(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = foldcauchy.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, foldcauchy.cdf(vals, c)) True

Generate random numbers:

>>> r = foldcauchy.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A folded normal continuous random variable.

As an instance of the `rv_continuous` class, `foldnorm` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `foldnorm` is:

.. math::

f(x, c) = \sqrt

/\pi

cosh(c x) \exp(-\fracx^2+c^2

)

for :math:`c \ge 0`.

`foldnorm` takes ``c`` as a shape parameter for :math:`c`.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``foldnorm.pdf(x, c, loc, scale)`` is identically equivalent to ``foldnorm.pdf(y, c) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import foldnorm >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 1.95 >>> mean, var, skew, kurt = foldnorm.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(foldnorm.ppf(0.01, c), ... foldnorm.ppf(0.99, c), 100) >>> ax.plot(x, foldnorm.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='foldnorm pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = foldnorm(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = foldnorm.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, foldnorm.cdf(vals, c)) True

Generate random numbers:

>>> r = foldnorm.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A Frechet left (or Weibull maximum) continuous random variable.

As an instance of the `rv_continuous` class, `frechet_l` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

See Also -------- weibull_max : The same distribution as `frechet_l`.

Notes ----- The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``frechet_l.pdf(x, c, loc, scale)`` is identically equivalent to ``frechet_l.pdf(y, c) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import frechet_l >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 3.63 >>> mean, var, skew, kurt = frechet_l.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(frechet_l.ppf(0.01, c), ... frechet_l.ppf(0.99, c), 100) >>> ax.plot(x, frechet_l.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='frechet_l pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = frechet_l(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = frechet_l.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, frechet_l.cdf(vals, c)) True

Generate random numbers:

>>> r = frechet_l.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A Frechet right (or Weibull minimum) continuous random variable.

As an instance of the `rv_continuous` class, `frechet_r` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, c, loc=0, scale=1) Probability density function. logpdf(x, c, loc=0, scale=1) Log of the probability density function. cdf(x, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, c, loc=0, scale=1) Log of the survival function. ppf(q, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, c, loc=0, scale=1) Non-central moment of order n stats(c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(c, loc=0, scale=1) Median of the distribution. mean(c, loc=0, scale=1) Mean of the distribution. var(c, loc=0, scale=1) Variance of the distribution. std(c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

See Also -------- weibull_min : The same distribution as `frechet_r`.

Notes ----- The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``frechet_r.pdf(x, c, loc, scale)`` is identically equivalent to ``frechet_r.pdf(y, c) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import frechet_r >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> c = 1.89 >>> mean, var, skew, kurt = frechet_r.stats(c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(frechet_r.ppf(0.01, c), ... frechet_r.ppf(0.99, c), 100) >>> ax.plot(x, frechet_r.pdf(x, c), ... 'r-', lw=5, alpha=0.6, label='frechet_r pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = frechet_r(c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = frechet_r.ppf(0.001, 0.5, 0.999, c) >>> np.allclose(0.001, 0.5, 0.999, frechet_r.cdf(vals, c)) True

Generate random numbers:

>>> r = frechet_r.rvs(c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

Compute the Friedman test for repeated measurements.

The Friedman test tests the null hypothesis that repeated measurements of the same individuals have the same distribution. It is often used to test for consistency among measurements obtained in different ways. For example, if two measurement techniques are used on the same set of individuals, the Friedman test can be used to determine if the two measurement techniques are consistent.

Parameters ---------- measurements1, measurements2, measurements3... : array_like Arrays of measurements. All of the arrays must have the same number of elements. At least 3 sets of measurements must be given.

Returns ------- statistic : float The test statistic, correcting for ties. pvalue : float The associated p-value assuming that the test statistic has a chi squared distribution.

Notes ----- Due to the assumption that the test statistic has a chi squared distribution, the p-value is only reliable for n > 10 and more than 6 repeated measurements.

References ---------- .. 1 https://en.wikipedia.org/wiki/Friedman_test

A gamma continuous random variable.

As an instance of the `rv_continuous` class, `gamma` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, loc=0, scale=1) Probability density function. logpdf(x, a, loc=0, scale=1) Log of the probability density function. cdf(x, a, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, loc=0, scale=1) Log of the survival function. ppf(q, a, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, loc=0, scale=1) Non-central moment of order n stats(a, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a,), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, loc=0, scale=1) Median of the distribution. mean(a, loc=0, scale=1) Mean of the distribution. var(a, loc=0, scale=1) Variance of the distribution. std(a, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

See Also -------- erlang, expon

Notes ----- The probability density function for `gamma` is:

.. math::

f(x, a) = \fracx^{a-1 \exp(-x)

}

\Gamma(a)

for :math:`x \ge 0`, :math:`a > 0`. Here :math:`\Gamma(a)` refers to the gamma function.

`gamma` takes ``a`` as a shape parameter for :math:`a`.

When :math:`a` is an integer, `gamma` reduces to the Erlang distribution, and when :math:`a=1` to the exponential distribution.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``gamma.pdf(x, a, loc, scale)`` is identically equivalent to ``gamma.pdf(y, a) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import gamma >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a = 1.99 >>> mean, var, skew, kurt = gamma.stats(a, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(gamma.ppf(0.01, a), ... gamma.ppf(0.99, a), 100) >>> ax.plot(x, gamma.pdf(x, a), ... 'r-', lw=5, alpha=0.6, label='gamma pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = gamma(a) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = gamma.ppf(0.001, 0.5, 0.999, a) >>> np.allclose(0.001, 0.5, 0.999, gamma.cdf(vals, a)) True

Generate random numbers:

>>> r = gamma.rvs(a, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A Gauss hypergeometric continuous random variable.

As an instance of the `rv_continuous` class, `gausshyper` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, b, c, z, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, b, c, z, loc=0, scale=1) Probability density function. logpdf(x, a, b, c, z, loc=0, scale=1) Log of the probability density function. cdf(x, a, b, c, z, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, b, c, z, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, b, c, z, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, b, c, z, loc=0, scale=1) Log of the survival function. ppf(q, a, b, c, z, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, b, c, z, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, b, c, z, loc=0, scale=1) Non-central moment of order n stats(a, b, c, z, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, b, c, z, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, b, c, z, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a, b, c, z), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, b, c, z, loc=0, scale=1) Median of the distribution. mean(a, b, c, z, loc=0, scale=1) Mean of the distribution. var(a, b, c, z, loc=0, scale=1) Variance of the distribution. std(a, b, c, z, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, b, c, z, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `gausshyper` is:

.. math::

f(x, a, b, c, z) = C x^a-1 (1-x)^-1 (1+zx)^

c

}

for :math:`0 \le x \le 1`, :math:`a > 0`, :math:`b > 0`, and :math:`C = \frac

B(a, b) F[2, 1](c, a; a+b; -z)`. :math:`F2, 1` is the Gauss hypergeometric function `scipy.special.hyp2f1`.

`gausshyper` takes :math:`a`, :math:`b`, :math:`c` and :math:`z` as shape parameters.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``gausshyper.pdf(x, a, b, c, z, loc, scale)`` is identically equivalent to ``gausshyper.pdf(y, a, b, c, z) / scale`` with ``y = (x - loc) / scale``.

Examples -------- >>> from scipy.stats import gausshyper >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a, b, c, z = 13.8, 3.12, 2.51, 5.18 >>> mean, var, skew, kurt = gausshyper.stats(a, b, c, z, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(gausshyper.ppf(0.01, a, b, c, z), ... gausshyper.ppf(0.99, a, b, c, z), 100) >>> ax.plot(x, gausshyper.pdf(x, a, b, c, z), ... 'r-', lw=5, alpha=0.6, label='gausshyper pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = gausshyper(a, b, c, z) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = gausshyper.ppf(0.001, 0.5, 0.999, a, b, c, z) >>> np.allclose(0.001, 0.5, 0.999, gausshyper.cdf(vals, a, b, c, z)) True

Generate random numbers:

>>> r = gausshyper.rvs(a, b, c, z, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()

A generalized exponential continuous random variable.

As an instance of the `rv_continuous` class, `genexpon` object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.

Methods ------- rvs(a, b, c, loc=0, scale=1, size=1, random_state=None) Random variates. pdf(x, a, b, c, loc=0, scale=1) Probability density function. logpdf(x, a, b, c, loc=0, scale=1) Log of the probability density function. cdf(x, a, b, c, loc=0, scale=1) Cumulative distribution function. logcdf(x, a, b, c, loc=0, scale=1) Log of the cumulative distribution function. sf(x, a, b, c, loc=0, scale=1) Survival function (also defined as ``1 - cdf``, but `sf` is sometimes more accurate). logsf(x, a, b, c, loc=0, scale=1) Log of the survival function. ppf(q, a, b, c, loc=0, scale=1) Percent point function (inverse of ``cdf`` --- percentiles). isf(q, a, b, c, loc=0, scale=1) Inverse survival function (inverse of ``sf``). moment(n, a, b, c, loc=0, scale=1) Non-central moment of order n stats(a, b, c, loc=0, scale=1, moments='mv') Mean('m'), variance('v'), skew('s'), and/or kurtosis('k'). entropy(a, b, c, loc=0, scale=1) (Differential) entropy of the RV. fit(data, a, b, c, loc=0, scale=1) Parameter estimates for generic data. expect(func, args=(a, b, c), loc=0, scale=1, lb=None, ub=None, conditional=False, **kwds) Expected value of a function (of one argument) with respect to the distribution. median(a, b, c, loc=0, scale=1) Median of the distribution. mean(a, b, c, loc=0, scale=1) Mean of the distribution. var(a, b, c, loc=0, scale=1) Variance of the distribution. std(a, b, c, loc=0, scale=1) Standard deviation of the distribution. interval(alpha, a, b, c, loc=0, scale=1) Endpoints of the range that contains alpha percent of the distribution

Notes ----- The probability density function for `genexpon` is:

.. math::

f(x, a, b, c) = (a + b (1 - \exp(-c x))) \exp(-a x - b x + \fracc (1-\exp(-c x)))

for :math:`x \ge 0`, :math:`a, b, c > 0`.

`genexpon` takes :math:`a`, :math:`b` and :math:`c` as shape parameters.

The probability density above is defined in the 'standardized' form. To shift and/or scale the distribution use the ``loc`` and ``scale`` parameters. Specifically, ``genexpon.pdf(x, a, b, c, loc, scale)`` is identically equivalent to ``genexpon.pdf(y, a, b, c) / scale`` with ``y = (x - loc) / scale``.

References ---------- H.K. Ryu, 'An Extension of Marshall and Olkin's Bivariate Exponential Distribution', Journal of the American Statistical Association, 1993.

N. Balakrishnan, 'The Exponential Distribution: Theory, Methods and Applications', Asit P. Basu.

Examples -------- >>> from scipy.stats import genexpon >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(1, 1)

Calculate a few first moments:

>>> a, b, c = 9.13, 16.2, 3.28 >>> mean, var, skew, kurt = genexpon.stats(a, b, c, moments='mvsk')

Display the probability density function (``pdf``):

>>> x = np.linspace(genexpon.ppf(0.01, a, b, c), ... genexpon.ppf(0.99, a, b, c), 100) >>> ax.plot(x, genexpon.pdf(x, a, b, c), ... 'r-', lw=5, alpha=0.6, label='genexpon pdf')

Alternatively, the distribution object can be called (as a function) to fix the shape, location and scale parameters. This returns a 'frozen' RV object holding the given parameters fixed.

Freeze the distribution and display the frozen ``pdf``:

>>> rv = genexpon(a, b, c) >>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')

Check accuracy of ``cdf`` and ``ppf``:

>>> vals = genexpon.ppf(0.001, 0.5, 0.999, a, b, c) >>> np.allclose(0.001, 0.5, 0.999, genexpon.cdf(vals, a, b, c)) True

Generate random numbers:

>>> r = genexpon.rvs(a, b, c, size=1000)

And compare the histogram:

>>> ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) >>> ax.legend(loc='best', frameon=False) >>> plt.show()