def test_conditional_1d():
X = Normal(0,1)
Y = Given(X, X>=0)
assert Density(Y) == 2 * Density(X)
assert Y.pspace.domain.set == Interval(0, oo)
assert E(Y) == sqrt(2) / sqrt(pi)
assert E(X**2) == E(Y**2)
def test_bernoulli():
p, a, b = symbols('p a b')
X = Bernoulli(p, a, b, symbol='B')
assert E(X) == a * p + b * (-p + 1)
assert Density(X)[a] == p
assert Density(X)[b] == 1 - p
X = Bernoulli(p, 1, 0, symbol='B')
assert E(X) == p
assert Var(X) == -p**2 + p
E(a * X + b) == a * E(X) + b
Var(a * X + b) == a**2 * Var(X)
def test_FiniteRV():
F = FiniteRV({1: S.Half, 2: S.One / 4, 3: S.One / 4})
assert Density(F) == {S(1): S.Half, S(2): S.One / 4, S(3): S.One / 4}
assert P(F >= 2) == S.Half
assert pspace(F).domain.as_boolean() == Or(
*[Eq(F.symbol, i) for i in [1, 2, 3]])
def test_pareto():
xm, beta = symbols('xm beta', positive=True, bounded=True)
alpha = beta + 5
X = Pareto(xm, alpha)
density = Density(X)
x = Symbol('x')
assert density(x) == x**(-(alpha+1))*xm**(alpha)*(alpha)
def test_coins():
C, D = Coin(), Coin()
H, T = sorted(Density(C).keys())
assert P(Eq(C, D)) == S.Half
assert Density(Tuple(C, D)) == {
(H, H): S.One / 4,
(H, T): S.One / 4,
(T, H): S.One / 4,
(T, T): S.One / 4
}
assert Density(C) == {H: S.Half, T: S.Half}
E = Coin(S.One / 10)
assert P(Eq(E, H)) == S(1) / 10
d = pspace(C).domain
assert d.as_boolean() == Or(Eq(C.symbol, H), Eq(C.symbol, T))
raises(ValueError, "P(C>D)") # Can't intelligently compare H to T
def test_discreteuniform():
# Symbolic
a, b, c = symbols('a b c')
X = DiscreteUniform([a, b, c])
assert E(X) == (a + b + c) / 3
assert Var(X) == (a**2 + b**2 + c**2) / 3 - (a / 3 + b / 3 + c / 3)**2
assert P(Eq(X, a)) == P(Eq(X, b)) == P(Eq(X, c)) == S('1/3')
Y = DiscreteUniform(range(-5, 5))
# Numeric
assert E(Y) == S('-1/2')
assert Var(Y) == S('33/4')
assert Skewness(Y) == 0
for x in range(-5, 5):
assert P(Eq(Y, x)) == S('1/10')
assert P(Y <= x) == S(x + 6) / 10
assert P(Y >= x) == S(5 - x) / 10
assert Density(Die(6)) == Density(DiscreteUniform(range(1, 7)))
def test_dice():
X, Y, Z = Die(6), Die(6), Die(6)
a, b = symbols('a b')
assert E(X) == 3 + S.Half
assert Var(X) == S(35) / 12
assert E(X + Y) == 7
assert E(X + X) == 7
assert E(a * X + b) == a * E(X) + b
assert Var(X + Y) == Var(X) + Var(Y)
assert Var(X + X) == 4 * Var(X)
assert Covar(X, Y) == S.Zero
assert Covar(X, X + Y) == Var(X)
assert Density(Eq(cos(X * S.Pi), 1))[True] == S.Half
assert P(X > 3) == S.Half
assert P(2 * X > 6) == S.Half
assert P(X > Y) == S(5) / 12
assert P(Eq(X, Y)) == P(Eq(X, 1))
assert E(X, X > 3) == 5
assert E(X, Y > 3) == E(X)
assert E(X + Y, Eq(X, Y)) == E(2 * X)
assert E(X + Y - Z, 2 * X > Y + 1) == S(49) / 12
assert P(X > 3, X > 3) == S.One
assert P(X > Y, Eq(Y, 6)) == S.Zero
assert P(Eq(X + Y, 12)) == S.One / 36
assert P(Eq(X + Y, 12), Eq(X, 6)) == S.One / 6
assert Density(X + Y) == Density(Y + Z) != Density(X + X)
d = Density(2 * X + Y**Z)
assert d[S(22)] == S.One / 108 and d[S(4100)] == S.One / 216 and S(
3130) not in d
assert pspace(X).domain.as_boolean() == Or(
*[Eq(X.symbol, i) for i in [1, 2, 3, 4, 5, 6]])
assert Where(X > 3).set == FiniteSet(4, 5, 6)
def test_single_normal():
mu = Symbol('mu', real=True, bounded=True)
sigma = Symbol('sigma', real=True, positive=True, bounded=True)
X = Normal(0,1)
Y = X*sigma + mu
assert simplify(E(Y)) == mu
assert simplify(Var(Y)) == sigma**2
pdf = Density(Y)
x = Symbol('x')
assert pdf(x) == 2**S.Half*exp(-(x - mu)**2/(2*sigma**2))/(2*pi**S.Half*sigma)
assert P(X**2 < 1) == erf(2**S.Half/2)
assert E(X, Eq(X, mu)) == mu
def test_hypergeometric_numeric():
for N in range(1, 5):
for m in range(0, N + 1):
for n in range(1, N + 1):
X = Hypergeometric(N, m, n)
N, m, n = map(sympify, (N, m, n))
assert sum(Density(X).values()) == 1
assert E(X) == n * m / N
if N > 1:
assert Var(X) == n * (m / N) * (N - m) / N * (N - n) / (N -
1)
# Only test for skewness when defined
if N > 2 and 0 < m < N and n < N:
assert Eq(
Skewness(X),
simplify((N - 2 * m) * sqrt(N - 1) * (N - 2 * n) /
(sqrt(n * m * (N - m) * (N - n)) * (N - 2))))
def test_beta():
a, b = symbols('alpha beta', positive=True)
B = Beta(a, b)
assert pspace(B).domain.set == Interval(0, 1)
dens = Density(B)
x = Symbol('x')
assert dens(x) == x**(a-1)*(1-x)**(b-1) / beta(a,b)
# This is too slow
# assert E(B) == a / (a + b)
# assert Var(B) == (a*b) / ((a+b)**2 * (a+b+1))
# Full symbolic solution is too much, test with numeric version
a, b = 1, 2
B = Beta(a, b)
assert E(B) == a / S(a + b)
assert Var(B) == (a*b) / S((a+b)**2 * (a+b+1))
def test_normality():
X, Y = Normal(0, 1), Normal(0, 1)
x, z = symbols('x, z', real=True)
density = Density(X - Y, Eq(X + Y, z))
assert integrate(density(x), (x, -oo, oo)) == 1
def test_given():
X = Die(6)
Density(X, X > 5) == {S(6): S(1)}
Where(X > 2, X > 5).as_boolean() == Eq(X.symbol, 6)
Sample(X, X > 5) == 6