package scipy

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `Levy_stable_gen
]
type t = [ `Levy_stable_gen | `Object | `Rv_continuous | `Rv_generic ] Obj.t
val of_pyobject : Py.Object.t -> t
val to_pyobject : [> tag ] Obj.t -> Py.Object.t
val as_rv_generic : t -> [ `Rv_generic ] Obj.t
val as_rv_continuous : t -> [ `Rv_continuous ] Obj.t
val create : ?momtype:Py.Object.t -> ?a:Py.Object.t -> ?b:Py.Object.t -> ?xtol:Py.Object.t -> ?badvalue:Py.Object.t -> ?name:Py.Object.t -> ?longname:Py.Object.t -> ?shapes:Py.Object.t -> ?extradoc:Py.Object.t -> ?seed:Py.Object.t -> unit -> t

A Levy-stable continuous random variable.

%(before_notes)s

See Also -------- levy, levy_l

Notes ----- The distribution for `levy_stable` has characteristic function:

.. math::

\varphi(t, \alpha, \beta, c, \mu) = e^t\mu -|ct|^\alpha(1-i\beta \operatornamesign(t)\Phi(\alpha, t))

where:

.. math::

\Phi = \begincases \tan \left(\frac {\pi \alpha

}

\right)&\alpha \neq 1\\

  • \frac {2\pi

}

\log |t|&\alpha =1 \endcases

The probability density function for `levy_stable` is:

.. math::

f(x) = \frac

\pi

\int_

\infty

}

^\infty \varphi(t)e^

ixt

}

\,dt

where :math:`-\infty < t < \infty`. This integral does not have a known closed form.

For evaluation of pdf we use either Zolotarev :math:`S_0` parameterization with integration, direct integration of standard parameterization of characteristic function or FFT of characteristic function. If set to other than None and if number of points is greater than ``levy_stable.pdf_fft_min_points_threshold`` (defaults to None) we use FFT otherwise we use one of the other methods.

The default method is 'best' which uses Zolotarev's method if alpha = 1 and integration of characteristic function otherwise. The default method can be changed by setting ``levy_stable.pdf_default_method`` to either 'zolotarev', 'quadrature' or 'best'.

To increase accuracy of FFT calculation one can specify ``levy_stable.pdf_fft_grid_spacing`` (defaults to 0.001) and ``pdf_fft_n_points_two_power`` (defaults to a value that covers the input range * 4). Setting ``pdf_fft_n_points_two_power`` to 16 should be sufficiently accurate in most cases at the expense of CPU time.

For evaluation of cdf we use Zolatarev :math:`S_0` parameterization with integration or integral of the pdf FFT interpolated spline. The settings affecting FFT calculation are the same as for pdf calculation. Setting the threshold to ``None`` (default) will disable FFT. For cdf calculations the Zolatarev method is superior in accuracy, so FFT is disabled by default.

Fitting estimate uses quantile estimation method in MC. MLE estimation of parameters in fit method uses this quantile estimate initially. Note that MLE doesn't always converge if using FFT for pdf calculations; so it's best that ``pdf_fft_min_points_threshold`` is left unset.

.. warning::

For pdf calculations implementation of Zolatarev is unstable for values where alpha = 1 and beta != 0. In this case the quadrature method is recommended. FFT calculation is also considered experimental.

For cdf calculations FFT calculation is considered experimental. Use Zolatarev's method instead (default).

%(after_notes)s

References ---------- .. MC McCulloch, J., 1986. Simple consistent estimators of stable distribution parameters. Communications in Statistics - Simulation and Computation 15, 11091136. .. MS Mittnik, S.T. Rachev, T. Doganoglu, D. Chenyao, 1999. Maximum likelihood estimation of stable Paretian models, Mathematical and Computer Modelling, Volume 29, Issue 10, 1999, Pages 275-293. .. BS Borak, S., Hardle, W., Rafal, W. 2005. Stable distributions, Economic Risk.

%(example)s

val cdf : ?kwds:(string * Py.Object.t) list -> x:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Cumulative distribution function of the given RV.

Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- cdf : ndarray Cumulative distribution function evaluated at `x`

val entropy : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> Py.Object.t

Differential entropy of the RV.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). scale : array_like, optional (continuous distributions only). Scale parameter (default=1).

Notes ----- Entropy is defined base `e`:

>>> drv = rv_discrete(values=((0, 1), (0.5, 0.5))) >>> np.allclose(drv.entropy(), np.log(2.0)) True

val expect : ?func:Py.Object.t -> ?args:Py.Object.t -> ?loc:float -> ?scale:float -> ?lb:Py.Object.t -> ?ub:Py.Object.t -> ?conditional:bool -> ?kwds:(string * Py.Object.t) list -> [> tag ] Obj.t -> float

Calculate expected value of a function with respect to the distribution by numerical integration.

The expected value of a function ``f(x)`` with respect to a distribution ``dist`` is defined as::

ub Ef(x) = Integral(f(x) * dist.pdf(x)), lb

where ``ub`` and ``lb`` are arguments and ``x`` has the ``dist.pdf(x)`` distribution. If the bounds ``lb`` and ``ub`` correspond to the support of the distribution, e.g. ``-inf, inf`` in the default case, then the integral is the unrestricted expectation of ``f(x)``. Also, the function ``f(x)`` may be defined such that ``f(x)`` is ``0`` outside a finite interval in which case the expectation is calculated within the finite range ``lb, ub``.

Parameters ---------- func : callable, optional Function for which integral is calculated. Takes only one argument. The default is the identity mapping f(x) = x. args : tuple, optional Shape parameters of the distribution. loc : float, optional Location parameter (default=0). scale : float, optional Scale parameter (default=1). lb, ub : scalar, optional Lower and upper bound for integration. Default is set to the support of the distribution. conditional : bool, optional If True, the integral is corrected by the conditional probability of the integration interval. The return value is the expectation of the function, conditional on being in the given interval. Default is False.

Additional keyword arguments are passed to the integration routine.

Returns ------- expect : float The calculated expected value.

Notes ----- The integration behavior of this function is inherited from `scipy.integrate.quad`. Neither this function nor `scipy.integrate.quad` can verify whether the integral exists or is finite. For example ``cauchy(0).mean()`` returns ``np.nan`` and ``cauchy(0).expect()`` returns ``0.0``.

The function is not vectorized.

Examples --------

To understand the effect of the bounds of integration consider

>>> from scipy.stats import expon >>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0) 0.6321205588285578

This is close to

>>> expon(1).cdf(2.0) - expon(1).cdf(0.0) 0.6321205588285577

If ``conditional=True``

>>> expon(1).expect(lambda x: 1, lb=0.0, ub=2.0, conditional=True) 1.0000000000000002

The slight deviation from 1 is due to numerical integration.

val fit : ?kwds:(string * Py.Object.t) list -> data:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> Py.Object.t

Return MLEs for shape (if applicable), location, and scale parameters from data.

MLE stands for Maximum Likelihood Estimate. Starting estimates for the fit are given by input arguments; for any arguments not provided with starting estimates, ``self._fitstart(data)`` is called to generate such.

One can hold some parameters fixed to specific values by passing in keyword arguments ``f0``, ``f1``, ..., ``fn`` (for shape parameters) and ``floc`` and ``fscale`` (for location and scale parameters, respectively).

Parameters ---------- data : array_like Data to use in calculating the MLEs. arg1, arg2, arg3,... : floats, optional Starting value(s) for any shape-characterizing arguments (those not provided will be determined by a call to ``_fitstart(data)``). No default value. kwds : floats, optional

  • `loc`: initial guess of the distribution's location parameter.
  • `scale`: initial guess of the distribution's scale parameter.

Special keyword arguments are recognized as holding certain parameters fixed:

  • f0...fn : hold respective shape parameters fixed. Alternatively, shape parameters to fix can be specified by name. For example, if ``self.shapes == 'a, b'``, ``fa`` and ``fix_a`` are equivalent to ``f0``, and ``fb`` and ``fix_b`` are equivalent to ``f1``.
  • floc : hold location parameter fixed to specified value.
  • fscale : hold scale parameter fixed to specified value.
  • optimizer : The optimizer to use. The optimizer must take ``func``, and starting position as the first two arguments, plus ``args`` (for extra arguments to pass to the function to be optimized) and ``disp=0`` to suppress output as keyword arguments.

Returns ------- mle_tuple : tuple of floats MLEs for any shape parameters (if applicable), followed by those for location and scale. For most random variables, shape statistics will be returned, but there are exceptions (e.g. ``norm``).

Notes ----- This fit is computed by maximizing a log-likelihood function, with penalty applied for samples outside of range of the distribution. The returned answer is not guaranteed to be the globally optimal MLE, it may only be locally optimal, or the optimization may fail altogether. If the data contain any of np.nan, np.inf, or -np.inf, the fit routine will throw a RuntimeError.

Examples --------

Generate some data to fit: draw random variates from the `beta` distribution

>>> from scipy.stats import beta >>> a, b = 1., 2. >>> x = beta.rvs(a, b, size=1000)

Now we can fit all four parameters (``a``, ``b``, ``loc`` and ``scale``):

>>> a1, b1, loc1, scale1 = beta.fit(x)

We can also use some prior knowledge about the dataset: let's keep ``loc`` and ``scale`` fixed:

>>> a1, b1, loc1, scale1 = beta.fit(x, floc=0, fscale=1) >>> loc1, scale1 (0, 1)

We can also keep shape parameters fixed by using ``f``-keywords. To keep the zero-th shape parameter ``a`` equal 1, use ``f0=1`` or, equivalently, ``fa=1``:

>>> a1, b1, loc1, scale1 = beta.fit(x, fa=1, floc=0, fscale=1) >>> a1 1

Not all distributions return estimates for the shape parameters. ``norm`` for example just returns estimates for location and scale:

>>> from scipy.stats import norm >>> x = norm.rvs(a, b, size=1000, random_state=123) >>> loc1, scale1 = norm.fit(x) >>> loc1, scale1 (0.92087172783841631, 2.0015750750324668)

val fit_loc_scale : data:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> float * float

Estimate loc and scale parameters from data using 1st and 2nd moments.

Parameters ---------- data : array_like Data to fit. arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information).

Returns ------- Lhat : float Estimated location parameter for the data. Shat : float Estimated scale parameter for the data.

val freeze : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> Py.Object.t

Freeze the distribution for the given arguments.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution. Should include all the non-optional arguments, may include ``loc`` and ``scale``.

Returns ------- rv_frozen : rv_frozen instance The frozen distribution.

val interval : ?kwds:(string * Py.Object.t) list -> alpha:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> Py.Object.t

Confidence interval with equal areas around the median.

Parameters ---------- alpha : array_like of float Probability that an rv will be drawn from the returned range. Each value should be in the range 0, 1. arg1, arg2, ... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional location parameter, Default is 0. scale : array_like, optional scale parameter, Default is 1.

Returns ------- a, b : ndarray of float end-points of range that contain ``100 * alpha %`` of the rv's possible values.

val isf : ?kwds:(string * Py.Object.t) list -> q:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Inverse survival function (inverse of `sf`) at q of the given RV.

Parameters ---------- q : array_like upper tail probability arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- x : ndarray or scalar Quantile corresponding to the upper tail probability q.

val logcdf : ?kwds:(string * Py.Object.t) list -> x:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Log of the cumulative distribution function at x of the given RV.

Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- logcdf : array_like Log of the cumulative distribution function evaluated at x

val logpdf : ?kwds:(string * Py.Object.t) list -> x:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Log of the probability density function at x of the given RV.

This uses a more numerically accurate calculation if available.

Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- logpdf : array_like Log of the probability density function evaluated at x

val logsf : ?kwds:(string * Py.Object.t) list -> x:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Log of the survival function of the given RV.

Returns the log of the 'survival function,' defined as (1 - `cdf`), evaluated at `x`.

Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- logsf : ndarray Log of the survival function evaluated at `x`.

val mean : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> float

Mean of the distribution.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- mean : float the mean of the distribution

val median : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> float

Median of the distribution.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional Location parameter, Default is 0. scale : array_like, optional Scale parameter, Default is 1.

Returns ------- median : float The median of the distribution.

See Also -------- rv_discrete.ppf Inverse of the CDF

val moment : ?kwds:(string * Py.Object.t) list -> n:[ `N_1 of Py.Object.t | `I of int ] -> Py.Object.t list -> [> tag ] Obj.t -> Py.Object.t

n-th order non-central moment of distribution.

Parameters ---------- n : int, n >= 1 Order of moment. arg1, arg2, arg3,... : float The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

val nnlf : theta:Py.Object.t -> x:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Return negative loglikelihood function.

Notes ----- This is ``-sum(log pdf(x, theta), axis=0)`` where `theta` are the parameters (including loc and scale).

val pdf : ?kwds:(string * Py.Object.t) list -> x:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Probability density function at x of the given RV.

Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- pdf : ndarray Probability density function evaluated at x

val ppf : ?kwds:(string * Py.Object.t) list -> q:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Percent point function (inverse of `cdf`) at q of the given RV.

Parameters ---------- q : array_like lower tail probability arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- x : array_like quantile corresponding to the lower tail probability q.

val rvs : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Random variates of given type.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional Location parameter (default=0). scale : array_like, optional Scale parameter (default=1). size : int or tuple of ints, optional Defining number of random variates (default is 1). random_state : None, int, `~np.random.RandomState`, `~np.random.Generator`, optional If `seed` is `None` the `~np.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with seed. If `seed` is already a ``RandomState`` or ``Generator`` instance, then that object is used. Default is None.

Returns ------- rvs : ndarray or scalar Random variates of given `size`.

val sf : ?kwds:(string * Py.Object.t) list -> x:[> `Ndarray ] Np.Obj.t -> Py.Object.t list -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Survival function (1 - `cdf`) at x of the given RV.

Parameters ---------- x : array_like quantiles arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- sf : array_like Survival function evaluated at x

val stats : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> Py.Object.t

Some statistics of the given RV.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional (continuous RVs only) scale parameter (default=1) moments : str, optional composed of letters 'mvsk' defining which moments to compute: 'm' = mean, 'v' = variance, 's' = (Fisher's) skew, 'k' = (Fisher's) kurtosis. (default is 'mv')

Returns ------- stats : sequence of requested moments.

val std : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> float

Standard deviation of the distribution.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- std : float standard deviation of the distribution

val support : ?kwargs:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> Py.Object.t

Return the support of the distribution.

Parameters ---------- arg1, arg2, ... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information). loc : array_like, optional location parameter, Default is 0. scale : array_like, optional scale parameter, Default is 1. Returns ------- a, b : float end-points of the distribution's support.

val var : ?kwds:(string * Py.Object.t) list -> Py.Object.t list -> [> tag ] Obj.t -> float

Variance of the distribution.

Parameters ---------- arg1, arg2, arg3,... : array_like The shape parameter(s) for the distribution (see docstring of the instance object for more information) loc : array_like, optional location parameter (default=0) scale : array_like, optional scale parameter (default=1)

Returns ------- var : float the variance of the distribution

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Format.formatter -> t -> unit

Pretty-print the object to a formatter.

OCaml

Innovation. Community. Security.