def test_gompertz():
b = Symbol("b", positive=True)
eta = Symbol("eta", positive=True)
X = Gompertz("x", b, eta)
assert density(X)(x) == b*eta*exp(eta)*exp(b*x)*exp(-eta*exp(b*x))
assert cdf(X)(x) == 1 - exp(eta)*exp(-eta*exp(b*x))
assert diff(cdf(X)(x), x) == density(X)(x)
def test_chi_squared():
k = Symbol("k", integer=True)
X = ChiSquared('x', k)
assert density(X)(x) == 2**(-k/2)*x**(k/2 - 1)*exp(-x/2)/gamma(k/2)
assert cdf(X)(x) == Piecewise((lowergamma(k/2, x/2)/gamma(k/2), x >= 0), (0, True))
X = ChiSquared('x', 15)
assert cdf(X)(3) == -14873*sqrt(6)*exp(-S(3)/2)/(5005*sqrt(pi)) + erf(sqrt(6)/2)
def test_rayleigh():
sigma = Symbol("sigma", positive=True)
X = Rayleigh('x', sigma)
assert density(X)(x) == x*exp(-x**2/(2*sigma**2))/sigma**2
assert E(X) == sqrt(2)*sqrt(pi)*sigma/2
assert variance(X) == -pi*sigma**2/2 + 2*sigma**2
assert cdf(X)(x) == 1 - exp(-x**2/(2*sigma**2))
assert diff(cdf(X)(x), x) == density(X)(x)
def test_maxwell():
a = Symbol("a", positive=True)
X = Maxwell('x', a)
assert density(X)(x) == (sqrt(2)*x**2*exp(-x**2/(2*a**2))/
(sqrt(pi)*a**3))
assert E(X) == 2*sqrt(2)*a/sqrt(pi)
assert simplify(variance(X)) == a**2*(-8 + 3*pi)/pi
assert cdf(X)(x) == erf(sqrt(2)*x/(2*a)) - sqrt(2)*x*exp(-x**2/(2*a**2))/(sqrt(pi)*a)
assert diff(cdf(X)(x), x) == density(X)(x)
def test_cauchy():
x0 = Symbol("x0")
gamma = Symbol("gamma", positive=True)
X = Cauchy('x', x0, gamma)
assert density(X)(x) == 1/(pi*gamma*(1 + (x - x0)**2/gamma**2))
assert cdf(X)(x) == atan((x - x0)/gamma)/pi + S.Half
assert diff(cdf(X)(x), x) == density(X)(x)
gamma = Symbol("gamma", positive=False)
raises(ValueError, lambda: Cauchy('x', x0, gamma))
def symSq():
rho = r / sigma - 0.5 * sigma
N = stats.Normal('N', 0, 1)
theta2t = 1/(2*T)*theta2/sqrt(1+theta2**2)
# theta2t = 1/(2*T)*(exp(theta2)-1)/(exp(theta2)+1)
a = (1/(2*T)+theta2t) * 4*sqrt(T)/sigma*log(B/s0) - theta1
Kprime = K * exp(-r*T)
g1 = stats.cdf(N)(a - log(Kprime/s0)/sigma/sqrt(T) + 3/2*sigma*sqrt(T))
g2 = stats.cdf(N)(a - log(Kprime/s0)/sigma/sqrt(T) + 0.5*sigma*sqrt(T))
g3 = stats.cdf(N)(a - log(Kprime/s0)/sigma/sqrt(T) - 0.5*sigma*sqrt(T))
pre = exp((1/(2*T)+theta2t)*(4*T*rho/sigma*log(B/s0) - 4/sigma**2*log(B/s0)**2))
T1 = s0**2*g1*exp(0.5*(a+2*sigma*sqrt(T))**2 - sigma**2*T)
T2 = s0*Kprime*g2*exp(0.5*(a+sigma*sqrt(T))**2 - 0.5*sigma**2*T)
T3 = Kprime**2*g3*exp(0.5*a**2)
res = pre * (T1 - 2*T2 + T3) * exp(0.5*theta1**2) / (1-4*T**2*theta2t**2)
return res
def test_gumbel():
beta = Symbol("beta", positive=True)
mu = Symbol("mu")
x = Symbol("x")
X = Gumbel("x", beta, mu)
assert str(density(X)(x)) == 'exp(-exp(-(-mu + x)/beta) - (-mu + x)/beta)/beta'
assert cdf(X)(x) == exp(-exp((mu - x)/beta))
def test_studentt():
nu = Symbol("nu", positive=True)
X = StudentT('x', nu)
assert density(X)(x) == (1 + x**2/nu)**(-nu/2 - S(1)/2)/(sqrt(nu)*beta(S(1)/2, nu/2))
assert cdf(X)(x) == S(1)/2 + x*gamma(nu/2 + S(1)/2)*hyper((S(1)/2, nu/2 + S(1)/2),
(S(3)/2,), -x**2/nu)/(sqrt(pi)*sqrt(nu)*gamma(nu/2))
def test_gamma_inverse():
a = Symbol("a", positive=True)
b = Symbol("b", positive=True)
X = GammaInverse("x", a, b)
assert density(X)(x) == x**(-a - 1)*b**a*exp(-b/x)/gamma(a)
assert cdf(X)(x) == Piecewise((uppergamma(a, b/x)/gamma(a), x > 0), (0, True))
def test_logistic():
mu = Symbol("mu", real=True)
s = Symbol("s", positive=True)
X = Logistic('x', mu, s)
assert density(X)(x) == exp((-x + mu)/s)/(s*(exp((-x + mu)/s) + 1)**2)
assert cdf(X)(x) == 1/(exp((mu - x)/s) + 1)
def test_erlang():
k = Symbol("k", integer=True, positive=True)
l = Symbol("l", positive=True)
X = Erlang("x", k, l)
assert density(X)(x) == x**(k - 1)*l**k*exp(-x*l)/gamma(k)
assert cdf(X)(x) == Piecewise((lowergamma(k, l*x)/gamma(k), x > 0),
(0, True))
def test_laplace():
mu = Symbol("mu")
b = Symbol("b", positive=True)
X = Laplace('x', mu, b)
assert density(X)(x) == exp(-Abs(x - mu)/b)/(2*b)
assert cdf(X)(x) == Piecewise((exp((-mu + x)/b)/2, mu > x),
(-exp((mu - x)/b)/2 + 1, True))
def test_frechet():
a = Symbol("a", positive=True)
s = Symbol("s", positive=True)
m = Symbol("m", real=True)
X = Frechet("x", a, s=s, m=m)
assert density(X)(x) == a*((x - m)/s)**(-a - 1)*exp(-((x - m)/s)**(-a))/s
assert cdf(X)(x) == Piecewise((exp(-((-m + x)/s)**(-a)), m <= x), (0, True))
def test_chi_squared():
k = Symbol("k", integer=True)
X = ChiSquared('x', k)
assert density(X)(x) == 2**(-k/2)*x**(k/2 - 1)*exp(-x/2)/gamma(k/2)
assert cdf(X)(x) == Piecewise((lowergamma(k/2, x/2)/gamma(k/2), x >= 0), (0, True))
assert E(X) == k
assert variance(X) == 2*k
X = ChiSquared('x', 15)
assert cdf(X)(3) == -14873*sqrt(6)*exp(-S(3)/2)/(5005*sqrt(pi)) + erf(sqrt(6)/2)
k = Symbol("k", integer=True, positive=False)
raises(ValueError, lambda: ChiSquared('x', k))
k = Symbol("k", integer=False, positive=True)
raises(ValueError, lambda: ChiSquared('x', k))
def test_kumaraswamy():
a = Symbol("a", positive=True)
b = Symbol("b", positive=True)
X = Kumaraswamy("x", a, b)
assert density(X)(x) == x**(a - 1)*a*b*(-x**a + 1)**(b - 1)
assert cdf(X)(x) == Piecewise((0, x < 0),
(-(-x**a + 1)**b + 1, x <= 1),
(1, True))
def test_logistic():
mu = Symbol("mu", real=True)
s = Symbol("s", positive=True)
p = Symbol("p", positive=True)
X = Logistic('x', mu, s)
assert density(X)(x) == exp((-x + mu)/s)/(s*(exp((-x + mu)/s) + 1)**2)
assert cdf(X)(x) == 1/(exp((mu - x)/s) + 1)
assert quantile(X)(p) == mu - s*log(-S(1) + 1/p)
def test_dagum():
p = Symbol("p", positive=True)
b = Symbol("b", positive=True)
a = Symbol("a", positive=True)
X = Dagum('x', p, a, b)
assert density(X)(x) == a*p*(x/b)**(a*p)*((x/b)**a + 1)**(-p - 1)/x
assert cdf(X)(x) == Piecewise(((1 + (x/b)**(-a))**(-p), x >= 0),
(0, True))
def test_arcsin():
from sympy import asin
a = Symbol("a", real=True)
b = Symbol("b", real=True)
X = Arcsin('x', a, b)
assert density(X)(x) == 1/(pi*sqrt((-x + b)*(x - a)))
assert cdf(X)(x) == Piecewise((0, a > x),
(2*asin(sqrt((-a + x)/(-a + b)))/pi, b >= x),
(1, True))
def test_cauchy():
x0 = Symbol("x0")
gamma = Symbol("gamma", positive=True)
p = Symbol("p", positive=True)
X = Cauchy('x', x0, gamma)
assert density(X)(x) == 1/(pi*gamma*(1 + (x - x0)**2/gamma**2))
assert diff(cdf(X)(x), x) == density(X)(x)
assert quantile(X)(p) == gamma*tan(pi*(p - S.Half)) + x0
gamma = Symbol("gamma", positive=False)
raises(ValueError, lambda: Cauchy('x', x0, gamma))
def test_cdf():
X = Normal('x', 0, 1)
d = cdf(X)
assert P(X < 1) == d(1)
assert d(0) == S.Half
d = cdf(X, X > 0) # given X>0
assert d(0) == 0
Y = Exponential('y', 10)
d = cdf(Y)
assert d(-5) == 0
assert P(Y > 3) == 1 - d(3)
raises(ValueError, lambda: cdf(X + Y))
Z = Exponential('z', 1)
f = cdf(Z)
z = Symbol('z')
assert f(z) == Piecewise((1 - exp(-z), z >= 0), (0, True))
def test_nakagami():
mu = Symbol("mu", positive=True)
omega = Symbol("omega", positive=True)
X = Nakagami('x', mu, omega)
assert density(X)(x) == (2*x**(2*mu - 1)*mu**mu*omega**(-mu)
*exp(-x**2*mu/omega)/gamma(mu))
assert simplify(E(X)) == (sqrt(mu)*sqrt(omega)
*gamma(mu + S.Half)/gamma(mu + 1))
assert simplify(variance(X)) == (
omega - omega*gamma(mu + S(1)/2)**2/(gamma(mu)*gamma(mu + 1)))
assert cdf(X)(x) == Piecewise(
(lowergamma(mu, mu*x**2/omega)/gamma(mu), x > 0),
(0, True))
def test_long_precomputed_cdf():
x = symbols("x", real=True, finite=True)
distribs = [
Arcsin("A", -5, 9),
Dagum("D", 4, 10, 3),
Erlang("E", 14, 5),
Frechet("F", 2, 6, -3),
Gamma("G", 2, 7),
GammaInverse("GI", 3, 5),
Kumaraswamy("K", 6, 8),
Laplace("LA", -5, 4),
Logistic("L", -6, 7),
Nakagami("N", 2, 7),
StudentT("S", 4)
]
for distr in distribs:
for _ in range(5):
assert tn(diff(cdf(distr)(x), x), density(distr)(x), x, a=0, b=0, c=1, d=0)
US = UniformSum("US", 5)
pdf01 = density(US)(x).subs(floor(x), 0).doit() # pdf on (0, 1)
cdf01 = cdf(US, evaluate=False)(x).subs(floor(x), 0).doit() # cdf on (0, 1)
assert tn(diff(cdf01, x), pdf01, x, a=0, b=0, c=1, d=0)
def test_precomputed_cdf():
x = symbols("x", real=True, finite=True)
mu = symbols("mu", real=True, finite=True)
sigma, xm, alpha = symbols("sigma xm alpha", positive=True, finite=True)
n = symbols("n", integer=True, positive=True, finite=True)
distribs = [
Normal("X", mu, sigma),
Pareto("P", xm, alpha),
ChiSquared("C", n),
Exponential("E", sigma),
# LogNormal("L", mu, sigma),
]
for X in distribs:
compdiff = cdf(X)(x) - simplify(X.pspace.density.compute_cdf()(x))
compdiff = simplify(compdiff.rewrite(erfc))
assert compdiff == 0
def test_gamma():
k = Symbol("k", positive=True)
theta = Symbol("theta", positive=True)
X = Gamma('x', k, theta)
assert density(X) == Lambda(_x,
_x**(k - 1)*theta**(-k)*exp(-_x/theta)/gamma(k))
assert cdf(X, meijerg=True) == Lambda(_z, Piecewise(
(-k*lowergamma(k, 0)/gamma(k + 1) + k*lowergamma(k, _z/theta)/gamma(k + 1), _z >= 0), (0, True)))
assert variance(X) == (-theta**2*gamma(k + 1)**2/gamma(k)**2 +
theta*theta**(-k)*theta**(k + 1)*gamma(k + 2)/gamma(k))
k, theta = symbols('k theta', real=True, bounded=True, positive=True)
X = Gamma('x', k, theta)
assert simplify(E(X)) == k*theta
# can't get things to simplify on this one so we use subs
assert variance(X).subs(k, 5) == (k*theta**2).subs(k, 5)
def test_gamma():
k = Symbol("k", positive=True)
theta = Symbol("theta", positive=True)
X = Gamma("x", k, theta)
assert density(X)(x) == x ** (k - 1) * theta ** (-k) * exp(-x / theta) / gamma(k)
assert cdf(X, meijerg=True)(z) == Piecewise(
(-k * lowergamma(k, 0) / gamma(k + 1) + k * lowergamma(k, z / theta) / gamma(k + 1), z >= 0), (0, True)
)
# assert simplify(variance(X)) == k*theta**2 # handled numerically below
assert E(X) == moment(X, 1)
k, theta = symbols("k theta", real=True, finite=True, positive=True)
X = Gamma("x", k, theta)
assert simplify(E(X)) == k * theta
# can't get things to simplify on this one so we use subs
assert variance(X).subs(k, 5) == (k * theta ** 2).subs(k, 5)
def test_gamma():
k = Symbol("k", positive=True)
theta = Symbol("theta", positive=True)
X = Gamma('x', k, theta)
assert density(X)(x) == x**(k - 1)*theta**(-k)*exp(-x/theta)/gamma(k)
assert cdf(X, meijerg=True)(z) == Piecewise(
(-k*lowergamma(k, 0)/gamma(k + 1) +
k*lowergamma(k, z/theta)/gamma(k + 1), z >= 0),
(0, True))
# assert simplify(variance(X)) == k*theta**2 # handled numerically below
assert E(X) == moment(X, 1)
k, theta = symbols('k theta', real=True, finite=True, positive=True)
X = Gamma('x', k, theta)
assert simplify(E(X)) == k*theta
# can't get things to simplify on this one so we use subs
assert variance(X).subs(k, 5) == (k*theta**2).subs(k, 5)
def test_gamma():
k = Symbol("k", positive=True)
theta = Symbol("theta", positive=True)
X = Gamma('x', k, theta)
assert density(X)(x) == x**(k - 1) * theta**(-k) * exp(
-x / theta) / gamma(k)
assert cdf(X, meijerg=True)(z) == Piecewise(
(-k * lowergamma(k, 0) / gamma(k + 1) +
k * lowergamma(k, z / theta) / gamma(k + 1), z >= 0), (0, True))
# assert simplify(variance(X)) == k*theta**2 # handled numerically below
assert E(X) == moment(X, 1)
k, theta = symbols('k theta', real=True, finite=True, positive=True)
X = Gamma('x', k, theta)
assert E(X) == k * theta
assert variance(X) == k * theta**2
assert simplify(skewness(X)) == 2 / sqrt(k)
def test_levy():
mu = Symbol("mu", real=True)
c = Symbol("c", positive=True)
X = Levy('x', mu, c)
assert X.pspace.domain.set == Interval(mu, oo)
assert density(X)(x) == sqrt(c / (2 * pi)) * exp(-c / (2 * (x - mu))) / (
(x - mu)**(S.One + S.Half))
assert cdf(X)(x) == erfc(sqrt(c / (2 * (x - mu))))
mu = Symbol("mu", real=False)
raises(ValueError, lambda: Levy('x', mu, c))
c = Symbol("c", nonpositive=True)
raises(ValueError, lambda: Levy('x', mu, c))
mu = Symbol("mu", real=True)
raises(ValueError, lambda: Levy('x', mu, c))
def test_pareto():
xm, beta = symbols('xm beta', positive=True)
alpha = beta + 5
X = Pareto('x', xm, alpha)
dens = density(X)
#Tests cdf function
assert cdf(X)(x) == \
Piecewise((-x**(-beta - 5)*xm**(beta + 5) + 1, x >= xm), (0, True))
#Tests characteristic_function
assert characteristic_function(X)(x) == \
((-I*x*xm)**(beta + 5)*(beta + 5)*uppergamma(-beta - 5, -I*x*xm))
assert dens(x) == x**(-(alpha + 1)) * xm**(alpha) * (alpha)
assert simplify(E(X)) == alpha * xm / (alpha - 1)
def test_cauchy():
x0 = Symbol("x0", real=True)
gamma = Symbol("gamma", positive=True)
p = Symbol("p", positive=True)
X = Cauchy('x', x0, gamma)
# Tests the characteristic function
assert characteristic_function(X)(x) == exp(-gamma*Abs(x) + I*x*x0)
assert density(X)(x) == 1/(pi*gamma*(1 + (x - x0)**2/gamma**2))
assert diff(cdf(X)(x), x) == density(X)(x)
assert quantile(X)(p) == gamma*tan(pi*(p - S.Half)) + x0
x1 = Symbol("x1", real=False)
raises(ValueError, lambda: Cauchy('x', x1, gamma))
gamma = Symbol("gamma", nonpositive=True)
raises(ValueError, lambda: Cauchy('x', x0, gamma))
assert median(X) == FiniteSet(x0)
def test_gamma():
k = Symbol("k", positive=True)
theta = Symbol("theta", positive=True)
X = Gamma('x', k, theta)
assert density(X)(x) == x**(k - 1)*theta**(-k)*exp(-x/theta)/gamma(k)
assert cdf(X, meijerg=True)(z) == Piecewise(
(-k*lowergamma(k, 0)/gamma(k + 1) +
k*lowergamma(k, z/theta)/gamma(k + 1), z >= 0),
(0, True))
# assert simplify(variance(X)) == k*theta**2 # handled numerically below
assert E(X) == moment(X, 1)
k, theta = symbols('k theta', real=True, finite=True, positive=True)
X = Gamma('x', k, theta)
assert E(X) == k*theta
assert variance(X) == k*theta**2
assert simplify(skewness(X)) == 2/sqrt(k)
def test_bernoulli_CompoundDist():
X = Beta('X', 1, 2)
Y = Bernoulli('Y', X)
assert density(Y).dict == {0: S(2)/3, 1: S(1)/3}
assert E(Y) == P(Eq(Y, 1)) == S(1)/3
assert variance(Y) == S(2)/9
assert cdf(Y) == {0: S(2)/3, 1: 1}
# test issue 8128
a = Bernoulli('a', S(1)/2)
b = Bernoulli('b', a)
assert density(b).dict == {0: S(1)/2, 1: S(1)/2}
assert P(b > 0.5) == S(1)/2
X = Uniform('X', 0, 1)
Y = Bernoulli('Y', X)
assert E(Y) == S(1)/2
assert P(Eq(Y, 1)) == E(Y)
def test_Moyal():
mu = Symbol('mu',real=False)
sigma = Symbol('sigma', real=True, positive=True)
raises(ValueError, lambda: Moyal('M',mu, sigma))
mu = Symbol('mu', real=True)
sigma = Symbol('sigma', real=True, negative=True)
raises(ValueError, lambda: Moyal('M',mu, sigma))
sigma = Symbol('sigma', real=True, positive=True)
M = Moyal('M', mu, sigma)
assert density(M)(z) == sqrt(2)*exp(-exp((mu - z)/sigma)/2
- (-mu + z)/(2*sigma))/(2*sqrt(pi)*sigma)
assert cdf(M)(z).simplify() == 1 - erf(sqrt(2)*exp((mu - z)/(2*sigma))/2)
assert characteristic_function(M)(z) == 2**(-I*sigma*z)*exp(I*mu*z) \
*gamma(-I*sigma*z + Rational(1, 2))/sqrt(pi)
assert E(M) == mu + EulerGamma*sigma + sigma*log(2)
assert moment_generating_function(M)(z) == 2**(-sigma*z)*exp(mu*z) \
*gamma(-sigma*z + Rational(1, 2))/sqrt(pi)
def test_dagum():
p = Symbol("p", positive=True)
b = Symbol("b", positive=True)
a = Symbol("a", positive=True)
X = Dagum('x', p, a, b)
assert density(X)(x) == a*p*(x/b)**(a*p)*((x/b)**a + 1)**(-p - 1)/x
assert cdf(X)(x) == Piecewise(((1 + (x/b)**(-a))**(-p), x >= 0),
(0, True))
p = Symbol("p", nonpositive=True)
raises(ValueError, lambda: Dagum('x', p, a, b))
p = Symbol("p", positive=True)
b = Symbol("b", nonpositive=True)
raises(ValueError, lambda: Dagum('x', p, a, b))
b = Symbol("b", positive=True)
a = Symbol("a", nonpositive=True)
raises(ValueError, lambda: Dagum('x', p, a, b))
def test_gamma():
k = Symbol("k", positive=True)
theta = Symbol("theta", positive=True)
X = Gamma('x', k, theta)
assert density(X) == Lambda(
_x,
_x**(k - 1) * theta**(-k) * exp(-_x / theta) / gamma(k))
assert cdf(X, meijerg=True) == Lambda(
_z,
Piecewise((0, _z < 0),
(-k * lowergamma(k, 0) / gamma(k + 1) +
k * lowergamma(k, _z / theta) / gamma(k + 1), True)))
assert variance(X) == (
-theta**2 * gamma(k + 1)**2 / gamma(k)**2 +
theta * theta**(-k) * theta**(k + 1) * gamma(k + 2) / gamma(k))
k, theta = symbols('k theta', real=True, bounded=True, positive=True)
X = Gamma('x', k, theta)
assert simplify(E(X)) == k * theta
# can't get things to simplify on this one so we use subs
assert variance(X).subs(k, 5) == (k * theta**2).subs(k, 5)
def test_uniform():
l = Symbol('l', real=True, finite=True)
w = Symbol('w', positive=True, finite=True)
X = Uniform('x', l, l + w)
assert simplify(E(X)) == l + w/2
assert simplify(variance(X)) == w**2/12
# With numbers all is well
X = Uniform('x', 3, 5)
assert P(X < 3) == 0 and P(X > 5) == 0
assert P(X < 4) == P(X > 4) == S.Half
z = Symbol('z')
p = density(X)(z)
assert p.subs(z, 3.7) == S(1)/2
assert p.subs(z, -1) == 0
assert p.subs(z, 6) == 0
c = cdf(X)
assert c(2) == 0 and c(3) == 0
assert c(S(7)/2) == S(1)/4
assert c(5) == 1 and c(6) == 1
def test_loglogistic():
a, b = symbols('a b')
assert LogLogistic('x', a, b)
a = Symbol('a', negative=True)
b = Symbol('b', positive=True)
raises(ValueError, lambda: LogLogistic('x', a, b))
a = Symbol('a', positive=True)
b = Symbol('b', negative=True)
raises(ValueError, lambda: LogLogistic('x', a, b))
a, b, z, p = symbols('a b z p', positive=True)
X = LogLogistic('x', a, b)
assert density(X)(z) == b*(z/a)**(b - 1)/(a*((z/a)**b + 1)**2)
assert cdf(X)(z) == 1/(1 + (z/a)**(-b))
assert quantile(X)(p) == a*(p/(1 - p))**(1/b)
# Expectation
assert E(X) == Piecewise((S.NaN, b <= 1), (pi*a/(b*sin(pi/b)), True))
b = symbols('b', prime=True) # b > 1
X = LogLogistic('x', a, b)
assert E(X) == pi*a/(b*sin(pi/b))
def test_construct_lazy(self):
# adapted from https://gist.github.com/raddy/bd0e977dc8437a4f8276
spot, strike, vol, dte, rate, cp = sy.symbols('spot strike vol dte rate cp')
T = dte / 260.
N = syNormal('N', 0.0, 1.0)
d1 = (sy.ln(spot / strike) + (0.5 * vol ** 2) * T) / (vol * sy.sqrt(T))
d2 = d1 - vol * sy.sqrt(T)
TimeValueExpr = sy.exp(-rate * T) * (cp * spot * cdf(N)(cp * d1) - cp * strike * cdf(N)(cp * d2))
PriceClass = ts.construct_lazy(TimeValueExpr)
price = PriceClass(spot=210.59, strike=205, vol=14.04, dte=4, rate=.2175, cp=-1)
x = price.evaluate()()
assert price.evaluate()() == x
price.strike = 210
assert x != price.evaluate()()
def test_uniform():
l = Symbol('l', real=True)
w = Symbol('w', positive=True)
X = Uniform('x', l, l + w)
assert E(X) == l + w / 2
assert variance(X).expand() == w**2 / 12
# With numbers all is well
X = Uniform('x', 3, 5)
assert P(X < 3) == 0 and P(X > 5) == 0
assert P(X < 4) == P(X > 4) == S.Half
z = Symbol('z')
p = density(X)(z)
assert p.subs(z, 3.7) == S.Half
assert p.subs(z, -1) == 0
assert p.subs(z, 6) == 0
c = cdf(X)
assert c(2) == 0 and c(3) == 0
assert c(Rational(7, 2)) == Rational(1, 4)
assert c(5) == 1 and c(6) == 1
def test_uniform():
l = Symbol('l', real=True, finite=True)
w = Symbol('w', positive=True, finite=True)
X = Uniform('x', l, l + w)
assert simplify(E(X)) == l + w/2
assert simplify(variance(X)) == w**2/12
# With numbers all is well
X = Uniform('x', 3, 5)
assert P(X < 3) == 0 and P(X > 5) == 0
assert P(X < 4) == P(X > 4) == S.Half
z = Symbol('z')
p = density(X)(z)
assert p.subs(z, 3.7) == S(1)/2
assert p.subs(z, -1) == 0
assert p.subs(z, 6) == 0
c = cdf(X)
assert c(2) == 0 and c(3) == 0
assert c(S(7)/2) == S(1)/4
assert c(5) == 1 and c(6) == 1
def test_gamma():
k = Symbol("k", positive=True)
theta = Symbol("theta", positive=True)
X = Gamma('x', k, theta)
# Tests characteristic function
assert characteristic_function(X)(x) == ((-I * theta * x + 1)**(-k))
assert density(X)(x) == x**(k - 1) * theta**(-k) * exp(
-x / theta) / gamma(k)
assert cdf(X, meijerg=True)(z) == Piecewise(
(-k * lowergamma(k, 0) / gamma(k + 1) +
k * lowergamma(k, z / theta) / gamma(k + 1), z >= 0), (0, True))
# assert simplify(variance(X)) == k*theta**2 # handled numerically below
assert E(X) == moment(X, 1)
k, theta = symbols('k theta', positive=True)
X = Gamma('x', k, theta)
assert E(X) == k * theta
assert variance(X) == k * theta**2
assert skewness(X).expand() == 2 / sqrt(k)
assert kurtosis(X).expand() == 3 + 6 / k
def test_prob():
def emit(name, iname, cdf, args, no_small=False):
V = []
for arg in sorted(args):
y = cdf(*arg)
if isinstance(y, mpf):
e = sp.nsimplify(y, rational=True)
if e.is_Rational and e.q <= 1000 and \
mp.almosteq(mp.mpf(e), y, 1e-25):
y = e
else:
y = N(y)
V.append(arg + (y,))
for v in V:
if name:
test(name, *v)
for v in V:
if iname and (not no_small or 1/1000 <= v[-1] <= 999/1000):
test(iname, *(v[:-2] + v[:-3:-1]))
x = sp.Symbol("x")
emit("ncdf", "nicdf",
sp.Lambda(x, st.cdf(st.Normal("X", 0, 1))(x)), zip(exparg))
# using cdf() for anything more complex is too slow
df = FiniteSet(1, S(3)/2, 2, S(5)/2, 5, 25)
emit("c2cdf", "c2icdf",
lambda k, x: sp.lowergamma(k/2, x/2)/sp.gamma(k/2),
ProductSet(df, posarg), no_small=True)
dfint = df & sp.fancysets.Naturals()
def cdf(k, x):
k, x = map(mpf, (k, x))
return .5 + .5*mp.sign(x)*mp.betainc(k/2, .5, x1=1/(1+x**2/k),
regularized=True)
emit("stcdf", "sticdf", cdf, ProductSet(dfint, exparg))
def cdf(d1, d2, x):
d1, d2, x = map(mpf, (d1, d2, x))
return mp.betainc(d1/2, d2/2, x2=x/(x+d2/d1), regularized=True)
emit("fcdf", "ficdf", cdf, ProductSet(dfint, dfint, posarg))
kth = ProductSet(sp.ImageSet(lambda x: x/5, df),
posarg - FiniteSet(0))
emit("gcdf", "gicdf",
lambda k, th, x: sp.lowergamma(k, x/th)/sp.gamma(k),
ProductSet(kth, posarg), no_small=True)
karg = FiniteSet(0, 1, 2, 5, 10, 15, 40)
knparg = [(k, n, p) for k, n, p
in ProductSet(karg, karg, posarg & Interval(0, 1, True, True))
if k <= n and n > 0]
def cdf(k, n, p):
return st.P(st.Binomial("X", n, p) <= k)
emit("bncdf", "bnicdf", cdf, knparg, no_small=True)
def cdf(k, lamda):
return sp.uppergamma(k+1, lamda)/sp.gamma(k+1)
emit("pscdf", "psicdf", cdf,
ProductSet(karg, posarg + karg - FiniteSet(0)), no_small=True)
x, i = sp.symbols("x i")
def smcdf(n, e):
return 1-sp.Sum(sp.binomial(n, i)*e*(e+i/n)**(i-1)*(1-e-i/n)**(n-i),
(i, 0, sp.floor(n*(1-e)))).doit()
kcdf = sp.Lambda(x,
sp.sqrt(2*pi)/x*sp.Sum(sp.exp(-pi**2/8*(2*i-1)**2/x**2), (i, 1, oo)))
smarg = ProductSet(karg - FiniteSet(0), posarg & Interval(0, 1, True, True))
karg = FiniteSet(S(1)/100, S(1)/10) + (posarg & Interval(S(1)/4, oo, True))
for n, e in sorted(smarg):
test("smcdf", n, e, N(smcdf(n, e)))
prec("1e-10")
for x in sorted(karg):
test("kcdf", x, N(kcdf(x)))
prec("1e-9")
for n, e in sorted(smarg):
p = smcdf(n, e)
if p < S(9)/10:
test("smicdf", n, N(p), e)
prec("1e-6")
for x in sorted(karg):
p = kcdf(x)
if N(p) > S(10)**-8:
test("kicdf", N(p), x)
def test_dice():
# TODO: Make iid method!
X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6)
a, b, t, p = symbols('a b t p')
assert E(X) == 3 + S.Half
assert variance(X) == S(35) / 12
assert E(X + Y) == 7
assert E(X + X) == 7
assert E(a * X + b) == a * E(X) + b
assert variance(X + Y) == variance(X) + variance(Y) == cmoment(X + Y, 2)
assert variance(X + X) == 4 * variance(X) == cmoment(X + X, 2)
assert cmoment(X, 0) == 1
assert cmoment(4 * X, 3) == 64 * cmoment(X, 3)
assert covariance(X, Y) == S.Zero
assert covariance(X, X + Y) == variance(X)
assert density(Eq(cos(X * S.Pi), 1))[True] == S.Half
assert correlation(X, Y) == 0
assert correlation(X, Y) == correlation(Y, X)
assert smoment(X + Y, 3) == skewness(X + Y)
assert smoment(X + Y, 4) == kurtosis(X + Y)
assert smoment(X, 0) == 1
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 == moment(X, 1, 0, X > 3)
assert E(X, Y > 3) == E(X) == moment(X, 1, 0, Y > 3)
assert E(X + Y, Eq(X, Y)) == E(2 * X)
assert moment(X, 0) == 1
assert moment(5 * X, 2) == 25 * moment(X, 2)
assert quantile(X)(p) == Piecewise((nan, (p > S.One) | (p < S(0))),\
(S.One, p <= S(1)/6), (S(2), p <= S(1)/3), (S(3), p <= S.Half),\
(S(4), p <= S(2)/3), (S(5), p <= S(5)/6), (S(6), p <= S.One))
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)
assert characteristic_function(X)(t) == exp(6 * I * t) / 6 + exp(
5 * I * t) / 6 + exp(4 * I * t) / 6 + exp(3 * I * t) / 6 + exp(
2 * I * t) / 6 + exp(I * t) / 6
assert moment_generating_function(X)(
t) == exp(6 * t) / 6 + exp(5 * t) / 6 + exp(4 * t) / 6 + exp(
3 * t) / 6 + exp(2 * t) / 6 + exp(t) / 6
# Bayes test for die
BayesTest(X > 3, X + Y < 5)
BayesTest(Eq(X - Y, Z), Z > Y)
BayesTest(X > 3, X > 2)
# arg test for die
raises(ValueError, lambda: Die('X', -1)) # issue 8105: negative sides.
raises(ValueError, lambda: Die('X', 0))
raises(ValueError, lambda: Die('X', 1.5)) # issue 8103: non integer sides.
# symbolic test for die
n, k = symbols('n, k', positive=True)
D = Die('D', n)
dens = density(D).dict
assert dens == Density(DieDistribution(n))
assert set(dens.subs(n, 4).doit().keys()) == set([1, 2, 3, 4])
assert set(dens.subs(n, 4).doit().values()) == set([S(1) / 4])
k = Dummy('k', integer=True)
assert E(D).dummy_eq(Sum(Piecewise((k / n, k <= n), (0, True)), (k, 1, n)))
assert variance(D).subs(n, 6).doit() == S(35) / 12
ki = Dummy('ki')
cumuf = cdf(D)(k)
assert cumuf.dummy_eq(
Sum(Piecewise((1 / n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, k)))
assert cumuf.subs({n: 6, k: 2}).doit() == S(1) / 3
t = Dummy('t')
cf = characteristic_function(D)(t)
assert cf.dummy_eq(
Sum(Piecewise((exp(ki * I * t) / n, (ki >= 1) & (ki <= n)), (0, True)),
(ki, 1, n)))
assert cf.subs(
n,
3).doit() == exp(3 * I * t) / 3 + exp(2 * I * t) / 3 + exp(I * t) / 3
mgf = moment_generating_function(D)(t)
assert mgf.dummy_eq(
Sum(Piecewise((exp(ki * t) / n, (ki >= 1) & (ki <= n)), (0, True)),
(ki, 1, n)))
assert mgf.subs(n,
3).doit() == exp(3 * t) / 3 + exp(2 * t) / 3 + exp(t) / 3
from sympy.stats import UniformSum, density, cdf
# configuration
res_size = 128
wl_size = 8192
task_length_mean = 1024
core_perf = 32
het = 0.5
sensitivity = 100
task_exec_time_mean = task_length_mean / core_perf
gen = int(wl_size / res_size)
cdf_val = np.power(0.5, 1 / res_size)
# calculate thr (value of x in Irwin-Hall CDF) P(max(TTX_j)<x)=0.5
range_val = sensitivity * gen
min_val = 1
thr = gen * 1.0
for x in range(range_val):
tmp = cdf(UniformSum("x", gen), evaluate=False)(x / sensitivity).doit()
tmp_diff = np.absolute(tmp - cdf_val)
if (tmp_diff < min_val):
min_val = tmp_diff
thr = x / sensitivity
print(thr)
# transformation from a U(0,1) distribution to U(a,b) distribution
ttx = task_exec_time_mean * (1 -
het) * gen + task_exec_time_mean * het * 2 * thr
print(ttx)
def test_cdf():
D = Die('D', 6)
o = S.One
assert cdf(
D) == sympify({1: o/6, 2: o/3, 3: o/2, 4: 2*o/3, 5: 5*o/6, 6: o})
def test_cdf():
D = Die('D', 6)
o = S.One
assert cdf(
D) == sympify({1: o/6, 2: o/3, 3: o/2, 4: 2*o/3, 5: 5*o/6, 6: o})
def test_gamma_inverse():
a = Symbol("a", positive=True)
b = Symbol("b", positive=True)
X = GammaInverse("x", a, b)
assert density(X)(x) == x**(-a - 1)*b**a*exp(-b/x)/gamma(a)
assert cdf(X)(x) == Piecewise((uppergamma(a, b/x)/gamma(a), x > 0), (0, True))
"""
Created on Thu Mar 28 15:57:09 2019
@author: javie
"""
# SymPy Imports
from sympy import init_session
init_session()
gini = 0.7
pLambda = (1 + gini) / (2 * gini)
population = 4000
thetaMin = 0.1
cParam = 0.01
gamma = 2
delta = 0.5
cFijo = 0
discountQ = 0.7
probRichest = 0.99
p, q, th = symbols('p q th', real=True)
dem = symbols('dem', integer=True)
from sympy.stats import P, E, variance, Binomial, cdf, density, Pareto
pa = Pareto("pa", thetaMin, pLambda)
bi = Binomial("bi", population, 1-cdf(pa)(th))
def test_prob():
def emit(name, iname, cdf, args, no_small=False):
V = []
for arg in sorted(args):
y = cdf(*arg)
if isinstance(y, mpf):
e = sp.nsimplify(y, rational=True)
if e.is_Rational and e.q <= 1000 and \
mp.almosteq(mp.mpf(e), y, 1e-25):
y = e
else:
y = N(y)
V.append(arg + (y, ))
for v in V:
if name:
test(name, *v)
for v in V:
if iname and (not no_small or 1 / 1000 <= v[-1] <= 999 / 1000):
test(iname, *(v[:-2] + v[:-3:-1]))
x = sp.Symbol("x")
emit("ncdf", "nicdf", sp.Lambda(x,
st.cdf(st.Normal("X", 0, 1))(x)),
zip(exparg))
# using cdf() for anything more complex is too slow
df = FiniteSet(1, S(3) / 2, 2, S(5) / 2, 5, 25)
emit("c2cdf",
"c2icdf",
lambda k, x: sp.lowergamma(k / 2, x / 2) / sp.gamma(k / 2),
ProductSet(df, posarg),
no_small=True)
dfint = df & sp.fancysets.Naturals()
def cdf(k, x):
k, x = map(mpf, (k, x))
return .5 + .5 * mp.sign(x) * mp.betainc(
k / 2, .5, x1=1 / (1 + x**2 / k), regularized=True)
emit("stcdf", "sticdf", cdf, ProductSet(dfint, exparg))
def cdf(d1, d2, x):
d1, d2, x = map(mpf, (d1, d2, x))
return mp.betainc(d1 / 2,
d2 / 2,
x2=x / (x + d2 / d1),
regularized=True)
emit("fcdf", "ficdf", cdf, ProductSet(dfint, dfint, posarg))
kth = ProductSet(sp.ImageSet(lambda x: x / 5, df), posarg - FiniteSet(0))
emit("gcdf",
"gicdf",
lambda k, th, x: sp.lowergamma(k, x / th) / sp.gamma(k),
ProductSet(kth, posarg),
no_small=True)
karg = FiniteSet(0, 1, 2, 5, 10, 15, 40)
knparg = [(k, n, p)
for k, n, p in ProductSet(karg, karg, posarg
& Interval(0, 1, True, True))
if k <= n and n > 0]
def cdf(k, n, p):
return st.P(st.Binomial("X", n, p) <= k)
emit("bncdf", "bnicdf", cdf, knparg, no_small=True)
def cdf(k, lamda):
return sp.uppergamma(k + 1, lamda) / sp.gamma(k + 1)
emit("pscdf",
"psicdf",
cdf,
ProductSet(karg, posarg + karg - FiniteSet(0)),
no_small=True)
x, i = sp.symbols("x i")
def smcdf(n, e):
return 1 - sp.Sum(
sp.binomial(n, i) * e * (e + i / n)**(i - 1) *
(1 - e - i / n)**(n - i), (i, 0, sp.floor(n * (1 - e)))).doit()
kcdf = sp.Lambda(
x,
sp.sqrt(2 * pi) / x *
sp.Sum(sp.exp(-pi**2 / 8 * (2 * i - 1)**2 / x**2), (i, 1, oo)))
smarg = ProductSet(karg - FiniteSet(0),
posarg & Interval(0, 1, True, True))
karg = FiniteSet(S(1) / 100,
S(1) / 10) + (posarg & Interval(S(1) / 4, oo, True))
for n, e in sorted(smarg):
test("smcdf", n, e, N(smcdf(n, e)))
prec("1e-10")
for x in sorted(karg):
test("kcdf", x, N(kcdf(x)))
prec("1e-9")
for n, e in sorted(smarg):
p = smcdf(n, e)
if p < S(9) / 10:
test("smicdf", n, N(p), e)
prec("1e-6")
for x in sorted(karg):
p = kcdf(x)
if N(p) > S(10)**-8:
test("kicdf", N(p), x)
