class USR:
'''
Uniform Set of References, aka RT_LMAD (Real Time Linear Memory Access
Descriptor) both to be found in Rus et al. 2003 and Rus et al. 2008. Simple
implementation for the needs of TVB. No strides, branching, conditionals
etc., only union, intersection, complement and subtration; uses sympy
finite sets as underlying implementation of dimensions of known sizes as a
quick fix and ignores symbolic dimensions altogether. MD-LMAD
(Multi-Dimensional Linear Memory Access Descriptor (Paek et al. 2002))
leaves represented by ProductSet of Range instances (seems to be exact). To
be rewritten and/or replaced with full RT_LMAD implementation if needed in
future ;)
'''
def __init__(self, subscripts=None):
'''
Creates an empty USR or an USR containing single MD-LMAD leaf
subscripts:
list of subscripts defining the access to particular dimension, for
every dimension we use a triplet notation: lower bound, upper
bound, stride. Each subscript is therefore a tuple of following
possible formats: n - linear range from 0 to n-1; (low, up) -
linear range from low to up-1; (low, up,step) same, but with a
step.
'''
if subscripts is None:
self._symbolic_set = EmptySet()
else:
ranges = tuple(map(lambda x: Range(x) if isinstance(x,int) else Range(*x), subscripts))
self._symbolic_set = ProductSet(*ranges)
def __repr__(self):
return "<USR: "******">"
def intersect(self, other):
usr = USR()
usr._symbolic_set = self._symbolic_set.intersect(other._symbolic_set)
return usr
def union(self, other):
usr = USR()
usr._symbolic_set = self._symbolic_set.union(other._symbolic_set)
return usr
def is_empty(self):
return self._symbolic_set is EmptySet()
def complement(self, other):
usr = USR()
usr._symbolic_set = Complement(FiniteSet(*self._symbolic_set), FiniteSet(*other._symbolic_set))
return usr
def __eq__(self, other):
return FiniteSet(*self._symbolic_set) == FiniteSet(*other._symbolic_set)
def __str__(self):
return str(self._symbolic_set)
def union_sets(a, b):
if b.is_subset(a):
return a
if len(b.args) != len(a.args):
return None
if a.args[0] == b.args[0]:
return a.args[0] * Union(ProductSet(a.args[1:]),
ProductSet(b.args[1:]))
if a.args[-1] == b.args[-1]:
return Union(ProductSet(a.args[:-1]),
ProductSet(b.args[:-1])) * a.args[-1]
return None
def test_hyper():
for x in sorted(exparg):
test("erf", x, N(sp.erf(x)))
for x in sorted(exparg):
test("erfc", x, N(sp.erfc(x)))
gamarg = FiniteSet(*(x + S(1) / 12 for x in exparg))
betarg = ProductSet(gamarg, gamarg)
for x in sorted(gamarg):
test("lgamma", x, N(sp.log(abs(sp.gamma(x)))))
for x in sorted(gamarg):
test("gamma", x, N(sp.gamma(x)))
for x, y in sorted(betarg, key=lambda (x, y): (y, x)):
test("beta", x, y, N(sp.beta(x, y)))
pgamarg = FiniteSet(S(1) / 12, S(1) / 3, S(3) / 2, 5)
pgamargp = ProductSet(gamarg & Interval(0, oo, True), pgamarg)
for a, x in sorted(pgamargp):
test("pgamma", a, x, N(sp.lowergamma(a, x)))
for a, x in sorted(pgamargp):
test("pgammac", a, x, N(sp.uppergamma(a, x)))
for a, x in sorted(pgamargp):
test("pgammar", a, x, N(sp.lowergamma(a, x) / sp.gamma(a)))
for a, x in sorted(pgamargp):
test("pgammarc", a, x, N(sp.uppergamma(a, x) / sp.gamma(a)))
for a, x in sorted(pgamargp):
test("ipgammarc", a, N(sp.uppergamma(a, x) / sp.gamma(a)), x)
pbetargp = [(a, b, x) for a, b, x in ProductSet(betarg, pgamarg)
if a > 0 and b > 0 and x < 1]
pbetargp.sort(key=lambda (a, b, x): (b, a, x))
for a, b, x in pbetargp:
test("pbeta", a, b, x, mp.betainc(mpf(a), mpf(b), x2=mpf(x)))
for a, b, x in pbetargp:
test("pbetar", a, b, x,
mp.betainc(mpf(a), mpf(b), x2=mpf(x), regularized=True))
for a, b, x in pbetargp:
test("ipbetar", a, b,
mp.betainc(mpf(a), mpf(b), x2=mpf(x), regularized=True), x)
for x in sorted(posarg):
test("j0", x, N(sp.besselj(0, x)))
for x in sorted(posarg):
test("j1", x, N(sp.besselj(1, x)))
for x in sorted(posarg - FiniteSet(0)):
test("y0", x, N(sp.bessely(0, x)))
for x in sorted(posarg - FiniteSet(0)):
test("y1", x, N(sp.bessely(1, x)))
def test_MultivariateEwens():
n, theta, i = symbols('n theta i', positive=True)
# tests for integer dimensions
theta_f = symbols('t_f', negative=True)
a = symbols('a_1:4', positive=True, integer=True)
ed = MultivariateEwens('E', 3, theta)
assert density(ed)(a[0], a[1], a[2]) == Piecewise(
(6 * 2**(-a[1]) * 3**(-a[2]) * theta**a[0] * theta**a[1] *
theta**a[2] /
(theta * (theta + 1) *
(theta + 2) * factorial(a[0]) * factorial(a[1]) * factorial(a[2])),
Eq(a[0] + 2 * a[1] + 3 * a[2], 3)), (0, True))
assert marginal_distribution(ed, ed[1])(a[1]) == Piecewise(
(6 * 2**(-a[1]) * theta**a[1] /
((theta + 1) * (theta + 2) * factorial(a[1])), Eq(2 * a[1] + 1, 3)),
(0, True))
raises(ValueError, lambda: MultivariateEwens('e1', 5, theta_f))
assert ed.pspace.distribution.set == ProductSet(Range(0, 4, 1),
Range(0, 2, 1),
Range(0, 2, 1))
# tests for symbolic dimensions
eds = MultivariateEwens('E', n, theta)
a = IndexedBase('a')
j, k = symbols('j, k')
den = Piecewise((factorial(n) *
Product(theta**a[j] * (j + 1)**(-a[j]) / factorial(a[j]),
(j, 0, n - 1)) / RisingFactorial(theta, n),
Eq(n, Sum((k + 1) * a[k], (k, 0, n - 1)))), (0, True))
assert density(eds)(a).dummy_eq(den)
def test_Normal():
m = Normal('A', [1, 2], [[1, 0], [0, 1]])
A = MultivariateNormal('A', [1, 2], [[1, 0], [0, 1]])
assert m == A
assert density(m)(1, 2) == 1 / (2 * pi)
assert m.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
raises(ValueError, lambda: m[2])
raises (ValueError,\
lambda: Normal('M',[1, 2], [[0, 0], [0, 1]]))
n = Normal('B', [1, 2, 3], [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
p = Normal('C', Matrix([1, 2]), Matrix([[1, 0], [0, 1]]))
assert density(m)(x, y) == density(p)(x, y)
assert marginal_distribution(n, 0, 1)(1, 2) == 1 / (2 * pi)
raises(ValueError, lambda: marginal_distribution(m))
assert integrate(density(m)(x, y), (x, -oo, oo), (y, -oo, oo)).evalf() == 1
N = Normal('N', [1, 2], [[x, 0], [0, y]])
assert density(N)(0,
0) == exp(-2 / y - 1 / (2 * x)) / (2 * pi * sqrt(x * y))
raises(ValueError, lambda: Normal('M', [1, 2], [[1, 1], [1, -1]]))
# symbolic
n = symbols('n', natural=True)
mu = MatrixSymbol('mu', n, 1)
sigma = MatrixSymbol('sigma', n, n)
X = Normal('X', mu, sigma)
assert density(X) == MultivariateNormalDistribution(mu, sigma)
raises(NotImplementedError, lambda: median(m))
def test_MatrixGamma():
M = MatrixGamma('M', 1, 2, [[1, 0], [0, 1]])
assert M.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
assert isinstance(density(M), MatrixGammaDistribution)
X = MatrixSymbol('X', 2, 2)
num = exp(Trace(Matrix([[-S(1) / 2, 0], [0, -S(1) / 2]]) * X))
assert density(M)(X).doit() == num / (4 * pi * sqrt(Determinant(X)))
assert density(M)([[2, 1], [1, 2]]).doit() == sqrt(3) * exp(-2) / (12 * pi)
X = MatrixSymbol('X', 1, 2)
Y = MatrixSymbol('Y', 1, 2)
assert density(M)([X, Y]).doit() == exp(-X[0, 0] / 2 - Y[0, 1] / 2) / (
4 * pi * sqrt(X[0, 0] * Y[0, 1] - X[0, 1] * Y[0, 0]))
# symbolic
a, b = symbols('a b', positive=True)
d = symbols('d', positive=True, integer=True)
Y = MatrixSymbol('Y', d, d)
Z = MatrixSymbol('Z', 2, 2)
SM = MatrixSymbol('SM', d, d)
M2 = MatrixGamma('M2', a, b, SM)
M3 = MatrixGamma('M3', 2, 3, [[2, 1], [1, 2]])
k = Dummy('k')
exprd = pi**(-d * (d - 1) / 4) * b**(-a * d) * exp(
Trace((-1 / b) * SM**(-1) * Y)) * Determinant(SM)**(-a) * Determinant(
Y)**(a - d / 2 - S(1) / 2) / Product(gamma(-k / 2 + a + S(1) / 2),
(k, 1, d))
assert density(M2)(Y).dummy_eq(exprd)
raises(NotImplementedError, lambda: density(M3 + M)(Z))
raises(ValueError, lambda: density(M)(1))
raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [0, 1]]))
raises(ValueError, lambda: MatrixGamma('M', -1, -2, [[1, 0], [0, 1]]))
raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [2, 1]]))
raises(ValueError, lambda: MatrixGamma('M', -1, 2, [[1, 0], [0]]))
def set(self):
rvs = [i for i in random_symbols(self.args[1])]
marginalise_out = [i for i in random_symbols(self.args[1]) \
if i not in self.args[1]]
for i in rvs:
if i in marginalise_out:
rvs.remove(i)
return ProductSet((i.pspace.set for i in rvs))
def __init__(self, subscripts=None):
'''
Creates an empty USR or an USR containing single MD-LMAD leaf
subscripts:
list of subscripts defining the access to particular dimension, for
every dimension we use a triplet notation: lower bound, upper
bound, stride. Each subscript is therefore a tuple of following
possible formats: n - linear range from 0 to n-1; (low, up) -
linear range from low to up-1; (low, up,step) same, but with a
step.
'''
if subscripts is None:
self._symbolic_set = EmptySet()
else:
ranges = tuple(map(lambda x: Range(x) if isinstance(x,int) else Range(*x), subscripts))
self._symbolic_set = ProductSet(*ranges)
def test_NormalGamma():
ng = NormalGamma('G', 1, 2, 3, 4)
assert density(ng)(1, 1) == 32 * exp(-4) / sqrt(pi)
assert ng.pspace.distribution.set == ProductSet(S.Reals, Interval(0, oo))
raises(ValueError, lambda: NormalGamma('G', 1, 2, 3, -1))
assert marginal_distribution(ng, 0)(1) == \
3*sqrt(10)*gamma(Rational(7, 4))/(10*sqrt(pi)*gamma(Rational(5, 4)))
assert marginal_distribution(ng, y)(1) == exp(Rational(-1, 4)) / 128
assert marginal_distribution(ng, [0, 1])(x) == x**2 * exp(-x / 4) / 128
def test_MultivariateTDist():
t1 = MultivariateT('T', [0, 0], [[1, 0], [0, 1]], 2)
assert(density(t1))(1, 1) == 1/(8*pi)
assert t1.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
assert integrate(density(t1)(x, y), (x, -oo, oo), \
(y, -oo, oo)).evalf() == 1
raises(ValueError, lambda: MultivariateT('T', [1, 2], [[1, 1], [1, -1]], 1))
t2 = MultivariateT('t2', [1, 2], [[x, 0], [0, y]], 1)
assert density(t2)(1, 2) == 1/(2*pi*sqrt(x*y))
def test_multivariate_laplace():
raises(ValueError, lambda: Laplace('T', [1, 2], [[1, 2], [2, 1]]))
L = Laplace('L', [1, 0], [[1, 0], [0, 1]])
L2 = MultivariateLaplace('L2', [1, 0], [[1, 0], [0, 1]])
assert density(L)(2, 3) == exp(2) * besselk(0, sqrt(39)) / pi
L1 = Laplace('L1', [1, 2], [[x, 0], [0, y]])
assert density(L1)(0, 1) == \
exp(2/y)*besselk(0, sqrt((2 + 4/y + 1/x)/y))/(pi*sqrt(x*y))
assert L.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
assert L.pspace.distribution == L2.pspace.distribution
def test_MultivariateBeta():
a1, a2 = symbols('a1, a2', positive=True)
a1_f, a2_f = symbols('a1, a2', positive=False, real=True)
mb = MultivariateBeta('B', [a1, a2])
mb_c = MultivariateBeta('C', a1, a2)
assert density(mb)(1, 2) == S(2)**(a2 - 1)*gamma(a1 + a2)/\
(gamma(a1)*gamma(a2))
assert marginal_distribution(mb_c, 0)(3) == S(3)**(a1 - 1)*gamma(a1 + a2)/\
(a2*gamma(a1)*gamma(a2))
raises(ValueError, lambda: MultivariateBeta('b1', [a1_f, a2]))
raises(ValueError, lambda: MultivariateBeta('b2', [a1, a2_f]))
raises(ValueError, lambda: MultivariateBeta('b3', [0, 0]))
raises(ValueError, lambda: MultivariateBeta('b4', [a1_f, a2_f]))
assert mb.pspace.distribution.set == ProductSet(Interval(0, 1), Interval(0, 1))
def __init__(self, _Symbols, _Domains):
if type(_Symbols) is not list:
raise TypeError("Symbols must be a list of sympy symbols")
if type(_Domains) is not list:
raise TypeError("Domains must be a list of sympy domains")
if len(_Symbols) != len(_Domains):
raise TypeError("Symbols and Domains must have same length")
#specify the type of the symbols
self.is_continuous = False
self.is_mixed = False
self.is_discrete = False
#specify different stages of model building (compiling)
self.is_built = False
self.is_AVS = None
self.is_Coherent = None
self.Symbols = _Symbols
self._Domains = _Domains
self._TypeSymbols = [] #list that includes symbol type (c,d)
for el in _Domains:
if el.is_FiniteSet == True:
self._TypeSymbols.append('d') #discrete
if el.is_Interval == True:
self._TypeSymbols.append('c') #continuous
ind = np.argsort(self._TypeSymbols)
self._TypeSymbols = list(np.array(self._TypeSymbols)[ind])
self.Symbols = list(np.array(self.Symbols)[ind])
self._Domains = list(np.array(self._Domains)[ind])
self.Domain = ProductSet(self._Domains) #cartesian product
if ('c' in self._TypeSymbols and 'd' not in self._TypeSymbols):
self.is_continuous = True
elif ('c' not in self._TypeSymbols and 'd' in self._TypeSymbols):
self.is_discrete = True
else:
self.is_mixed = True
ind, = np.where(np.array(self._TypeSymbols) == 'c')
self.last_continuous = ind[-1] #index of last continuous symbol
self.Gambles = [] #list of gambles
self.SupportingPoints = [] #Supporting points for smart discretisation
self.DiscretePowerSet = [] #power set of domain of discrete variables
self.lambda_bounds = [
] #bounds for lambda_i in LP, this is used to make bounds in the LP problem
self.type_relation = [
] #type of relation: '>=' inequality or '==' equality
self.Lambda = [] #vector of the lambdas (solutions of the LP problem)
def test_NegativeMultinomial():
k0, x1, x2, x3, x4 = symbols('k0, x1, x2, x3, x4', nonnegative=True, integer=True)
p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True)
p1_f = symbols('p1_f', negative=True)
N = NegativeMultinomial('N', 4, [p1, p2, p3, p4])
C = NegativeMultinomial('C', 4, 0.1, 0.2, 0.3)
g = gamma
f = factorial
assert simplify(density(N)(x1, x2, x3, x4) -
p1**x1*p2**x2*p3**x3*p4**x4*(-p1 - p2 - p3 - p4 + 1)**4*g(x1 + x2 +
x3 + x4 + 4)/(6*f(x1)*f(x2)*f(x3)*f(x4))) is S.Zero
assert comp(marginal_distribution(C, C[0])(1).evalf(), 0.33, .01)
raises(ValueError, lambda: NegativeMultinomial('b1', 5, [p1, p2, p3, p1_f]))
raises(ValueError, lambda: NegativeMultinomial('b2', k0, 0.5, 0.4, 0.3, 0.4))
assert N.pspace.distribution.set == ProductSet(Range(0, oo, 1),
Range(0, oo, 1), Range(0, oo, 1), Range(0, oo, 1))
def make_SupportingPoints(self, n, criterion='centermaximin'):
'''
makes discretisation points for continuous and discrete vars using design of experiment strategy + exahustive on discrete vars
'''
if self.is_discrete == True:
T = self.__make_DiscretePoints(self.Domain)
elif self.is_continuous == True:
T = self.__make_ContinuousPoints(len(self.Symbols), n, criterion)
elif self.is_mixed == True:
Tc = self.__make_ContinuousPoints(self.last_continuous + 1, n,
criterion)
discretedomain = ProductSet(self._Domains[self.last_continuous +
1:])
Td = self.__make_DiscretePoints(discretedomain)
self.DiscretePowerSet = Td
T = []
for i in range(0, len(Tc)):
for j in range(0, len(Td)):
T.append(Tc[i] + Td[j])
#T = np.unique(T,axis=0) #initial discretisation
return np.array(T)
def test_ProductSet_of_single_arg_is_arg():
assert ProductSet(Interval(0, 1)) == Interval(0, 1)
def set(self):
rvs = [i for i in self.args[1] if isinstance(i, RandomSymbol)]
return ProductSet(*[rv.pspace.set for rv in rvs])
def intersection_sets(a, b):
if len(b.args) != len(a.args):
return S.EmptySet
return ProductSet(*(i.intersect(j) for i, j in zip(a.sets, b.sets)))
Run this cell before any other Declare any other sets here if you'd like """ from sympy import FiniteSet, ProductSet from sympy.sets.powerset import PowerSet """Finite Sets: represents a finite set of discrete numbers""" A = FiniteSet(1, 2, 3, 4, 5) B = FiniteSet(5, 6, 7, 8, 9) C = FiniteSet(9, 10, 11, 12) #%% """Powersets: all possible sets in a set""" E = A.powerset() # Returns a new finite set with a finite set F = PowerSet(A).rewrite(FiniteSet) # Returns a setwith many finite sets print(F) #%% """Cartesian product: """ cp_m1 = ProductSet(A, B) # Uses sympy function cp_m2 = A*B # Sympy syntax for finite sets print()
def test_Normal():
m = Normal('A', [1, 2], [[1, 0], [0, 1]])
A = MultivariateNormal('A', [1, 2], [[1, 0], [0, 1]])
assert m == A
assert density(m)(1, 2) == 1 / (2 * pi)
assert m.pspace.distribution.set == ProductSet(S.Reals, S.Reals)
raises(ValueError, lambda: m[2])
n = Normal('B', [1, 2, 3], [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
p = Normal('C', Matrix([1, 2]), Matrix([[1, 0], [0, 1]]))
assert density(m)(x, y) == density(p)(x, y)
assert marginal_distribution(n, 0, 1)(1, 2) == 1 / (2 * pi)
raises(ValueError, lambda: marginal_distribution(m))
assert integrate(density(m)(x, y), (x, -oo, oo), (y, -oo, oo)).evalf() == 1
N = Normal('N', [1, 2], [[x, 0], [0, y]])
assert density(N)(0, 0) == exp(-((4 * x + y) /
(2 * x * y))) / (2 * pi * sqrt(x * y))
raises(ValueError, lambda: Normal('M', [1, 2], [[1, 1], [1, -1]]))
# symbolic
n = symbols('n', natural=True)
mu = MatrixSymbol('mu', n, 1)
sigma = MatrixSymbol('sigma', n, n)
X = Normal('X', mu, sigma)
assert density(X) == MultivariateNormalDistribution(mu, sigma)
raises(NotImplementedError, lambda: median(m))
# Below tests should work after issue #17267 is resolved
# assert E(X) == mu
# assert variance(X) == sigma
# test symbolic multivariate normal densities
n = 3
Sg = MatrixSymbol('Sg', n, n)
mu = MatrixSymbol('mu', n, 1)
obs = MatrixSymbol('obs', n, 1)
X = MultivariateNormal('X', mu, Sg)
density_X = density(X)
eval_a = density_X(obs).subs({
Sg: eye(3),
mu: Matrix([0, 0, 0]),
obs: Matrix([0, 0, 0])
}).doit()
eval_b = density_X(0, 0, 0).subs({
Sg: eye(3),
mu: Matrix([0, 0, 0])
}).doit()
assert eval_a == sqrt(2) / (4 * pi**Rational(3 / 2))
assert eval_b == sqrt(2) / (4 * pi**Rational(3 / 2))
n = symbols('n', natural=True)
Sg = MatrixSymbol('Sg', n, n)
mu = MatrixSymbol('mu', n, 1)
obs = MatrixSymbol('obs', n, 1)
X = MultivariateNormal('X', mu, Sg)
density_X_at_obs = density(X)(obs)
expected_density = MatrixElement(
exp((S(1)/2) * (mu.T - obs.T) * Sg**(-1) * (-mu + obs)) / \
sqrt((2*pi)**n * Determinant(Sg)), 0, 0)
assert density_X_at_obs == expected_density
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_ProductSet_is_empty():
assert ProductSet(S.Integers, S.Reals).is_empty == False
assert ProductSet(Interval(x, 1), S.Reals).is_empty == None
from sympy import FiniteSet, Intersection, Interval, ProductSet, Union
init_printing(use_unicode=False, wrap_line=False, no_global=True)
Union(Interval(1, 10), Interval(10, 30))
Union(Interval(5, 15), Interval(15, 25))
Union(FiniteSet(1, 2, 3, 4), FiniteSet(10, 15, 30, 7))
Intersection(Interval(1, 3), Interval(2, 4))
Interval(1, 3).intersect(Interval(2, 4))
Intersection(FiniteSet(1, 2, 3, 4), FiniteSet(1, 3, 4, 7))
FiniteSet(1, 2, 3, 4).intersect(FiniteSet(1, 3, 4, 7))
I = Interval(0, 5)
S = FiniteSet(1, 2, 3)
ProductSet(I, S)
(2, 2) in ProductSet(I, S)
Interval(0, 1) * Interval(0, 1)
coin = FiniteSet('H', 'T')
set(coin**2)
Complement(FiniteSet(0, 1, 2, 3, 4, 5), FiniteSet(1, 2))