Stats

SymPy statistics module

Introduces a random variable type into the SymPy language.

Random variables may be declared using prebuilt functions such as Normal, Exponential, Coin, Die, etc... or built with functions like FiniteRV.

Queries on random expressions can be made using the functions

Expression Meaning
P(condition) Probability
E(expression) Expected value
variance(expression) Variance
density(expression) Probability Density Function
sample(expression) Produce a realization
where(condition) Where the condition is true

Examples

>>> from sympy.stats import P, E, variance, Die, Normal
>>> from sympy import Eq, simplify
>>> X, Y = Die('X', 6), Die('Y', 6) # Define two six sided dice
>>> Z = Normal('Z', 0, 1) # Declare a Normal random variable with mean 0, std 1
>>> P(X>3) # Probability X is greater than 3
1/2
>>> E(X+Y) # Expectation of the sum of two dice
7
>>> variance(X+Y) # Variance of the sum of two dice
35/6
>>> simplify(P(Z>1)) # Probability of Z being greater than 1
-erf(sqrt(2)/2)/2 + 1/2

Random Variable Types

Finite Types

sympy.stats.DiscreteUniform(name, items)[source]

Create a Finite Random Variable representing a uniform distribution over the input set.

Returns a RandomSymbol.

Examples

>>> from sympy.stats import DiscreteUniform, density
>>> from sympy import symbols
>>> X = DiscreteUniform('X', symbols('a b c')) # equally likely over a, b, c
>>> density(X).dict
{a: 1/3, b: 1/3, c: 1/3}
>>> Y = DiscreteUniform('Y', list(range(5))) # distribution over a range
>>> density(Y).dict
{0: 1/5, 1: 1/5, 2: 1/5, 3: 1/5, 4: 1/5}
sympy.stats.Die(name, sides=6)[source]

Create a Finite Random Variable representing a fair die.

Returns a RandomSymbol.

>>> from sympy.stats import Die, density
>>> D6 = Die('D6', 6) # Six sided Die
>>> density(D6).dict
{1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6}
>>> D4 = Die('D4', 4) # Four sided Die
>>> density(D4).dict
{1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4}
sympy.stats.Bernoulli(name, p, succ=1, fail=0)[source]

Create a Finite Random Variable representing a Bernoulli process.

Returns a RandomSymbol

>>> from sympy.stats import Bernoulli, density
>>> from sympy import S
>>> X = Bernoulli('X', S(3)/4) # 1-0 Bernoulli variable, probability = 3/4
>>> density(X).dict
{0: 1/4, 1: 3/4}
>>> X = Bernoulli('X', S.Half, 'Heads', 'Tails') # A fair coin toss
>>> density(X).dict
{Heads: 1/2, Tails: 1/2}
sympy.stats.Coin(name, p=1/2)[source]

Create a Finite Random Variable representing a Coin toss.

Probability p is the chance of gettings “Heads.” Half by default

Returns a RandomSymbol.

>>> from sympy.stats import Coin, density
>>> from sympy import Rational
>>> C = Coin('C') # A fair coin toss
>>> density(C).dict
{H: 1/2, T: 1/2}
>>> C2 = Coin('C2', Rational(3, 5)) # An unfair coin
>>> density(C2).dict
{H: 3/5, T: 2/5}
sympy.stats.Binomial(name, n, p, succ=1, fail=0)[source]

Create a Finite Random Variable representing a binomial distribution.

Returns a RandomSymbol.

Examples

