def test_naturals():
N = S.Naturals
assert 5 in N
assert -5 not in N
assert 5.5 not in N
ni = iter(N)
a, b, c, d = ni.next(), ni.next(), ni.next(), ni.next()
assert (a, b, c, d) == (1, 2, 3, 4)
assert isinstance(a, Basic)
assert N.intersect(Interval(-5, 5)) == FiniteSet(1, 2, 3, 4, 5)
assert N.intersect(Interval(-5, 5, True, True)) == FiniteSet(1, 2, 3, 4)
assert N.inf == 1
assert N.sup == oo
def test_integers():
Z = S.Integers
assert 5 in Z
assert -5 in Z
assert 5.5 not in Z
zi = iter(Z)
a, b, c, d = zi.next(), zi.next(), zi.next(), zi.next()
assert (a, b, c, d) == (0, 1, -1, 2)
assert isinstance(a, Basic)
assert Z.intersect(Interval(-5, 5)) == FiniteSet(range(-5, 6))
assert Z.intersect(Interval(-5, 5, True, True)) == FiniteSet(range(-4, 5))
assert Z.inf == -oo
assert Z.sup == oo
def __new__(cls):
from sympy.core.sets import FiniteSet
x = C.Dummy('x')
#construct "by hand" to avoid infinite loop
obj = Expr.__new__(cls, Tuple(x), x)
obj.nargs = FiniteSet(1)
return obj
def __new__(cls, *domains):
symbols = sumsets([domain.symbols for domain in domains])
# Flatten any product of products
domains2 = []
for domain in domains:
if not domain.is_ProductDomain:
domains2.append(domain)
else:
domains2.extend(domain.domains)
domains2 = FiniteSet(domains2)
sym_domain_dict = {}
for domain in domains2:
for symbol in domain.symbols:
sym_domain_dict[symbol] = domain
if all(domain.is_Finite for domain in domains2):
from sympy.stats.frv import ProductFiniteDomain
cls = ProductFiniteDomain
if all(domain.is_Continuous for domain in domains2):
from sympy.stats.crv import ProductContinuousDomain
cls = ProductContinuousDomain
obj = RandomDomain.__new__(cls, symbols, domains2)
obj.sym_domain_dict = sym_domain_dict
return obj
def test_Lambda():
e = Lambda(x, x**2)
assert e(4) == 16
assert e(x) == x**2
assert e(y) == y**2
assert Lambda(x, x**2) == Lambda(x, x**2)
assert Lambda(x, x**2) == Lambda(y, y**2)
assert Lambda(x, x**2) != Lambda(y, y**2 + 1)
assert Lambda((x, y), x**y) == Lambda((y, x), y**x)
assert Lambda((x, y), x**y) != Lambda((x, y), y**x)
assert Lambda((x, y), x**y)(x, y) == x**y
assert Lambda((x, y), x**y)(3, 3) == 3**3
assert Lambda((x, y), x**y)(x, 3) == x**3
assert Lambda((x, y), x**y)(3, y) == 3**y
assert Lambda(x, f(x))(x) == f(x)
assert Lambda(x, x**2)(e(x)) == x**4
assert e(e(x)) == x**4
assert Lambda((x, y), x + y).nargs == FiniteSet(2)
p = x, y, z, t
assert Lambda(p, t * (x + y + z))(*p) == t * (x + y + z)
assert Lambda(x, 2 * x) + Lambda(y, 2 * y) == 2 * Lambda(x, 2 * x)
assert Lambda(x, 2 * x) not in [Lambda(x, x)]
raises(ValueError, lambda: Lambda(1, x))
assert Lambda(x, 1)(1) is S.One
def set(self):
if self.fulldomain.__class__ is SingleFiniteDomain:
return FiniteSet(elem for elem in self.fulldomain.set
if frozenset(((self.fulldomain.symbol, elem),)) in self)
else:
raise NotImplementedError(
"Not implemented on multi-dimensional conditional domain")
def test_Function():
class myfunc(Function):
@classmethod
def eval(cls, x):
return
assert myfunc.nargs == FiniteSet(1)
assert myfunc(x).nargs == FiniteSet(1)
raises(TypeError, lambda: myfunc(x, y).nargs)
class myfunc(Function):
@classmethod
def eval(cls, *x):
return
assert myfunc.nargs == S.Naturals0
assert myfunc(x).nargs == S.Naturals0
def test_TransformationSet():
squares = TransformationSet(Lambda(x, x**2), S.Naturals)
assert 4 in squares
assert 5 not in squares
assert FiniteSet(range(10)).intersect(squares) == FiniteSet(1, 4, 9)
assert 16 not in squares.intersect(Interval(0, 10))
si = iter(squares)
a, b, c, d = next(si), next(si), next(si), next(si)
assert (a, b, c, d) == (1, 4, 9, 16)
harmonics = TransformationSet(Lambda(x, 1 / x), S.Naturals)
assert Rational(1, 5) in harmonics
assert .25 in harmonics
assert .3 not in harmonics
assert harmonics.is_iterable
def test_range_interval_intersection():
# Intersection with intervals
assert FiniteSet(Range(0, 10, 1).intersect(Interval(2, 6))) == \
FiniteSet(2, 3, 4, 5, 6)
# Open Intervals are removed
assert (FiniteSet(Range(0, 10, 1).intersect(Interval(2, 6, True, True)))
== FiniteSet(3, 4, 5))
# Try this with large steps
assert (FiniteSet(Range(0, 100, 10).intersect(Interval(15, 55))) ==
FiniteSet(20, 30, 40, 50))
# Going backwards
assert FiniteSet(Range(10, -9, -3).intersect(Interval(-5, 6))) == \
FiniteSet(-5, -2, 1, 4)
assert FiniteSet(Range(10, -9, -3).intersect(Interval(-5, 6, True))) == \
FiniteSet(-2, 1, 4)
def test_univariate_relational_as_set():
assert (x > 0).as_set() == Interval(0, oo, True, True)
assert (x >= 0).as_set() == Interval(0, oo)
assert (x < 0).as_set() == Interval(-oo, 0, True, True)
assert (x <= 0).as_set() == Interval(-oo, 0)
assert Eq(x, 0).as_set() == FiniteSet(0)
assert Ne(x, 0).as_set() == Interval(-oo, 0, True, True) + \
Interval(0, oo, True, True)
assert (x**2 >= 4).as_set() == Interval(-oo, -2) + Interval(2, oo)
def __new__(cls, *spaces):
rs_space_dict = {}
for space in spaces:
for value in space.values:
rs_space_dict[value] = space
symbols = FiniteSet(val.symbol for val in rs_space_dict.keys())
# Overlapping symbols
if len(symbols) < sum(len(space.symbols) for space in spaces):
raise ValueError("Overlapping Random Variables")
if all(space.is_Finite for space in spaces):
from sympy.stats.frv import ProductFinitePSpace
cls = ProductFinitePSpace
if all(space.is_Continuous for space in spaces):
from sympy.stats.crv import ProductContinuousPSpace
cls = ProductContinuousPSpace
obj = Basic.__new__(cls, *FiniteSet(*spaces))
return obj
def test_nargs():
f = Function('f')
assert f.nargs == S.Naturals0
assert f(1).nargs == S.Naturals0
assert Function('f', nargs=2)(1, 2).nargs == FiniteSet(2)
assert sin.nargs == FiniteSet(1)
assert sin(2).nargs == FiniteSet(1)
assert log.nargs == FiniteSet(1, 2)
assert log(2).nargs == FiniteSet(1, 2)
assert Function('f', nargs=2).nargs == FiniteSet(2)
assert Function('f', nargs=0).nargs == FiniteSet(0)
def solve_univariate_inequality(expr, gen, assume=True, relational=True):
"""Solves a real univariate inequality.
Examples
========
>>> from sympy.solvers.inequalities import solve_univariate_inequality
>>> from sympy.core.symbol import Symbol
>>> x = Symbol('x', real=True)
>>> solve_univariate_inequality(x**2 >= 4, x)
Or(x <= -2, x >= 2)
>>> solve_univariate_inequality(x**2 >= 4, x, relational=False)
(-oo, -2] U [2, oo)
"""
# Implementation for continous functions
from sympy.solvers.solvers import solve
solns = solve(expr.lhs - expr.rhs, gen, assume=assume)
oo = S.Infinity
start = -oo
sol_sets = [S.EmptySet]
for x in sorted(s for s in solns if s.is_real):
end = x
if expr.subs(gen, (start + end) / 2 if start != -oo else end - 1):
sol_sets.append(Interval(start, end, True, True))
if expr.subs(gen, x):
sol_sets.append(FiniteSet(x))
start = end
end = oo
if expr.subs(gen, start + 1):
sol_sets.append(Interval(start, end, True, True))
rv = Union(*sol_sets)
return rv if not relational else rv.as_relational(gen)
def __new__(cls, *domains):
symbols = sumsets([domain.symbols for domain in domains])
# Flatten any product of products
domains2 = []
for domain in domains:
if not domain.is_ProductDomain:
domains2.append(domain)
else:
domains2.extend(domain.domains)
domains2 = FiniteSet(domains2)
if all(domain.is_Finite for domain in domains2):
from sympy.stats.frv import ProductFiniteDomain
cls = ProductFiniteDomain
if all(domain.is_Continuous for domain in domains2):
from sympy.stats.crv import ProductContinuousDomain
cls = ProductContinuousDomain
return Basic.__new__(cls, *domains2)
def spaces(self):
return FiniteSet(*self.args)
def symbols(self):
return FiniteSet(val.symbol for val in self.rs_space_dict.keys())
def __new__(cls, symbol, set):
assert symbol.is_Symbol
symbols = FiniteSet(symbol)
return RandomDomain.__new__(cls, symbols, set)
def _intersect(self, other):
if other.is_Interval:
s = FiniteSet(range(ceiling(other.left), floor(other.right) + 1))
return s.intersect(other) # take out endpoints if open interval
return None
def elements(self):
return FiniteSet(iter(self))
def elements(self):
return FiniteSet(
frozenset(((self.symbol, elem), )) for elem in self.set)
def _intersect(self, other):
if other.is_Interval:
s = FiniteSet(range(ceiling(other.left), floor(other.right) + 1))
return s.intersect(other) # take out endpoints if open interval
return None
def symbols(self):
return FiniteSet(sym for sym, val in self.elements)
def symbols(self):
return FiniteSet(self.symbol)
def symbols(self):
return FiniteSet(sym for domain in self.domains
for sym in domain.symbols)
def __new__(cls, symbol, set):
if not isinstance(set, FiniteSet):
set = FiniteSet(*set)
return Basic.__new__(cls, symbol, set)
def __new__(cls, symbols, *args):
symbols = FiniteSet(*symbols)
return Basic.__new__(cls, symbols, *args)
def __new__(cls, elements):
elements = FiniteSet(*elements)
symbols = FiniteSet(sym for sym, val in elements)
return RandomDomain.__new__(cls, symbols, elements)
def test_fun():
assert (FiniteSet(
TransformationSet(Lambda(x, sin(pi * x / 4)),
Range(-10,
11))) == FiniteSet(-1, -sqrt(2) / 2, 0,
sqrt(2) / 2, 1))
def dict(self):
return FiniteSet(Dict(dict(el)) for el in self.elements)
def test_sympy__core__sets__FiniteSet():
from sympy.core.sets import FiniteSet
assert _test_args(FiniteSet(x, y, z))
def __new__(cls, symbol, set):
return RandomDomain.__new__(cls, (symbol, ), FiniteSet(*set))