|
|
from sympy.concrete.summations import (Sum, summation) |
|
|
from sympy.core.basic import Basic |
|
|
from sympy.core.cache import cacheit |
|
|
from sympy.core.function import Lambda |
|
|
from sympy.core.numbers import I |
|
|
from sympy.core.relational import (Eq, Ne) |
|
|
from sympy.core.singleton import S |
|
|
from sympy.core.symbol import (Dummy, symbols) |
|
|
from sympy.core.sympify import sympify |
|
|
from sympy.functions.combinatorial.factorials import factorial |
|
|
from sympy.functions.elementary.exponential import exp |
|
|
from sympy.functions.elementary.integers import floor |
|
|
from sympy.functions.elementary.piecewise import Piecewise |
|
|
from sympy.logic.boolalg import And |
|
|
from sympy.polys.polytools import poly |
|
|
from sympy.series.series import series |
|
|
|
|
|
from sympy.polys.polyerrors import PolynomialError |
|
|
from sympy.stats.crv import reduce_rational_inequalities_wrap |
|
|
from sympy.stats.rv import (NamedArgsMixin, SinglePSpace, SingleDomain, |
|
|
random_symbols, PSpace, ConditionalDomain, RandomDomain, |
|
|
ProductDomain, Distribution) |
|
|
from sympy.stats.symbolic_probability import Probability |
|
|
from sympy.sets.fancysets import Range, FiniteSet |
|
|
from sympy.sets.sets import Union |
|
|
from sympy.sets.contains import Contains |
|
|
from sympy.utilities import filldedent |
|
|
from sympy.core.sympify import _sympify |
|
|
|
|
|
|
|
|
class DiscreteDistribution(Distribution): |
|
|
def __call__(self, *args): |
|
|
return self.pdf(*args) |
|
|
|
|
|
|
|
|
class SingleDiscreteDistribution(DiscreteDistribution, NamedArgsMixin): |
|
|
""" Discrete distribution of a single variable. |
|
|
|
|
|
Serves as superclass for PoissonDistribution etc.... |
|
|
|
|
|
Provides methods for pdf, cdf, and sampling |
|
|
|
|
|
See Also: |
|
|
sympy.stats.crv_types.* |
|
|
""" |
|
|
|
|
|
set = S.Integers |
|
|
|
|
|
def __new__(cls, *args): |
|
|
args = list(map(sympify, args)) |
|
|
return Basic.__new__(cls, *args) |
|
|
|
|
|
@staticmethod |
|
|
def check(*args): |
|
|
pass |
|
|
|
|
|
@cacheit |
|
|
def compute_cdf(self, **kwargs): |
|
|
""" Compute the CDF from the PDF. |
|
|
|
|
|
Returns a Lambda. |
|
|
""" |
|
|
x = symbols('x', integer=True, cls=Dummy) |
|
|
z = symbols('z', real=True, cls=Dummy) |
|
|
left_bound = self.set.inf |
|
|
|
|
|
|
|
|
pdf = self.pdf(x) |
|
|
cdf = summation(pdf, (x, left_bound, floor(z)), **kwargs) |
|
|
|
|
|
cdf = Piecewise((cdf, z >= left_bound), (0, True)) |
|
|
return Lambda(z, cdf) |
|
|
|
|
|
def _cdf(self, x): |
|
|
return None |
|
|
|
|
|
def cdf(self, x, **kwargs): |
|
|
""" Cumulative density function """ |
|
|
if not kwargs: |
|
|
cdf = self._cdf(x) |
|
|
if cdf is not None: |
|
|
return cdf |
|
|
return self.compute_cdf(**kwargs)(x) |
|
|
|
|
|
@cacheit |
|
|
def compute_characteristic_function(self, **kwargs): |
|
|
""" Compute the characteristic function from the PDF. |
|
|
|
|
|
Returns a Lambda. |
|
|
""" |
|
|
x, t = symbols('x, t', real=True, cls=Dummy) |
|
|
pdf = self.pdf(x) |
|
|
cf = summation(exp(I*t*x)*pdf, (x, self.set.inf, self.set.sup)) |
|
|
return Lambda(t, cf) |
|
|
|
|
|
def _characteristic_function(self, t): |
|
|
return None |
|
|
|
|
|
def characteristic_function(self, t, **kwargs): |
|
|
""" Characteristic function """ |
|
|
if not kwargs: |
|
|
cf = self._characteristic_function(t) |
|
|
if cf is not None: |
|
|
return cf |
|
|
return self.compute_characteristic_function(**kwargs)(t) |
|
|
|
|
|
@cacheit |
|
|
def compute_moment_generating_function(self, **kwargs): |
|
|
t = Dummy('t', real=True) |
|
|
x = Dummy('x', integer=True) |
|
|
pdf = self.pdf(x) |
|
|
mgf = summation(exp(t*x)*pdf, (x, self.set.inf, self.set.sup)) |
|
|
return Lambda(t, mgf) |
|
|
|
|
|
def _moment_generating_function(self, t): |
|
|
return None |
|
|
|
|
|
def moment_generating_function(self, t, **kwargs): |
|
|
if not kwargs: |
|
|
mgf = self._moment_generating_function(t) |
|
|
if mgf is not None: |
|
|
return mgf |
|
|
return self.compute_moment_generating_function(**kwargs)(t) |
|
|
|
|
|
@cacheit |
|
|
def compute_quantile(self, **kwargs): |
|
|
""" Compute the Quantile from the PDF. |
|
|
|
|
|
Returns a Lambda. |
|
|
""" |
|
|
x = Dummy('x', integer=True) |
|
|
p = Dummy('p', real=True) |
|
|
left_bound = self.set.inf |
|
|
pdf = self.pdf(x) |
|
|
cdf = summation(pdf, (x, left_bound, x), **kwargs) |
|
|
set = ((x, p <= cdf), ) |
|
|
return Lambda(p, Piecewise(*set)) |
|
|
|
|
|
def _quantile(self, x): |
|
|
return None |
|
|
|
|
|
def quantile(self, x, **kwargs): |
|
|
""" Cumulative density function """ |
|
|
if not kwargs: |
|
|
quantile = self._quantile(x) |
|
|
if quantile is not None: |
|
|
return quantile |
|
|
return self.compute_quantile(**kwargs)(x) |
|
|
|
|
|
def expectation(self, expr, var, evaluate=True, **kwargs): |
|
|
""" Expectation of expression over distribution """ |
|
|
|
|
|
|
|
|
if evaluate: |
|
|
try: |
|
|
p = poly(expr, var) |
|
|
|
|
|
t = Dummy('t', real=True) |
|
|
|
|
|
mgf = self.moment_generating_function(t) |
|
|
deg = p.degree() |
|
|
taylor = poly(series(mgf, t, 0, deg + 1).removeO(), t) |
|
|
result = 0 |
|
|
for k in range(deg+1): |
|
|
result += p.coeff_monomial(var ** k) * taylor.coeff_monomial(t ** k) * factorial(k) |
|
|
|
|
|
return result |
|
|
|
|
|
except PolynomialError: |
|
|
return summation(expr * self.pdf(var), |
|
|
(var, self.set.inf, self.set.sup), **kwargs) |
|
|
|
|
|
else: |
|
|
return Sum(expr * self.pdf(var), |
|
|
(var, self.set.inf, self.set.sup), **kwargs) |
|
|
|
|
|
def __call__(self, *args): |
|
|
return self.pdf(*args) |
|
|
|
|
|
|
|
|
class DiscreteDomain(RandomDomain): |
|
|
""" |
|
|
A domain with discrete support with step size one. |
|
|
Represented using symbols and Range. |
|
|
""" |
|
|
is_Discrete = True |
|
|
|
|
|
class SingleDiscreteDomain(DiscreteDomain, SingleDomain): |
|
|
def as_boolean(self): |
|
|
return Contains(self.symbol, self.set) |
|
|
|
|
|
|
|
|
class ConditionalDiscreteDomain(DiscreteDomain, ConditionalDomain): |
|
|
""" |
|
|
Domain with discrete support of step size one, that is restricted by |
|
|
some condition. |
|
|
""" |
|
|
@property |
|
|
def set(self): |
|
|
rv = self.symbols |
|
|
if len(self.symbols) > 1: |
|
|
raise NotImplementedError(filldedent(''' |
|
|
Multivariate conditional domains are not yet implemented.''')) |
|
|
rv = list(rv)[0] |
|
|
return reduce_rational_inequalities_wrap(self.condition, |
|
|
rv).intersect(self.fulldomain.set) |
|
|
|
|
|
|
|
|
class DiscretePSpace(PSpace): |
|
|
is_real = True |
|
|
is_Discrete = True |
|
|
|
|
|
@property |
|
|
def pdf(self): |
|
|
return self.density(*self.symbols) |
|
|
|
|
|
def where(self, condition): |
|
|
rvs = random_symbols(condition) |
|
|
assert all(r.symbol in self.symbols for r in rvs) |
|
|
if len(rvs) > 1: |
|
|
raise NotImplementedError(filldedent('''Multivariate discrete |
|
|
random variables are not yet supported.''')) |
|
|
conditional_domain = reduce_rational_inequalities_wrap(condition, |
|
|
rvs[0]) |
|
|
conditional_domain = conditional_domain.intersect(self.domain.set) |
|
|
return SingleDiscreteDomain(rvs[0].symbol, conditional_domain) |
|
|
|
|
|
def probability(self, condition): |
|
|
complement = isinstance(condition, Ne) |
|
|
if complement: |
|
|
condition = Eq(condition.args[0], condition.args[1]) |
|
|
try: |
|
|
_domain = self.where(condition).set |
|
|
if condition == False or _domain is S.EmptySet: |
|
|
return S.Zero |
|
|
if condition == True or _domain == self.domain.set: |
|
|
return S.One |
|
|
prob = self.eval_prob(_domain) |
|
|
except NotImplementedError: |
|
|
from sympy.stats.rv import density |
|
|
expr = condition.lhs - condition.rhs |
|
|
dens = density(expr) |
|
|
if not isinstance(dens, DiscreteDistribution): |
|
|
from sympy.stats.drv_types import DiscreteDistributionHandmade |
|
|
dens = DiscreteDistributionHandmade(dens) |
|
|
z = Dummy('z', real=True) |
|
|
space = SingleDiscretePSpace(z, dens) |
|
|
prob = space.probability(condition.__class__(space.value, 0)) |
|
|
if prob is None: |
|
|
prob = Probability(condition) |
|
|
return prob if not complement else S.One - prob |
|
|
|
|
|
def eval_prob(self, _domain): |
|
|
sym = list(self.symbols)[0] |
|
|
if isinstance(_domain, Range): |
|
|
n = symbols('n', integer=True) |
|
|
inf, sup, step = (r for r in _domain.args) |
|
|
summand = ((self.pdf).replace( |
|
|
sym, n*step)) |
|
|
rv = summation(summand, |
|
|
(n, inf/step, (sup)/step - 1)).doit() |
|
|
return rv |
|
|
elif isinstance(_domain, FiniteSet): |
|
|
pdf = Lambda(sym, self.pdf) |
|
|
rv = sum(pdf(x) for x in _domain) |
|
|
return rv |
|
|
elif isinstance(_domain, Union): |
|
|
rv = sum(self.eval_prob(x) for x in _domain.args) |
|
|
return rv |
|
|
|
|
|
def conditional_space(self, condition): |
|
|
|
|
|
|
|
|
density = Lambda(tuple(self.symbols), self.pdf/self.probability(condition)) |
|
|
condition = condition.xreplace({rv: rv.symbol for rv in self.values}) |
|
|
domain = ConditionalDiscreteDomain(self.domain, condition) |
|
|
return DiscretePSpace(domain, density) |
|
|
|
|
|
class ProductDiscreteDomain(ProductDomain, DiscreteDomain): |
|
|
def as_boolean(self): |
|
|
return And(*[domain.as_boolean for domain in self.domains]) |
|
|
|
|
|
class SingleDiscretePSpace(DiscretePSpace, SinglePSpace): |
|
|
""" Discrete probability space over a single univariate variable """ |
|
|
is_real = True |
|
|
|
|
|
@property |
|
|
def set(self): |
|
|
return self.distribution.set |
|
|
|
|
|
@property |
|
|
def domain(self): |
|
|
return SingleDiscreteDomain(self.symbol, self.set) |
|
|
|
|
|
def sample(self, size=(), library='scipy', seed=None): |
|
|
""" |
|
|
Internal sample method. |
|
|
|
|
|
Returns dictionary mapping RandomSymbol to realization value. |
|
|
""" |
|
|
return {self.value: self.distribution.sample(size, library=library, seed=seed)} |
|
|
|
|
|
def compute_expectation(self, expr, rvs=None, evaluate=True, **kwargs): |
|
|
rvs = rvs or (self.value,) |
|
|
if self.value not in rvs: |
|
|
return expr |
|
|
|
|
|
expr = _sympify(expr) |
|
|
expr = expr.xreplace({rv: rv.symbol for rv in rvs}) |
|
|
|
|
|
x = self.value.symbol |
|
|
try: |
|
|
return self.distribution.expectation(expr, x, evaluate=evaluate, |
|
|
**kwargs) |
|
|
except NotImplementedError: |
|
|
return Sum(expr * self.pdf, (x, self.set.inf, self.set.sup), |
|
|
**kwargs) |
|
|
|
|
|
def compute_cdf(self, expr, **kwargs): |
|
|
if expr == self.value: |
|
|
x = Dummy("x", real=True) |
|
|
return Lambda(x, self.distribution.cdf(x, **kwargs)) |
|
|
else: |
|
|
raise NotImplementedError() |
|
|
|
|
|
def compute_density(self, expr, **kwargs): |
|
|
if expr == self.value: |
|
|
return self.distribution |
|
|
raise NotImplementedError() |
|
|
|
|
|
def compute_characteristic_function(self, expr, **kwargs): |
|
|
if expr == self.value: |
|
|
t = Dummy("t", real=True) |
|
|
return Lambda(t, self.distribution.characteristic_function(t, **kwargs)) |
|
|
else: |
|
|
raise NotImplementedError() |
|
|
|
|
|
def compute_moment_generating_function(self, expr, **kwargs): |
|
|
if expr == self.value: |
|
|
t = Dummy("t", real=True) |
|
|
return Lambda(t, self.distribution.moment_generating_function(t, **kwargs)) |
|
|
else: |
|
|
raise NotImplementedError() |
|
|
|
|
|
def compute_quantile(self, expr, **kwargs): |
|
|
if expr == self.value: |
|
|
p = Dummy("p", real=True) |
|
|
return Lambda(p, self.distribution.quantile(p, **kwargs)) |
|
|
else: |
|
|
raise NotImplementedError() |
|
|
|