>>> from sympy.stats import Binomial, density
>>> from sympy import S
>>> X = Binomial('X', 4, S.Half) # Four "coin flips"
>>> density(X).dict
{0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
sympy.stats.Hypergeometric(name, N, m, n)[source]

Create a Finite Random Variable representing a hypergeometric distribution.

Returns a RandomSymbol.

Examples

>>> from sympy.stats import Hypergeometric, density
>>> from sympy import S
>>> X = Hypergeometric('X', 10, 5, 3) # 10 marbles, 5 white (success), 3 draws
>>> density(X).dict
{0: 1/12, 1: 5/12, 2: 5/12, 3: 1/12}
sympy.stats.FiniteRV(name, density)[source]

Create a Finite Random Variable given a dict representing the density.

Returns a RandomSymbol.

>>> from sympy.stats import FiniteRV, P, E
>>> density = {0: .1, 1: .2, 2: .3, 3: .4}
>>> X = FiniteRV('X', density)
>>> E(X)
2.00000000000000
>>> P(X >= 2)
0.700000000000000

Discrete Types

sympy.stats.Geometric(name, p)[source]

Create a discrete random variable with a Geometric distribution.

The density of the Geometric distribution is given by

\[f(k) := p (1 - p)^{k - 1}\]
Parameters:p: A probability between 0 and 1
Returns:A RandomSymbol.

References

[1] http://en.wikipedia.org/wiki/Geometric_distribution [2] http://mathworld.wolfram.com/GeometricDistribution.html

Examples

>>> from sympy.stats import Geometric, density, E, variance
>>> from sympy import Symbol, S
>>> p = S.One / 5
>>> z = Symbol("z")
>>> X = Geometric("x", p)
>>> density(X)(z)
(4/5)**(z - 1)/5
>>> E(X)
5
>>> variance(X)
20
sympy.stats.Poisson(name, lamda)[source]

Create a discrete random variable with a Poisson distribution.

The density of the Poisson distribution is given by

\[f(k) := \frac{\lambda^{k} e^{- \lambda}}{k!}\]
Parameters:lamda: Positive number, a rate
Returns:A RandomSymbol.

References

[1] http://en.wikipedia.org/wiki/Poisson_distribution [2] http://mathworld.wolfram.com/PoissonDistribution.html

Examples

>>> from sympy.stats import Poisson, density, E, variance
>>> from sympy import Symbol, simplify
>>> rate = Symbol("lambda", positive=True)
>>> z = Symbol("z")
>>> X = Poisson("x", rate)
>>> density(X)(z)
lambda**z*exp(-lambda)/factorial(z)
>>> E(X)
lambda
>>> simplify(variance(X))
lambda

Continuous Types

sympy.stats.Arcsin(name, a=0, b=1)[source]

Create a Continuous Random Variable with an arcsin distribution.

The density of the arcsin distribution is given by

\[f(x) := \frac{1}{\pi\sqrt{(x-a)(b-x)}}\]

with \(x \in [a,b]\). It must hold that \(-\infty < a < b < \infty\).

Parameters:

a : Real number, the left interval boundary

b : Real number, the right interval boundary

Returns:

A RandomSymbol.

References

[R475]http://en.wikipedia.org/wiki/Arcsine_distribution

Examples

>>> from sympy.stats import Arcsin, density
>>> from sympy import Symbol, simplify
>>> a = Symbol("a", real=True)
>>> b = Symbol("b", real=True)
>>> z = Symbol("z")
>>> X = Arcsin("x", a, b)
>>> density(X)(z)
1/(pi*sqrt((-a + z)*(b - z)))
sympy.stats.Benini(name, alpha, beta, sigma)[source]

Create a Continuous Random Variable with a Benini distribution.

The density of the Benini distribution is given by

\[f(x) := e^{-\alpha\log{\frac{x}{\sigma}} -\beta\log^2\left[{\frac{x}{\sigma}}\right]} \left(\frac{\alpha}{x}+\frac{2\beta\log{\frac{x}{\sigma}}}{x}\right)\]

This is a heavy-tailed distrubtion and is also known as the log-Rayleigh distribution.

Parameters:

alpha : Real number, \(\alpha > 0\), a shape

beta : Real number, \(\beta > 0\), a shape

sigma : Real number, \(\sigma > 0\), a scale

Returns:

A RandomSymbol.

References

[R476]http://en.wikipedia.org/wiki/Benini_distribution
[R477]http://reference.wolfram.com/legacy/v8/ref/BeniniDistribution.html

Examples

>>> from sympy.stats import Benini, density
>>> from sympy import Symbol, simplify, pprint
>>> alpha = Symbol("alpha", positive=True)
>>> beta = Symbol("beta", positive=True)
>>> sigma = Symbol("sigma", positive=True)
>>> z = Symbol("z")
>>> X = Benini("x", alpha, beta, sigma)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
/                  /  z  \\             /  z  \            2/  z  \
|        2*beta*log|-----||  - alpha*log|-----| - beta*log  |-----|
|alpha             \sigma/|             \sigma/             \sigma/
|----- + -----------------|*e
\  z             z        /
sympy.stats.Beta(name, alpha, beta)[source]

Create a Continuous Random Variable with a Beta distribution.

The density of the Beta distribution is given by

\[f(x) := \frac{x^{\alpha-1}(1-x)^{\beta-1}} {\mathrm{B}(\alpha,\beta)}\]

with \(x \in [0,1]\).

Parameters:

alpha : Real number, \(\alpha > 0\), a shape

beta : Real number, \(\beta > 0\), a shape

Returns:

A RandomSymbol.

References

[R478]http://en.wikipedia.org/wiki/Beta_distribution
[R479]http://mathworld.wolfram.com/BetaDistribution.html

Examples

>>> from sympy.stats import Beta, density, E, variance
>>> from sympy import Symbol, simplify, pprint, expand_func
>>> alpha = Symbol("alpha", positive=True)
>>> beta = Symbol("beta", positive=True)
>>> z = Symbol("z")
>>> X = Beta("x", alpha, beta)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
 alpha - 1         beta - 1
z         *(-z + 1)
---------------------------
     beta(alpha, beta)
>>> expand_func(simplify(E(X, meijerg=True)))
alpha/(alpha + beta)
>>> simplify(variance(X, meijerg=True))  
alpha*beta/((alpha + beta)**2*(alpha + beta + 1))
sympy.stats.BetaPrime(name, alpha, beta)[source]

Create a continuous random variable with a Beta prime distribution.

The density of the Beta prime distribution is given by

\[f(x) := \frac{x^{\alpha-1} (1+x)^{-\alpha -\beta}}{B(\alpha,\beta)}\]

with \(x > 0\).

Parameters:

alpha : Real number, \(\alpha > 0\), a shape

beta : Real number, \(\beta > 0\), a shape

Returns:

A RandomSymbol.

References

[R480]http://en.wikipedia.org/wiki/Beta_prime_distribution
[R481]http://mathworld.wolfram.com/BetaPrimeDistribution.html

Examples

>>> from sympy.stats import BetaPrime, density
>>> from sympy import Symbol, pprint
>>> alpha = Symbol("alpha", positive=True)
>>> beta = Symbol("beta", positive=True)
>>> z = Symbol("z")
>>> X = BetaPrime("x", alpha, beta)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
 alpha - 1        -alpha - beta
z         *(z + 1)
-------------------------------
       beta(alpha, beta)
sympy.stats.Cauchy(name, x0, gamma)[source]

Create a continuous random variable with a Cauchy distribution.

The density of the Cauchy distribution is given by

\[f(x) := \frac{1}{\pi} \arctan\left(\frac{x-x_0}{\gamma}\right) +\frac{1}{2}\]
Parameters:

x0 : Real number, the location

gamma : Real number, \(\gamma > 0\), the scale

Returns:

A RandomSymbol.

References

[R482]http://en.wikipedia.org/wiki/Cauchy_distribution
[R483]http://mathworld.wolfram.com/CauchyDistribution.html

Examples

>>> from sympy.stats import Cauchy, density
>>> from sympy import Symbol
>>> x0 = Symbol("x0")
>>> gamma = Symbol("gamma", positive=True)
>>> z = Symbol("z")
>>> X = Cauchy("x", x0, gamma)
>>> density(X)(z)
1/(pi*gamma*(1 + (-x0 + z)**2/gamma**2))
sympy.stats.Chi(name, k)[source]

Create a continuous random variable with a Chi distribution.

The density of the Chi distribution is given by

\[f(x) := \frac{2^{1-k/2}x^{k-1}e^{-x^2/2}}{\Gamma(k/2)}\]

with \(x \geq 0\).

Parameters:k : A positive Integer, \(k > 0\), the number of degrees of freedom
Returns:A RandomSymbol.

References

[R484]http://en.wikipedia.org/wiki/Chi_distribution
[R485]http://mathworld.wolfram.com/ChiDistribution.html

Examples

>>> from sympy.stats import Chi, density, E, std
>>> from sympy import Symbol, simplify
>>> k = Symbol("k", integer=True)
>>> z = Symbol("z")
>>> X = Chi("x", k)
>>> density(X)(z)
2**(-k/2 + 1)*z**(k - 1)*exp(-z**2/2)/gamma(k/2)
sympy.stats.ChiNoncentral(name, k, l)[source]

Create a continuous random variable with a non-central Chi distribution.

The density of the non-central Chi distribution is given by

\[f(x) := \frac{e^{-(x^2+\lambda^2)/2} x^k\lambda} {(\lambda x)^{k/2}} I_{k/2-1}(\lambda x)\]

with \(x \geq 0\). Here, \(I_\nu (x)\) is the modified Bessel function of the first kind.

Parameters:

k : A positive Integer, \(k > 0\), the number of degrees of freedom

l : Shift parameter

Returns:

A RandomSymbol.

References

[R486]http://en.wikipedia.org/wiki/Noncentral_chi_distribution

Examples

>>> from sympy.stats import ChiNoncentral, density, E, std
>>> from sympy import Symbol, simplify
>>> k = Symbol("k", integer=True)
>>> l = Symbol("l")
>>> z = Symbol("z")
>>> X = ChiNoncentral("x", k, l)
>>> density(X)(z)
l*z**k*(l*z)**(-k/2)*exp(-l**2/2 - z**2/2)*besseli(k/2 - 1, l*z)
sympy.stats.ChiSquared(name, k)[source]

Create a continuous random variable with a Chi-squared distribution.

The density of the Chi-squared distribution is given by

\[f(x) := \frac{1}{2^{\frac{k}{2}}\Gamma\left(\frac{k}{2}\right)} x^{\frac{k}{2}-1} e^{-\frac{x}{2}}\]

with \(x \geq 0\).

Parameters:k : A positive Integer, \(k > 0\), the number of degrees of freedom
Returns:A RandomSymbol.

References

[R487]http://en.wikipedia.org/wiki/Chi_squared_distribution
[R488]http://mathworld.wolfram.com/Chi-SquaredDistribution.html

Examples

>>> from sympy.stats import ChiSquared, density, E, variance
>>> from sympy import Symbol, simplify, combsimp, expand_func
>>> k = Symbol("k", integer=True, positive=True)
>>> z = Symbol("z")
>>> X = ChiSquared("x", k)
>>> density(X)(z)
2**(-k/2)*z**(k/2 - 1)*exp(-z/2)/gamma(k/2)
>>> combsimp(E(X))
k
>>> simplify(expand_func(variance(X)))
2*k
sympy.stats.Dagum(name, p, a, b)[source]

Create a continuous random variable with a Dagum distribution.

The density of the Dagum distribution is given by

\[f(x) := \frac{a p}{x} \left( \frac{\left(\tfrac{x}{b}\right)^{a p}} {\left(\left(\tfrac{x}{b}\right)^a + 1 \right)^{p+1}} \right)\]

with \(x > 0\).

Parameters:

p : Real number, \(p > 0\), a shape

a : Real number, \(a > 0\), a shape

b : Real number, \(b > 0\), a scale

Returns:

A RandomSymbol.

References

[R489]http://en.wikipedia.org/wiki/Dagum_distribution

Examples

>>> from sympy.stats import Dagum, density
>>> from sympy import Symbol, simplify
>>> p = Symbol("p", positive=True)
>>> b = Symbol("b", positive=True)
>>> a = Symbol("a", positive=True)
>>> z = Symbol("z")
>>> X = Dagum("x", p, a, b)
>>> density(X)(z)
a*p*(z/b)**(a*p)*((z/b)**a + 1)**(-p - 1)/z
sympy.stats.Erlang(name, k, l)[source]

Create a continuous random variable with an Erlang distribution.

The density of the Erlang distribution is given by

\[f(x) := \frac{\lambda^k x^{k-1} e^{-\lambda x}}{(k-1)!}\]

with \(x \in [0,\infty]\).

Parameters:

k : Integer

l : Real number, \(\lambda > 0\), the rate

Returns:

A RandomSymbol.

References

[R490]http://en.wikipedia.org/wiki/Erlang_distribution
[R491]http://mathworld.wolfram.com/ErlangDistribution.html

Examples

>>> from sympy.stats import Erlang, density, cdf, E, variance
>>> from sympy import Symbol, simplify, pprint
>>> k = Symbol("k", integer=True, positive=True)
>>> l = Symbol("l", positive=True)
>>> z = Symbol("z")
>>> X = Erlang("x", k, l)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
 k  k - 1  -l*z
l *z     *e
---------------
    gamma(k)
>>> C = cdf(X, meijerg=True)(z)
>>> pprint(C, use_unicode=False)
/     -2*I*pi*k                       -2*I*pi*k
|  k*e         *lowergamma(k, 0)   k*e         *lowergamma(k, l*z)
|- ----------------------------- + -------------------------------  for z >= 0
<           gamma(k + 1)                     gamma(k + 1)
|
|                                0                                  otherwise
\
>>> simplify(E(X))
k/l
>>> simplify(variance(X))
k/l**2
sympy.stats.Exponential(name, rate)[source]

Create a continuous random variable with an Exponential distribution.

The density of the exponential distribution is given by

\[f(x) := \lambda \exp(-\lambda x)\]

with \(x > 0\). Note that the expected value is \(1/\lambda\).

Parameters:rate : A positive Real number, \(\lambda > 0\), the rate (or inverse scale/inverse mean)
Returns:A RandomSymbol.

References

[R492]http://en.wikipedia.org/wiki/Exponential_distribution
[R493]http://mathworld.wolfram.com/ExponentialDistribution.html

Examples

>>> from sympy.stats import Exponential, density, cdf, E
>>> from sympy.stats import variance, std, skewness
>>> from sympy import Symbol
>>> l = Symbol("lambda", positive=True)
>>> z = Symbol("z")
>>> X = Exponential("x", l)
>>> density(X)(z)
lambda*exp(-lambda*z)
>>> cdf(X)(z)
Piecewise((1 - exp(-lambda*z), z >= 0), (0, True))
>>> E(X)
1/lambda
>>> variance(X)
lambda**(-2)
>>> skewness(X)
2
>>> X = Exponential('x', 10)
>>> density(X)(z)
10*exp(-10*z)
>>> E(X)
1/10
>>> std(X)
1/10
sympy.stats.FDistribution(name, d1, d2)[source]

Create a continuous random variable with a F distribution.

The density of the F distribution is given by

\[f(x) := \frac{\sqrt{\frac{(d_1 x)^{d_1} d_2^{d_2}} {(d_1 x + d_2)^{d_1 + d_2}}}} {x \mathrm{B} \left(\frac{d_1}{2}, \frac{d_2}{2}\right)}\]

with \(x > 0\).

Parameters:

d1 : \(d_1 > 0\) a parameter

d2 : \(d_2 > 0\) a parameter

Returns:

A RandomSymbol.

References

[R494]http://en.wikipedia.org/wiki/F-distribution
[R495]http://mathworld.wolfram.com/F-Distribution.html

Examples

>>> from sympy.stats import FDistribution, density
>>> from sympy import Symbol, simplify, pprint
>>> d1 = Symbol("d1", positive=True)
>>> d2 = Symbol("d2", positive=True)
>>> z = Symbol("z")
>>> X = FDistribution("x", d1, d2)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
  d2
  --    ______________________________
  2    /       d1            -d1 - d2
d2  *\/  (d1*z)  *(d1*z + d2)
--------------------------------------
                  /d1  d2\
            z*beta|--, --|
                  \2   2 /
sympy.stats.FisherZ(name, d1, d2)[source]

Create a Continuous Random Variable with an Fisher’s Z distribution.

The density of the Fisher’s Z distribution is given by

\[f(x) := \frac{2d_1^{d_1/2} d_2^{d_2/2}} {\mathrm{B}(d_1/2, d_2/2)} \frac{e^{d_1z}}{\left(d_1e^{2z}+d_2\right)^{\left(d_1+d_2\right)/2}}\]
Parameters:

d1 : \(d_1 > 0\), degree of freedom

d2 : \(d_2 > 0\), degree of freedom

Returns:

A RandomSymbol.

References

[R496]http://en.wikipedia.org/wiki/Fisher%27s_z-distribution
[R497]http://mathworld.wolfram.com/Fishersz-Distribution.html

Examples

>>> from sympy.stats import FisherZ, density
>>> from sympy import Symbol, simplify, pprint
>>> d1 = Symbol("d1", positive=True)
>>> d2 = Symbol("d2", positive=True)
>>> z = Symbol("z")
>>> X = FisherZ("x", d1, d2)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
                            d1   d2
    d1   d2               - -- - --
    --   --                 2    2
    2    2  /    2*z     \           d1*z
2*d1  *d2  *\d1*e    + d2/         *e
-----------------------------------------
                   /d1  d2\
               beta|--, --|
                   \2   2 /
sympy.stats.Frechet(name, a, s=1, m=0)[source]

Create a continuous random variable with a Frechet distribution.

The density of the Frechet distribution is given by

\[f(x) := \frac{\alpha}{s} \left(\frac{x-m}{s}\right)^{-1-\alpha} e^{-(\frac{x-m}{s})^{-\alpha}}\]

with \(x \geq m\).

Parameters:

a : Real number, \(a \in \left(0, \infty\right)\) the shape

s : Real number, \(s \in \left(0, \infty\right)\) the scale

m : Real number, \(m \in \left(-\infty, \infty\right)\) the minimum

Returns:

A RandomSymbol.

References

[R498]http://en.wikipedia.org/wiki/Fr%C3%A9chet_distribution

Examples

>>> from sympy.stats import Frechet, density, E, std
>>> from sympy import Symbol, simplify
>>> a = Symbol("a", positive=True)
>>> s = Symbol("s", positive=True)
>>> m = Symbol("m", real=True)
>>> z = Symbol("z")
>>> X = Frechet("x", a, s, m)
>>> density(X)(z)
a*((-m + z)/s)**(-a - 1)*exp(-((-m + z)/s)**(-a))/s
sympy.stats.Gamma(name, k, theta)[source]

Create a continuous random variable with a Gamma distribution.

The density of the Gamma distribution is given by

\[f(x) := \frac{1}{\Gamma(k) \theta^k} x^{k - 1} e^{-\frac{x}{\theta}}\]

with \(x \in [0,1]\).

Parameters:

k : Real number, \(k > 0\), a shape

theta : Real number, \(\theta > 0\), a scale

Returns:

A RandomSymbol.

References

[R499]http://en.wikipedia.org/wiki/Gamma_distribution
[R500]http://mathworld.wolfram.com/GammaDistribution.html

Examples

>>> from sympy.stats import Gamma, density, cdf, E, variance
>>> from sympy import Symbol, pprint, simplify
>>> k = Symbol("k", positive=True)
>>> theta = Symbol("theta", positive=True)
>>> z = Symbol("z")
>>> X = Gamma("x", k, theta)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
                  -z
                -----
     -k  k - 1  theta
theta  *z     *e
---------------------
       gamma(k)
>>> C = cdf(X, meijerg=True)(z)
>>> pprint(C, use_unicode=False)
/                                   /     z  \
|                       k*lowergamma|k, -----|
|  k*lowergamma(k, 0)               \   theta/
<- ------------------ + ----------------------  for z >= 0
|     gamma(k + 1)           gamma(k + 1)
|
\                      0                        otherwise
>>> E(X)
theta*gamma(k + 1)/gamma(k)
>>> V = simplify(variance(X))
>>> pprint(V, use_unicode=False)
       2
k*theta
sympy.stats.GammaInverse(name, a, b)[source]

Create a continuous random variable with an inverse Gamma distribution.

The density of the inverse Gamma distribution is given by

\[f(x) := \frac{\beta^\alpha}{\Gamma(\alpha)} x^{-\alpha - 1} \exp\left(\frac{-\beta}{x}\right)\]

with \(x > 0\).

Parameters:

a : Real number, \(a > 0\) a shape

b : Real number, \(b > 0\) a scale

Returns:

A RandomSymbol.

References

[R501]http://en.wikipedia.org/wiki/Inverse-gamma_distribution

Examples

>>> from sympy.stats import GammaInverse, density, cdf, E, variance
>>> from sympy import Symbol, pprint
>>> a = Symbol("a", positive=True)
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = GammaInverse("x", a, b)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
            -b
            ---
 a  -a - 1   z
b *z      *e
---------------
   gamma(a)
sympy.stats.Kumaraswamy(name, a, b)[source]

Create a Continuous Random Variable with a Kumaraswamy distribution.

The density of the Kumaraswamy distribution is given by

\[f(x) := a b x^{a-1} (1-x^a)^{b-1}\]

with \(x \in [0,1]\).

Parameters:

a : Real number, \(a > 0\) a shape

b : Real number, \(b > 0\) a shape

Returns:

A RandomSymbol.

References

[R502]http://en.wikipedia.org/wiki/Kumaraswamy_distribution

Examples

>>> from sympy.stats import Kumaraswamy, density, E, variance
>>> from sympy import Symbol, simplify, pprint
>>> a = Symbol("a", positive=True)
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = Kumaraswamy("x", a, b)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
                     b - 1
     a - 1 /   a    \
a*b*z     *\- z  + 1/
sympy.stats.Laplace(name, mu, b)[source]

Create a continuous random variable with a Laplace distribution.

The density of the Laplace distribution is given by

\[f(x) := \frac{1}{2 b} \exp \left(-\frac{|x-\mu|}b \right)\]
Parameters:

mu : Real number, the location (mean)

b : Real number, \(b > 0\), a scale

Returns:

A RandomSymbol.

References

[R503]http://en.wikipedia.org/wiki/Laplace_distribution
[R504]http://mathworld.wolfram.com/LaplaceDistribution.html

Examples

>>> from sympy.stats import Laplace, density
>>> from sympy import Symbol
>>> mu = Symbol("mu")
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = Laplace("x", mu, b)
>>> density(X)(z)
exp(-Abs(mu - z)/b)/(2*b)
sympy.stats.Logistic(name, mu, s)[source]

Create a continuous random variable with a logistic distribution.

The density of the logistic distribution is given by

\[f(x) := \frac{e^{-(x-\mu)/s}} {s\left(1+e^{-(x-\mu)/s}\right)^2}\]
Parameters:

mu : Real number, the location (mean)

s : Real number, \(s > 0\) a scale

Returns:

A RandomSymbol.

References

[R505]http://en.wikipedia.org/wiki/Logistic_distribution
[R506]http://mathworld.wolfram.com/LogisticDistribution.html

Examples

>>> from sympy.stats import Logistic, density
>>> from sympy import Symbol
>>> mu = Symbol("mu", real=True)
>>> s = Symbol("s", positive=True)
>>> z = Symbol("z")
>>> X = Logistic("x", mu, s)
>>> density(X)(z)
exp((mu - z)/s)/(s*(exp((mu - z)/s) + 1)**2)
sympy.stats.LogNormal(name, mean, std)[source]

Create a continuous random variable with a log-normal distribution.

The density of the log-normal distribution is given by

\[f(x) := \frac{1}{x\sqrt{2\pi\sigma^2}} e^{-\frac{\left(\ln x-\mu\right)^2}{2\sigma^2}}\]

with \(x \geq 0\).

Parameters:

mu : Real number, the log-scale

sigma : Real number, \(\sigma^2 > 0\) a shape

Returns:

A RandomSymbol.

References

[R507]http://en.wikipedia.org/wiki/Lognormal
[R508]http://mathworld.wolfram.com/LogNormalDistribution.html

Examples

>>> from sympy.stats import LogNormal, density
>>> from sympy import Symbol, simplify, pprint
>>> mu = Symbol("mu", real=True)
>>> sigma = Symbol("sigma", positive=True)
>>> z = Symbol("z")
>>> X = LogNormal("x", mu, sigma)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
                      2
       -(-mu + log(z))
       -----------------
                  2
  ___      2*sigma
\/ 2 *e
------------------------
        ____
    2*\/ pi *sigma*z
>>> X = LogNormal('x', 0, 1) # Mean 0, standard deviation 1
>>> density(X)(z)
sqrt(2)*exp(-log(z)**2/2)/(2*sqrt(pi)*z)
sympy.stats.Maxwell(name, a)[source]

Create a continuous random variable with a Maxwell distribution.

The density of the Maxwell distribution is given by

\[f(x) := \sqrt{\frac{2}{\pi}} \frac{x^2 e^{-x^2/(2a^2)}}{a^3}\]

with \(x \geq 0\).

Parameters:a : Real number, \(a > 0\)
Returns:A RandomSymbol.

References

[R509]http://en.wikipedia.org/wiki/Maxwell_distribution
[R510]http://mathworld.wolfram.com/MaxwellDistribution.html

Examples

>>> from sympy.stats import Maxwell, density, E, variance
>>> from sympy import Symbol, simplify
>>> a = Symbol("a", positive=True)
>>> z = Symbol("z")
>>> X = Maxwell("x", a)
>>> density(X)(z)
sqrt(2)*z**2*exp(-z**2/(2*a**2))/(sqrt(pi)*a**3)
>>> E(X)
2*sqrt(2)*a/sqrt(pi)
>>> simplify(variance(X))
a**2*(-8 + 3*pi)/pi
sympy.stats.Nakagami(name, mu, omega)[source]

Create a continuous random variable with a Nakagami distribution.

The density of the Nakagami distribution is given by

\[f(x) := \frac{2\mu^\mu}{\Gamma(\mu)\omega^\mu} x^{2\mu-1} \exp\left(-\frac{\mu}{\omega}x^2 \right)\]

with \(x > 0\).

Parameters:

mu : Real number, \(\mu \geq \frac{1}{2}\) a shape

omega : Real number, \(\omega > 0\), the spread

Returns:

A RandomSymbol.

References

[R511]http://en.wikipedia.org/wiki/Nakagami_distribution

Examples

>>> from sympy.stats import Nakagami, density, E, variance
>>> from sympy import Symbol, simplify, pprint
>>> mu = Symbol("mu", positive=True)
>>> omega = Symbol("omega", positive=True)
>>> z = Symbol("z")
>>> X = Nakagami("x", mu, omega)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
                                2
                           -mu*z
                           -------
    mu      -mu  2*mu - 1  omega
2*mu  *omega   *z        *e
----------------------------------
            gamma(mu)
>>> simplify(E(X, meijerg=True))
sqrt(mu)*sqrt(omega)*gamma(mu + 1/2)/gamma(mu + 1)
>>> V = simplify(variance(X, meijerg=True))
>>> pprint(V, use_unicode=False)
                    2
         omega*gamma (mu + 1/2)
omega - -----------------------
        gamma(mu)*gamma(mu + 1)
sympy.stats.Normal(name, mean, std)[source]

Create a continuous random variable with a Normal distribution.

The density of the Normal distribution is given by

\[f(x) := \frac{1}{\sigma\sqrt{2\pi}} e^{ -\frac{(x-\mu)^2}{2\sigma^2} }\]
Parameters:

mu : Real number, the mean

sigma : Real number, \(\sigma^2 > 0\) the variance

Returns:

A RandomSymbol.

References

[R512]http://en.wikipedia.org/wiki/Normal_distribution
[R513]http://mathworld.wolfram.com/NormalDistributionFunction.html

Examples

>>> from sympy.stats import Normal, density, E, std, cdf, skewness
>>> from sympy import Symbol, simplify, pprint, factor, together, factor_terms
>>> mu = Symbol("mu")
>>> sigma = Symbol("sigma", positive=True)
>>> z = Symbol("z")
>>> X = Normal("x", mu, sigma)
>>> density(X)(z)
sqrt(2)*exp(-(-mu + z)**2/(2*sigma**2))/(2*sqrt(pi)*sigma)
>>> C = simplify(cdf(X))(z) # it needs a little more help...
>>> pprint(C, use_unicode=False)
   /  ___          \
   |\/ 2 *(-mu + z)|
erf|---------------|
   \    2*sigma    /   1
-------------------- + -
         2             2
>>> simplify(skewness(X))
0
>>> X = Normal("x", 0, 1) # Mean 0, standard deviation 1
>>> density(X)(z)
sqrt(2)*exp(-z**2/2)/(2*sqrt(pi))
>>> E(2*X + 1)
1
>>> simplify(std(2*X + 1))
2
sympy.stats.Pareto(name, xm, alpha)[source]

Create a continuous random variable with the Pareto distribution.

The density of the Pareto distribution is given by

\[f(x) := \frac{\alpha\,x_m^\alpha}{x^{\alpha+1}}\]

with \(x \in [x_m,\infty]\).

Parameters:

xm : Real number, \(x_m > 0\), a scale

alpha : Real number, \(\alpha > 0\), a shape

Returns:

A RandomSymbol.

References

[R514]http://en.wikipedia.org/wiki/Pareto_distribution
[R515]http://mathworld.wolfram.com/ParetoDistribution.html

Examples

>>> from sympy.stats import Pareto, density
>>> from sympy import Symbol
>>> xm = Symbol("xm", positive=True)
>>> beta = Symbol("beta", positive=True)
>>> z = Symbol("z")
>>> X = Pareto("x", xm, beta)
>>> density(X)(z)
beta*xm**beta*z**(-beta - 1)
sympy.stats.QuadraticU(name, a, b)[source]

Create a Continuous Random Variable with a U-quadratic distribution.

The density of the U-quadratic distribution is given by

\[f(x) := \alpha (x-\beta)^2\]

with \(x \in [a,b]\).

Parameters:

a : Real number

b : Real number, \(a < b\)

Returns:

A RandomSymbol.

References

[R516]http://en.wikipedia.org/wiki/U-quadratic_distribution

Examples

>>> from sympy.stats import QuadraticU, density, E, variance
>>> from sympy import Symbol, simplify, factor, pprint
>>> a = Symbol("a", real=True)
>>> b = Symbol("b", real=True)
>>> z = Symbol("z")
>>> X = QuadraticU("x", a, b)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
/                2
|   /  a   b    \
|12*|- - - - + z|
|   \  2   2    /
<-----------------  for And(a <= z, z <= b)
|            3
|    (-a + b)
|
\        0                 otherwise
sympy.stats.RaisedCosine(name, mu, s)[source]

Create a Continuous Random Variable with a raised cosine distribution.

The density of the raised cosine distribution is given by

\[f(x) := \frac{1}{2s}\left(1+\cos\left(\frac{x-\mu}{s}\pi\right)\right)\]

with \(x \in [\mu-s,\mu+s]\).

Parameters:

mu : Real number

s : Real number, \(s > 0\)

Returns:

A RandomSymbol.

References

[R517]http://en.wikipedia.org/wiki/Raised_cosine_distribution

Examples

>>> from sympy.stats import RaisedCosine, density, E, variance
>>> from sympy import Symbol, simplify, pprint
>>> mu = Symbol("mu", real=True)
>>> s = Symbol("s", positive=True)
>>> z = Symbol("z")
>>> X = RaisedCosine("x", mu, s)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
/   /pi*(-mu + z)\
|cos|------------| + 1
|   \     s      /
<---------------------  for And(z <= mu + s, mu - s <= z)
|         2*s
|
\          0                        otherwise
sympy.stats.Rayleigh(name, sigma)[source]

Create a continuous random variable with a Rayleigh distribution.

The density of the Rayleigh distribution is given by

\[f(x) := \frac{x}{\sigma^2} e^{-x^2/2\sigma^2}\]

with \(x > 0\).

Parameters:sigma : Real number, \(\sigma > 0\)
Returns:A RandomSymbol.

References

[R518]http://en.wikipedia.org/wiki/Rayleigh_distribution
[R519]http://mathworld.wolfram.com/RayleighDistribution.html

Examples

>>> from sympy.stats import Rayleigh, density, E, variance
>>> from sympy import Symbol, simplify
>>> sigma = Symbol("sigma", positive=True)
>>> z = Symbol("z")
>>> X = Rayleigh("x", sigma)
>>> density(X)(z)
z*exp(-z**2/(2*sigma**2))/sigma**2
>>> E(X)
sqrt(2)*sqrt(pi)*sigma/2
>>> variance(X)
-pi*sigma**2/2 + 2*sigma**2
sympy.stats.StudentT(name, nu)[source]

Create a continuous random variable with a student’s t distribution.

The density of the student’s t distribution is given by

\[f(x) := \frac{\Gamma \left(\frac{\nu+1}{2} \right)} {\sqrt{\nu\pi}\Gamma \left(\frac{\nu}{2} \right)} \left(1+\frac{x^2}{\nu} \right)^{-\frac{\nu+1}{2}}\]
Parameters:nu : Real number, \(\nu > 0\), the degrees of freedom
Returns:A RandomSymbol.

References

[R520]http://en.wikipedia.org/wiki/Student_t-distribution
[R521]http://mathworld.wolfram.com/Studentst-Distribution.html

Examples

>>> from sympy.stats import StudentT, density, E, variance
>>> from sympy import Symbol, simplify, pprint
>>> nu = Symbol("nu", positive=True)
>>> z = Symbol("z")
>>> X = StudentT("x", nu)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
            nu   1
          - -- - -
            2    2
  /     2\
  |    z |
  |1 + --|
  \    nu/
--------------------
  ____     /     nu\
\/ nu *beta|1/2, --|
           \     2 /
sympy.stats.Triangular(name, a, b, c)[source]

Create a continuous random variable with a triangular distribution.

The density of the triangular distribution is given by

\[\begin{split}f(x) := \begin{cases} 0 & \mathrm{for\ } x < a, \\ \frac{2(x-a)}{(b-a)(c-a)} & \mathrm{for\ } a \le x < c, \\ \frac{2}{b-a} & \mathrm{for\ } x = c, \\ \frac{2(b-x)}{(b-a)(b-c)} & \mathrm{for\ } c < x \le b, \\ 0 & \mathrm{for\ } b < x. \end{cases}\end{split}\]
Parameters:

a : Real number, \(a \in \left(-\infty, \infty\right)\)

b : Real number, \(a < b\)

c : Real number, \(a \leq c \leq b\)

Returns:

A RandomSymbol.

References

[R522]http://en.wikipedia.org/wiki/Triangular_distribution
[R523]http://mathworld.wolfram.com/TriangularDistribution.html

Examples

>>> from sympy.stats import Triangular, density, E
>>> from sympy import Symbol, pprint
>>> a = Symbol("a")
>>> b = Symbol("b")
>>> c = Symbol("c")
>>> z = Symbol("z")
>>> X = Triangular("x", a,b,c)
>>> pprint(density(X)(z), use_unicode=False)
/    -2*a + 2*z
|-----------------  for And(a <= z, z < c)
|(-a + b)*(-a + c)
|
|       2
|     ------              for z = c
<     -a + b
|
|   2*b - 2*z
|----------------   for And(z <= b, c < z)
|(-a + b)*(b - c)
|
\        0                otherwise
sympy.stats.Uniform(name, left, right)[source]

Create a continuous random variable with a uniform distribution.

The density of the uniform distribution is given by

\[\begin{split}f(x) := \begin{cases} \frac{1}{b - a} & \text{for } x \in [a,b] \\ 0 & \text{otherwise} \end{cases}\end{split}\]

with \(x \in [a,b]\).

Parameters:

a : Real number, \(-\infty < a\) the left boundary

b : Real number, \(a < b < \infty\) the right boundary

Returns:

A RandomSymbol.

References

[R524]http://en.wikipedia.org/wiki/Uniform_distribution_%28continuous%29
[R525]http://mathworld.wolfram.com/UniformDistribution.html

Examples

>>> from sympy.stats import Uniform, density, cdf, E, variance, skewness
>>> from sympy import Symbol, simplify
>>> a = Symbol("a", negative=True)
>>> b = Symbol("b", positive=True)
>>> z = Symbol("z")
>>> X = Uniform("x", a, b)
>>> density(X)(z)
Piecewise((1/(-a + b), And(a <= z, z <= b)), (0, True))
>>> cdf(X)(z)  
-a/(-a + b) + z/(-a + b)
>>> simplify(E(X))
a/2 + b/2
>>> simplify(variance(X))
a**2/12 - a*b/6 + b**2/12
sympy.stats.UniformSum(name, n)[source]

Create a continuous random variable with an Irwin-Hall distribution.

The probability distribution function depends on a single parameter \(n\) which is an integer.

The density of the Irwin-Hall distribution is given by

\[f(x) := \frac{1}{(n-1)!}\sum_{k=0}^{\lfloor x\rfloor}(-1)^k \binom{n}{k}(x-k)^{n-1}\]
Parameters:n : A positive Integer, \(n > 0\)
Returns:A RandomSymbol.

References

[R526]http://en.wikipedia.org/wiki/Uniform_sum_distribution
[R527]http://mathworld.wolfram.com/UniformSumDistribution.html

Examples

>>> from sympy.stats import UniformSum, density
>>> from sympy import Symbol, pprint
>>> n = Symbol("n", integer=True)
>>> z = Symbol("z")
>>> X = UniformSum("x", n)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
floor(z)
  ___
  \  `
   \         k         n - 1 /n\
    )    (-1) *(-k + z)     *| |
   /                         \k/
  /__,
 k = 0
--------------------------------
            (n - 1)!
sympy.stats.VonMises(name, mu, k)[source]

Create a Continuous Random Variable with a von Mises distribution.

The density of the von Mises distribution is given by

\[f(x) := \frac{e^{\kappa\cos(x-\mu)}}{2\pi I_0(\kappa)}\]

with \(x \in [0,2\pi]\).

Parameters:

mu : Real number, measure of location

k : Real number, measure of concentration

Returns:

A RandomSymbol.

References

[R528]http://en.wikipedia.org/wiki/Von_Mises_distribution
[R529]http://mathworld.wolfram.com/vonMisesDistribution.html

Examples

>>> from sympy.stats import VonMises, density, E, variance
>>> from sympy import Symbol, simplify, pprint
>>> mu = Symbol("mu")
>>> k = Symbol("k", positive=True)
>>> z = Symbol("z")
>>> X = VonMises("x", mu, k)
>>> D = density(X)(z)
>>> pprint(D, use_unicode=False)
     k*cos(mu - z)
    e
------------------
2*pi*besseli(0, k)
sympy.stats.Weibull(name, alpha, beta)[source]

Create a continuous random variable with a Weibull distribution.

The density of the Weibull distribution is given by

\[\begin{split}f(x) := \begin{cases} \frac{k}{\lambda}\left(\frac{x}{\lambda}\right)^{k-1} e^{-(x/\lambda)^{k}} & x\geq0\\ 0 & x<0 \end{cases}\end{split}\]
Parameters:

lambda : Real number, \(\lambda > 0\) a scale

k : Real number, \(k > 0\) a shape

Returns:

A RandomSymbol.

References

[R530]http://en.wikipedia.org/wiki/Weibull_distribution
[R531]http://mathworld.wolfram.com/WeibullDistribution.html

Examples

>>> from sympy.stats import Weibull, density, E, variance
>>> from sympy import Symbol, simplify
>>> l = Symbol("lambda", positive=True)
>>> k = Symbol("k", positive=True)
>>> z = Symbol("z")
>>> X = Weibull("x", l, k)
>>> density(X)(z)
k*(z/lambda)**(k - 1)*exp(-(z/lambda)**k)/lambda
>>> simplify(E(X))
lambda*gamma(1 + 1/k)
>>> simplify(variance(X))
lambda**2*(-gamma(1 + 1/k)**2 + gamma(1 + 2/k))
sympy.stats.WignerSemicircle(name, R)[source]

Create a continuous random variable with a Wigner semicircle distribution.

The density of the Wigner semicircle distribution is given by

\[f(x) := \frac2{\pi R^2}\,\sqrt{R^2-x^2}\]

with \(x \in [-R,R]\).

Parameters:R : Real number, \(R > 0\), the radius
Returns:A \(RandomSymbol\).

References

[R532]http://en.wikipedia.org/wiki/Wigner_semicircle_distribution
[R533]http://mathworld.wolfram.com/WignersSemicircleLaw.html

Examples

>>> from sympy.stats import WignerSemicircle, density, E
>>> from sympy import Symbol, simplify
>>> R = Symbol("R", positive=True)
>>> z = Symbol("z")
>>> X = WignerSemicircle("x", R)
>>> density(X)(z)
2*sqrt(R**2 - z**2)/(pi*R**2)
>>> E(X)
0
sympy.stats.ContinuousRV(symbol, density, set=(-oo, oo))[source]

Create a Continuous Random Variable given the following:

– a symbol – a probability density function – set on which the pdf is valid (defaults to entire real line)

Returns a RandomSymbol.

Many common continuous random variable types are already implemented. This function should be necessary only very rarely.

Examples

>>> from sympy import Symbol, sqrt, exp, pi
>>> from sympy.stats import ContinuousRV, P, E
>>> x = Symbol("x")
>>> pdf = sqrt(2)*exp(-x**2/2)/(2*sqrt(pi)) # Normal distribution
>>> X = ContinuousRV(x, pdf)
>>> E(X)
0
>>> P(X>0)
1/2

Interface

sympy.stats.P(condition, given_condition=None, numsamples=None, evaluate=True, **kwargs)

Probability that a condition is true, optionally given a second condition

Parameters:

condition : Combination of Relationals containing RandomSymbols

The condition of which you want to compute the probability

given_condition : Combination of Relationals containing RandomSymbols

A conditional expression. P(X > 1, X > 0) is expectation of X > 1 given X > 0

numsamples : int

Enables sampling and approximates the probability with this many samples

evaluate : Bool (defaults to True)

In case of continuous systems return unevaluated integral

Examples

>>> from sympy.stats import P, Die
>>> from sympy import Eq
>>> X, Y = Die('X', 6), Die('Y', 6)
>>> P(X > 3)
1/2
>>> P(Eq(X, 5), X > 2) # Probability that X == 5 given that X > 2
1/4
>>> P(X > Y)
5/12
class sympy.stats.Probability[source]

Symbolic expression for the probability.

Examples

>>> from sympy.stats import Probability, Normal
>>> X = Normal("X", 0, 1)
>>> prob = Probability(X > 1)
>>> prob
Probability(X > 1)
>>> prob.doit()
sqrt(2)*(-sqrt(2)*sqrt(pi)*erf(sqrt(2)/2) + sqrt(2)*sqrt(pi))/(4*sqrt(pi))
sympy.stats.E(expr, condition=None, numsamples=None, evaluate=True, **kwargs)

Returns the expected value of a random expression

Parameters:

expr : Expr containing RandomSymbols

The expression of which you want to compute the expectation value

given : Expr containing RandomSymbols

A conditional expression. E(X, X>0) is expectation of X given X > 0

numsamples : int

Enables sampling and approximates the expectation with this many samples

evalf : Bool (defaults to True)

If sampling return a number rather than a complex expression

evaluate : Bool (defaults to True)

In case of continuous systems return unevaluated integral

Examples

>>> from sympy.stats import E, Die
>>> X = Die('X', 6)
>>> E(X)
7/2
>>> E(2*X + 1)
8
>>> E(X, X > 3) # Expectation of X given that it is above 3
5
class sympy.stats.Expectation[source]

Symbolic expression for the expectation.

Examples

>>> from sympy.stats import Expectation, Normal
>>> from sympy import symbols
>>> mu = symbols("mu")
>>> sigma = symbols("sigma", positive=True)
>>> X = Normal("X", mu, sigma)
>>> Expectation(X)
Expectation(X)
>>> Expectation(X).doit().simplify()
mu
>>> Expectation(X).doit(evaluate=False)
Integral(sqrt(2)*X*exp(-(X - mu)**2/(2*sigma**2))/(2*sqrt(pi)*sigma), (X, -oo, oo))

This class is aware of some properties of the expectation:

>>> from sympy.abc import a
>>> Expectation(a*X)
a*Expectation(X)
>>> Y = Normal("Y", 0, 1)
>>> Expectation(X + Y)
Expectation(X) + Expectation(Y)

To prevent this kind of automatic evaluation, use evaluate=False:

>>> Expectation(a*X + Y)
a*Expectation(X) + Expectation(Y)
>>> Expectation(a*X + Y, evaluate=False)
Expectation(a*X + Y)
sympy.stats.density(expr, condition=None, evaluate=True, numsamples=None, **kwargs)[source]

Probability density of a random expression, optionally given a second condition.

This density will take on different forms for different types of probability spaces. Discrete variables produce Dicts. Continuous variables produce Lambdas.

Parameters:

expr : Expr containing RandomSymbols

The expression of which you want to compute the density value

condition : Relational containing RandomSymbols

A conditional expression. density(X > 1, X > 0) is density of X > 1 given X > 0

numsamples : int

Enables sampling and approximates the density with this many samples

Examples

>>> from sympy.stats import density, Die, Normal
>>> from sympy import Symbol
>>> x = Symbol('x')
>>> D = Die('D', 6)
>>> X = Normal(x, 0, 1)
>>> density(D).dict
{1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6}
>>> density(2*D).dict
{2: 1/6, 4: 1/6, 6: 1/6, 8: 1/6, 10: 1/6, 12: 1/6}
>>> density(X)(x)
sqrt(2)*exp(-x**2/2)/(2*sqrt(pi))
sympy.stats.given(expr, condition=None, **kwargs)[source]

Conditional Random Expression From a random expression and a condition on that expression creates a new probability space from the condition and returns the same expression on that conditional probability space.

Examples

>>> from sympy.stats import given, density, Die
>>> X = Die('X', 6)
>>> Y = given(X, X > 3)
>>> density(Y).dict
{4: 1/3, 5: 1/3, 6: 1/3}

Following convention, if the condition is a random symbol then that symbol is considered fixed.

>>> from sympy.stats import Normal
>>> from sympy import pprint
>>> from sympy.abc import z
>>> X = Normal('X', 0, 1)
>>> Y = Normal('Y', 0, 1)
>>> pprint(density(X + Y, Y)(z), use_unicode=False)
                2
       -(-Y + z)
       -----------
  ___       2
\/ 2 *e
------------------
         ____
     2*\/ pi
sympy.stats.where(condition, given_condition=None, **kwargs)[source]

Returns the domain where a condition is True.

Examples

>>> from sympy.stats import where, Die, Normal
>>> from sympy import symbols, And
>>> D1, D2 = Die('a', 6), Die('b', 6)
>>> a, b = D1.symbol, D2.symbol
>>> X = Normal('x', 0, 1)
>>> where(X**2<1)
Domain: And(-1 < x, x < 1)
>>> where(X**2<1).set
(-1, 1)
>>> where(And(D1<=D2 , D2<3))
Domain: Or(And(Eq(a, 1), Eq(b, 1)), And(Eq(a, 1), Eq(b, 2)), And(Eq(a, 2), Eq(b, 2)))    
sympy.stats.variance(X, condition=None, **kwargs)[source]

Variance of a random expression

Expectation of (X-E(X))**2

Examples

>>> from sympy.stats import Die, E, Bernoulli, variance
>>> from sympy import simplify, Symbol
>>> X = Die('X', 6)
>>> p = Symbol('p')
>>> B = Bernoulli('B', p, 1, 0)
>>> variance(2*X)
35/3
>>> simplify(variance(B))
p*(-p + 1)
class sympy.stats.Variance[source]

Symbolic expression for the variance.

Examples

>>> from sympy import symbols
>>> from sympy.stats import Normal, Expectation, Variance
>>> mu = symbols("mu", positive=True)
>>> sigma = symbols("sigma", positive=True)
>>> X = Normal("X", mu, sigma)
>>> Variance(X)
Variance(X)
>>> Variance(X).doit()
sigma**2

Rewrite the variance in terms of the expectation

>>> Variance(X).rewrite(Expectation)
-Expectation(X)**2 + Expectation(X**2)

Some transformations based on the properties of the variance may happen:

>>> from sympy.abc import a
>>> Y = Normal("Y", 0, 1)
>>> Variance(a*X)
a**2*Variance(X)

To prevent automatic evaluation, use evaluate=False:

>>> Variance(X + Y)
2*Covariance(X, Y) + Variance(X) + Variance(Y)
>>> Variance(X + Y, evaluate=False)
Variance(X + Y)
sympy.stats.covariance(X, Y, condition=None, **kwargs)[source]

Covariance of two random expressions

The expectation that the two variables will rise and fall together

Covariance(X,Y) = E( (X-E(X)) * (Y-E(Y)) )

Examples

>>> from sympy.stats import Exponential, covariance
>>> from sympy import Symbol
>>> rate = Symbol('lambda', positive=True, real=True, finite=True)
>>> X = Exponential('X', rate)
>>> Y = Exponential('Y', rate)
>>> covariance(X, X)
lambda**(-2)
>>> covariance(X, Y)
0
>>> covariance(X, Y + rate*X)
1/lambda
class sympy.stats.Covariance[source]

Symbolic expression for the covariance.

Examples

>>> from sympy.stats import Covariance
>>> from sympy.stats import Normal
>>> X = Normal("X", 3, 2)
>>> Y = Normal("Y", 0, 1)
>>> Z = Normal("Z", 0, 1)
>>> W = Normal("W", 0, 1)
>>> cexpr = Covariance(X, Y)
>>> cexpr
Covariance(X, Y)

Evaluate the covariance, \(X\) and \(Y\) are independent, therefore zero is the result:

>>> cexpr.doit()
0

Rewrite the covariance expression in terms of expectations:

>>> from sympy.stats import Expectation
>>> cexpr.rewrite(Expectation)
Expectation(X*Y) - Expectation(X)*Expectation(Y)

This class is aware of some properties of the covariance:

>>> Covariance(X, X)
Variance(X)
>>> from sympy.abc import a, b, c, d
>>> Covariance(a*X, b*Y)
a*b*Covariance(X, Y)

In order to prevent such transformations, use evaluate=False:

>>> Covariance(a*X + b*Y, c*Z + d*W)
a*c*Covariance(X, Z) + a*d*Covariance(W, X) + b*c*Covariance(Y, Z) + b*d*Covariance(W, Y)
>>> Covariance(a*X + b*Y, c*Z + d*W, evaluate=False)
Covariance(a*X + b*Y, c*Z + d*W)
sympy.stats.std(X, condition=None, **kwargs)

Standard Deviation of a random expression

Square root of the Expectation of (X-E(X))**2

Examples

>>> from sympy.stats import Bernoulli, std
>>> from sympy import Symbol, simplify
>>> p = Symbol('p')
>>> B = Bernoulli('B', p, 1, 0)
>>> simplify(std(B))
sqrt(p*(-p + 1))
sympy.stats.sample(expr, condition=None, **kwargs)[source]

A realization of the random expression

Examples

>>> from sympy.stats import Die, sample
>>> X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6)
>>> die_roll = sample(X + Y + Z) # A random realization of three dice
sympy.stats.sample_iter(expr, condition=None, numsamples=oo, **kwargs)[source]

Returns an iterator of realizations from the expression given a condition

expr: Random expression to be realized condition: A conditional expression (optional) numsamples: Length of the iterator (defaults to infinity)

See also

Sample, sampling_P, sampling_E, sample_iter_lambdify, sample_iter_subs

Examples

>>> from sympy.stats import Normal, sample_iter
>>> X = Normal('X', 0, 1)
>>> expr = X*X + 3
>>> iterator = sample_iter(expr, numsamples=3)
>>> list(iterator) 
[12, 4, 7]

Mechanics

SymPy Stats employs a relatively complex class hierarchy.

RandomDomains are a mapping of variables to possible values. For example we might say that the symbol Symbol('x') can take on the values \(\{1,2,3,4,5,6\}\).

class sympy.stats.rv.RandomDomain[source]

A PSpace, or Probability Space, combines a RandomDomain with a density to provide probabilistic information. For example the above domain could be enhanced by a finite density {1:1/6, 2:1/6, 3:1/6, 4:1/6, 5:1/6, 6:1/6} to fully define the roll of a fair die named x.

class sympy.stats.rv.PSpace[source]

A RandomSymbol represents the PSpace’s symbol ‘x’ inside of SymPy expressions.

class sympy.stats.rv.RandomSymbol[source]

The RandomDomain and PSpace classes are almost never directly instantiated. Instead they are subclassed for a variety of situations.

RandomDomains and PSpaces must be sufficiently general to represent domains and spaces of several variables with arbitrarily complex densities. This generality is often unnecessary. Instead we often build SingleDomains and SinglePSpaces to represent single, univariate events and processes such as a single die or a single normal variable.

class sympy.stats.rv.SinglePSpace[source]
class sympy.stats.rv.SingleDomain[source]

Another common case is to collect together a set of such univariate random variables. A collection of independent SinglePSpaces or SingleDomains can be brought together to form a ProductDomain or ProductPSpace. These objects would be useful in representing three dice rolled together for example.

class sympy.stats.rv.ProductDomain[source]
class sympy.stats.rv.ProductPSpace[source]

The Conditional adjective is added whenever we add a global condition to a RandomDomain or PSpace. A common example would be three independent dice where we know their sum to be greater than 12.

class sympy.stats.rv.ConditionalDomain[source]

We specialize further into Finite and Continuous versions of these classes to represent finite (such as dice) and continuous (such as normals) random variables.

class sympy.stats.frv.FiniteDomain[source]
class sympy.stats.frv.FinitePSpace[source]
class sympy.stats.crv.ContinuousDomain[source]
class sympy.stats.crv.ContinuousPSpace[source]

Additionally there are a few specialized classes that implement certain common random variable types. There is for example a DiePSpace that implements SingleFinitePSpace and a NormalPSpace that implements SingleContinuousPSpace.

class sympy.stats.frv_types.DiePSpace
class sympy.stats.crv_types.NormalPSpace

RandomVariables can be extracted from these objects using the PSpace.values method.

As previously mentioned SymPy Stats employs a relatively complex class structure. Inheritance is widely used in the implementation of end-level classes. This tactic was chosen to balance between the need to allow SymPy to represent arbitrarily defined random variables and optimizing for common cases. This complicates the code but is structured to only be important to those working on extending SymPy Stats to other random variable types.

Users will not use this class structure. Instead these mechanics are exposed through variable creation functions Die, Coin, FiniteRV, Normal, Exponential, etc.... These build the appropriate SinglePSpaces and return the corresponding RandomVariable. Conditional and Product spaces are formed in the natural construction of SymPy expressions and the use of interface functions E, Given, Density, etc....

sympy.stats.Die()
sympy.stats.Normal()

There are some additional functions that may be useful. They are largely used internally.

sympy.stats.rv.random_symbols(expr)[source]

Returns all RandomSymbols within a SymPy Expression.

sympy.stats.rv.pspace(expr)[source]

Returns the underlying Probability Space of a random expression.

For internal use.

Examples

>>> from sympy.stats import pspace, Normal
>>> from sympy.stats.rv import ProductPSpace
>>> X = Normal('X', 0, 1)
>>> pspace(2*X + 1) == X.pspace
True
sympy.stats.rv.rs_swap(a, b)[source]

Build a dictionary to swap RandomSymbols based on their underlying symbol.

i.e. if X = ('x', pspace1) and Y = ('x', pspace2) then X and Y match and the key, value pair {X:Y} will appear in the result

Inputs: collections a and b of random variables which share common symbols Output: dict mapping RVs in a to RVs in b