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)]
pytest.raises(TypeError, lambda: Lambda(1, x))
assert Lambda(x, 1)(1) is Integer(1)
assert (2 * x).canonical_variables == {}
assert Lambda(x, 2 * x).canonical_variables == {x: Symbol('0_')}
x_ = Symbol('x_')
assert Lambda(x_, 2 * x_).canonical_variables == {x_: Symbol('0__')}
def test_imageset_intersect_real():
assert (imageset(Lambda(n, n + (n - 1)*(n + 1)*I),
S.Integers).intersect(S.Reals) ==
FiniteSet(-1, 1))
s = ImageSet(Lambda(n, -I*(I*(2*pi*n - pi/4) + log(Abs(sqrt(-I))))), S.Integers)
assert s.intersect(S.Reals) == imageset(Lambda(n, 2*n*pi - pi/4), S.Integers)
def test_Function():
class myfunc(Function):
@classmethod
def eval(cls, x): # one arg
return
assert myfunc.nargs == FiniteSet(1)
assert myfunc(x).nargs == FiniteSet(1)
pytest.raises(TypeError, lambda: myfunc(x, y).nargs)
class myfunc(Function):
@classmethod
def eval(cls, *x): # star args
return
assert myfunc.nargs == S.Naturals0
assert myfunc(x).nargs == S.Naturals0
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_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_ImageSet():
squares = ImageSet(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 = ImageSet(Lambda(x, 1/x), S.Naturals)
assert Rational(1, 5) in harmonics
assert Rational(.25) in harmonics
assert 0.25 not in harmonics
assert Rational(.3) not in harmonics
assert harmonics.is_iterable
def _intersect(self, other):
from diofant import Dummy
from diofant.solvers.diophantine import diophantine
from diofant.sets.sets import imageset
if self.base_set is S.Integers:
if isinstance(other, ImageSet) and other.base_set is S.Integers:
f, g = self.lamda.expr, other.lamda.expr
n, m = self.lamda.variables[0], other.lamda.variables[0]
# Diophantine sorts the solutions according to the alphabetic
# order of the variable names, since the result should not depend
# on the variable name, they are replaced by the dummy variables
# below
a, b = Dummy('a'), Dummy('b')
f, g = f.subs(n, a), g.subs(m, b)
solns_set = diophantine(f - g)
if solns_set == set():
return EmptySet()
solns = list(diophantine(f - g))
if len(solns) == 1:
t = list(solns[0][0].free_symbols)[0]
else:
return
# since 'a' < 'b'
return imageset(Lambda(t, f.subs(a, solns[0][0])), S.Integers)
if other == S.Reals:
from diofant.solvers.diophantine import diophantine
from diofant.core.function import expand_complex
if len(self.lamda.variables
) > 1 or self.base_set is not S.Integers:
return
f = self.lamda.expr
n = self.lamda.variables[0]
n_ = Dummy(n.name, integer=True)
f_ = f.subs(n, n_)
re, im = f_.as_real_imag()
im = expand_complex(im)
sols = list(diophantine(im, n_))
if not sols:
return S.EmptySet
elif all(s[0].has(n_) is False for s in sols):
s = FiniteSet(*[s[0] for s in sols])
elif len(sols) == 1 and sols[0][0].has(n_):
s = imageset(Lambda(n_, sols[0][0]), S.Integers)
else:
return
return imageset(Lambda(n_, re), self.base_set.intersect(s))
def test_univariate_relational_as_set():
assert (x > 0).as_set() == Interval(0, oo, True, True)
assert (x >= 0).as_set() == Interval(0, oo, False, True)
assert (x < 0).as_set() == Interval(-oo, 0, True, True)
assert (x <= 0).as_set() == Interval(-oo, 0, True)
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, True) +
Interval(2, oo, False, True))
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)
assert Function('f', nargs=(0, 1)).nargs == FiniteSet(0, 1)
assert Function('f', nargs=None).nargs == S.Naturals0
pytest.raises(ValueError, lambda: Function('f', nargs=()))
p = Function('g', nargs=(1, 2))(1)
assert p.args == (1, ) and p.nargs == FiniteSet(1, 2)
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 diofant.stats.frv import ProductFinitePSpace
cls = ProductFinitePSpace
if all(space.is_Continuous for space in spaces):
from diofant.stats.crv import ProductContinuousPSpace
cls = ProductContinuousPSpace
obj = Basic.__new__(cls, *FiniteSet(*spaces))
return obj
def __new__(cls, *partition):
"""
Generates a new partition object.
This method also verifies if the arguments passed are
valid and raises a ValueError if they are not.
Examples
========
>>> from diofant.combinatorics.partitions import Partition
>>> a = Partition([1, 2], [3])
>>> a
{{3}, {1, 2}}
>>> a.partition
[[1, 2], [3]]
>>> len(a)
2
>>> a.members
(1, 2, 3)
"""
args = partition
if not all(isinstance(part, (list, FiniteSet)) for part in args):
raise ValueError(
"Each argument to Partition should be a list or a FiniteSet")
# sort so we have a canonical reference for RGS
partition = sorted(sum(list(map(list, partition)), []),
key=default_sort_key)
if has_dups(partition):
raise ValueError("Partition contained duplicated elements.")
obj = FiniteSet.__new__(cls, *[FiniteSet(*x) for x in args])
obj.members = tuple(partition)
obj.size = len(partition)
return obj
def test_sympyissue_11732():
interval12 = Interval(1, 2)
finiteset1234 = FiniteSet(1, 2, 3, 4)
pointComplex = (1, 2)
assert (interval12 in S.Naturals) is False
assert (interval12 in S.Naturals0) is False
assert (interval12 in S.Integers) is False
assert (finiteset1234 in S.Naturals) is False
assert (finiteset1234 in S.Naturals0) is False
assert (finiteset1234 in S.Integers) is False
assert (pointComplex in S.Naturals) is False
assert (pointComplex in S.Naturals0) is False
assert (pointComplex in S.Integers) is False
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 diofant.stats.frv import ProductFiniteDomain
cls = ProductFiniteDomain
if all(domain.is_Continuous for domain in domains2):
from diofant.stats.crv import ProductContinuousDomain
cls = ProductContinuousDomain
return Basic.__new__(cls, *domains2)
def elements(self):
return FiniteSet(*self)
def test_fun():
assert (FiniteSet(*ImageSet(Lambda(x, sin(pi*x/4)), Range(-10, 11))) ==
FiniteSet(-1, -sqrt(2)/2, 0, sqrt(2)/2, 1))
def symbols(self):
return FiniteSet(*[val.symbol for val in self.rs_space_dict.keys()])
def solve_univariate_inequality(expr, gen, relational=True):
"""
Solves a real univariate inequality.
Examples
========
>>> from diofant.solvers.inequalities import solve_univariate_inequality
>>> from diofant.core.symbol import Symbol
>>> x = Symbol('x', real=True)
>>> solve_univariate_inequality(x**2 >= 4, x)
Or(2 <= x, x <= -2)
>>> solve_univariate_inequality(x**2 >= 4, x, relational=False)
(-oo, -2] U [2, oo)
"""
from diofant.simplify.simplify import simplify
from diofant.solvers.solvers import solve, denoms
e = expr.lhs - expr.rhs
parts = n, d = e.as_numer_denom()
if all(i.is_polynomial(gen) for i in parts):
solns = solve(n, gen, check=False)
singularities = solve(d, gen, check=False)
else:
solns = solve(e, gen, check=False)
singularities = []
for d in denoms(e):
singularities.extend(solve(d, gen))
include_x = expr.func(0, 0)
def valid(x):
v = e.subs(gen, x)
try:
r = expr.func(v, 0)
except TypeError:
r = S.false
r = simplify(r)
if r in (S.true, S.false):
return r
if v.is_extended_real is False:
return S.false
else:
if v.is_comparable:
v = v.n(2)
if v._prec > 1:
return expr.func(v, 0)
elif v.is_comparable is False:
return False
raise NotImplementedError
start = S.NegativeInfinity
sol_sets = [S.EmptySet]
try:
reals = _nsort(set(solns + singularities), separated=True)[0]
except NotImplementedError:
raise NotImplementedError('sorting of these roots is not supported')
for x in reals:
end = x
if end in [S.NegativeInfinity, S.Infinity]:
if valid(Integer(0)):
sol_sets.append(Interval(start, S.Infinity, True, True))
break
if valid((start + end) / 2 if start != S.NegativeInfinity else end -
1):
sol_sets.append(Interval(start, end, True, True))
if x in singularities:
singularities.remove(x)
elif include_x:
sol_sets.append(FiniteSet(x))
start = end
end = S.Infinity
if valid(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 elements(self):
return FiniteSet(
*[frozenset(((self.symbol, elem), )) for elem in self.set])
def symbols(self):
return FiniteSet(self.symbol)
def __new__(cls, symbol, set):
if not isinstance(set, FiniteSet):
set = FiniteSet(*set)
return Basic.__new__(cls, symbol, set)
def dict(self):
return FiniteSet(*[Dict(dict(el)) for el in self.elements])
def symbols(self):
return FiniteSet(sym for sym, val in self.elements)
def spaces(self):
return FiniteSet(*self.args)
def symbols(self):
return FiniteSet(*[sym for domain in self.domains
for sym in domain.symbols])
def __new__(cls, symbols, *args):
symbols = FiniteSet(*symbols)
return Basic.__new__(cls, symbols, *args)