def prove(Eq):
i = Symbol.i(integer=True)
j = Symbol.j(integer=True)
n = Symbol.n(domain=Interval(2, oo, integer=True))
x = Symbol.x(shape=(oo, ), dtype=dtype.integer, finite=True)
j_domain = Interval(0, n - 1, integer=True) - {i}
given = ForAll[j:j_domain, i:n](Equality(x[i] & x[j], EmptySet()))
Eq << apply(given)
y = Symbol.y(shape=(oo, ),
dtype=dtype.integer,
definition=LAMBDA[i](Piecewise((x[i], i < n),
(EmptySet(), True))))
Eq.y_definition = y.equality_defined()
Eq.yi_definition = Eq.y_definition.forall((i, 0, n - 1))
Eq << Eq.yi_definition.reversed
Eq << Eq[0].subs(Eq[-1]).subs(Eq[-1].limits_subs(i, j))
Eq << Eq.y_definition.forall((i, n, oo))
Eq << Eq[-1].intersect(y[j]).forall((j, j_domain))
Eq << (Eq[-1] & Eq[-3])
Eq << sets.forall_equality.imply.equality.nonoverlapping_utility.apply(
Eq[-1])
Eq << Eq[-1].subs(Eq.yi_definition)
def test_stationary_points():
x, y = symbols('x y')
assert stationary_points(sin(x), x, Interval(-pi/2, pi/2)
) == {-pi/2, pi/2}
assert stationary_points(sin(x), x, Interval.Ropen(0, pi/4)
) == EmptySet()
assert stationary_points(tan(x), x,
) == EmptySet()
assert stationary_points(sin(x)*cos(x), x, Interval(0, pi)
) == {pi/4, pi*Rational(3, 4)}
assert stationary_points(sec(x), x, Interval(0, pi)
) == {0, pi}
assert stationary_points((x+3)*(x-2), x
) == FiniteSet(Rational(-1, 2))
assert stationary_points((x + 3)/(x - 2), x, Interval(-5, 5)
) == EmptySet()
assert stationary_points((x**2+3)/(x-2), x
) == {2 - sqrt(7), 2 + sqrt(7)}
assert stationary_points((x**2+3)/(x-2), x, Interval(0, 5)
) == {2 + sqrt(7)}
assert stationary_points(x**4 + x**3 - 5*x**2, x, S.Reals
) == FiniteSet(-2, 0, Rational(5, 4))
assert stationary_points(exp(x), x
) == EmptySet()
assert stationary_points(log(x) - x, x, S.Reals
) == {1}
assert stationary_points(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
) == {0, -pi, pi}
assert stationary_points(y, x, S.Reals
) == S.Reals
assert stationary_points(y, x, S.EmptySet) == S.EmptySet
def test_ComplexPlane_intersect():
# Polar form
X_axis = ComplexPlane(Interval(0, oo) * FiniteSet(0, S.Pi), polar=True)
unit_disk = ComplexPlane(Interval(0, 1) * Interval(0, 2 * S.Pi),
polar=True)
upper_half_unit_disk = ComplexPlane(Interval(0, 1) * Interval(0, S.Pi),
polar=True)
upper_half_disk = ComplexPlane(Interval(0, oo) * Interval(0, S.Pi),
polar=True)
lower_half_disk = ComplexPlane(Interval(0, oo) * Interval(S.Pi, 2 * S.Pi),
polar=True)
right_half_disk = ComplexPlane(Interval(0, oo) *
Interval(-S.Pi / 2, S.Pi / 2),
polar=True)
first_quad_disk = ComplexPlane(Interval(0, oo) * Interval(0, S.Pi / 2),
polar=True)
assert upper_half_disk.intersect(unit_disk) == upper_half_unit_disk
assert right_half_disk.intersect(first_quad_disk) == first_quad_disk
assert upper_half_disk.intersect(right_half_disk) == first_quad_disk
assert upper_half_disk.intersect(lower_half_disk) == X_axis
c1 = ComplexPlane(Interval(0, 4) * Interval(0, 2 * S.Pi), polar=True)
assert c1.intersect(Interval(1, 5)) == Interval(1, 4)
assert c1.intersect(Interval(4, 9)) == FiniteSet(4)
assert c1.intersect(Interval(5, 12)) == EmptySet()
# Rectangular form
X_axis = ComplexPlane(Interval(-oo, oo) * FiniteSet(0))
unit_square = ComplexPlane(Interval(-1, 1) * Interval(-1, 1))
upper_half_unit_square = ComplexPlane(Interval(-1, 1) * Interval(0, 1))
upper_half_plane = ComplexPlane(Interval(-oo, oo) * Interval(0, oo))
lower_half_plane = ComplexPlane(Interval(-oo, oo) * Interval(-oo, 0))
right_half_plane = ComplexPlane(Interval(0, oo) * Interval(-oo, oo))
first_quad_plane = ComplexPlane(Interval(0, oo) * Interval(0, oo))
assert upper_half_plane.intersect(unit_square) == upper_half_unit_square
assert right_half_plane.intersect(first_quad_plane) == first_quad_plane
assert upper_half_plane.intersect(right_half_plane) == first_quad_plane
assert upper_half_plane.intersect(lower_half_plane) == X_axis
c1 = ComplexPlane(Interval(-5, 5) * Interval(-10, 10))
assert c1.intersect(Interval(2, 7)) == Interval(2, 5)
assert c1.intersect(Interval(5, 7)) == FiniteSet(5)
assert c1.intersect(Interval(6, 9)) == EmptySet()
# unevaluated object
C1 = ComplexPlane(Interval(0, 1) * Interval(0, 2 * S.Pi), polar=True)
C2 = ComplexPlane(Interval(-1, 1) * Interval(-1, 1))
assert C1.intersect(C2) == Intersection(C1, C2)
def test_infinitely_indexed_set_1():
from sympy.abc import n, m, t
assert imageset(Lambda(n, n), S.Integers) == imageset(Lambda(m, m), S.Integers)
assert imageset(Lambda(n, 2*n), S.Integers).intersect(imageset(Lambda(m, 2*m + 1), S.Integers)) == \
EmptySet()
assert imageset(Lambda(n, 2*n), S.Integers).intersect(imageset(Lambda(n, 2*n + 1), S.Integers)) == \
EmptySet()
assert imageset(Lambda(m, 2*m), S.Integers).intersect(imageset(Lambda(n, 3*n), S.Integers)) == \
ImageSet(Lambda(t, 6*t), S.Integers)
def apply(given):
assert isinstance(given, StrictGreaterThan)
A_abs, zero = given.args
assert A_abs.is_Abs and zero.is_zero
A = A_abs.arg
return Unequality(A, EmptySet(), given=given)
def apply(given):
assert given.is_Equality
assert given.lhs.is_Complement
A, B = given.lhs.args
assert given.rhs == A
return Equality(A & B, EmptySet(), given=given)
def apply(given):
assert isinstance(given, GreaterThan)
A_abs, positive = given.args
assert A_abs.is_Abs and positive.is_positive
A = A_abs.arg
return Unequality(A, EmptySet(), given=given)
def _intersect(self, other):
from sympy import Dummy
from sympy.solvers.diophantine import diophantine
from sympy.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 None
# since 'a' < 'b'
return imageset(Lambda(t, f.subs(a, solns[0][0])), S.Integers)
def prove(Eq):
A = Symbol.A(dtype=dtype.integer, given=True)
B = Symbol.B(dtype=dtype.integer, given=True)
Eq << apply(Equality(B - A, EmptySet()))
Eq << Eq[0].union(A).reversed
Eq << Eq[1].subs(Eq[-1])
def test_bool_as_set():
x = symbols('x')
assert And(x <= 2, x >= -2).as_set() == Interval(-2, 2)
assert Or(x >= 2, x <= -2).as_set() == Interval(-oo, -2) + Interval(2, oo)
assert Not(x > 2).as_set() == Interval(-oo, 2)
# issue 10240
assert Not(And(x > 2, x < 3)).as_set() == \
Union(Interval(-oo,2),Interval(3,oo))
assert true.as_set() == S.UniversalSet
assert false.as_set() == EmptySet()
def test_minima():
from sympy import Integers
x, y, n = symbols('x y n')
assert minima(sin(x), x) == ImageSet(Lambda(n, 2*pi*n + 3*pi/2), Integers)
assert minima(sin(x), x, Interval(0, 2*pi)) == {3*pi/2}
assert minima(sin(x)-x, x) == EmptySet()
assert minima(x - x**3, x, Interval(-1, 2)) == {-sqrt(3)/3}
assert minima(sin(x)**2, x, Interval(-pi/2, pi/2)) == {0}
assert minima(sin(x)*cos(x), x, Interval(0, 2*pi)) == {3*pi/4, 7*pi/4}
#assert minima((x+3)*(x-2), x) == {-1/2}
assert minima((x+3)/(x-2), x) == EmptySet()
assert minima(x**5-3*x**3+2*x**2+6, x) == {0, 1}
assert minima(exp(x), x) == EmptySet()
assert minima(log(x) - x, x) == EmptySet()
assert minima(y, x) == EmptySet()
raises(ValueError, lambda : maxima(sin(x), x, S.EmptySet))
raises(ValueError, lambda : maxima(log(cos(x)), x, S.EmptySet))
raises(ValueError, lambda : maxima(1/(x**2 + y**2 + 1), x, S.EmptySet))
raises(ValueError, lambda : maxima(sin(x), sin(x)))
raises(ValueError, lambda : maxima(sin(x), x*y, S.EmptySet))
raises(ValueError, lambda : maxima(sin(x), S(1)))
def as_set(self):
"""
Rewrite logic operators and relationals in terms of real sets.
Examples
========
>>> from sympy import false
>>> false.as_set()
EmptySet()
"""
from sympy.sets.sets import EmptySet
return EmptySet()
def test_bool_as_set():
assert ITE(y <= 0, False, y >= 1).as_set() == Interval(1, oo)
assert And(x <= 2, x >= -2).as_set() == Interval(-2, 2)
assert Or(x >= 2, x <= -2).as_set() == Interval(-oo, -2) + Interval(2, oo)
assert Not(x > 2).as_set() == Interval(-oo, 2)
# issue 10240
assert Not(And(x > 2, x < 3)).as_set() == \
Union(Interval(-oo, 2), Interval(3, oo))
assert true.as_set() == S.UniversalSet
assert false.as_set() == EmptySet()
assert x.as_set() == S.UniversalSet
assert And(Or(x < 1, x > 3), x < 2).as_set() == Interval.open(-oo, 1)
assert And(x < 1, sin(x) < 3).as_set() == (x < 1).as_set()
raises(NotImplementedError, lambda: (sin(x) < 1).as_set())
def _intersect(self, other):
from sympy.solvers.diophantine import diophantine
if self.base_set is S.Integers:
g = None
if isinstance(other, ImageSet) and other.base_set is S.Integers:
g = other.lamda.expr
m = other.lamda.variables[0]
elif other is S.Integers:
m = g = Dummy('x')
if g is not None:
f = self.lamda.expr
n = self.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:
return
# since 'a' < 'b', select soln for n
nsol = solns[0][0]
t = nsol.free_symbols.pop()
return imageset(Lambda(n, f.subs(a, nsol.subs(t, n))),
S.Integers)
if other == S.Reals:
from sympy.solvers.solveset import solveset_real
from sympy.core.function import expand_complex
if len(self.lamda.variables) > 1:
return None
f = self.lamda.expr
n = self.lamda.variables[0]
n_ = Dummy(n.name, real=True)
f_ = f.subs(n, n_)
re, im = f_.as_real_imag()
im = expand_complex(im)
return imageset(Lambda(n_, re),
self.base_set.intersect(solveset_real(im, n_)))
def codomain(func, domain, *syms):
""" Finds the range of a real-valued function, for a real-domain
Parameters
==========
func: Expr
The expression whose range is to be found
domain: Union of Sets
The real-domain for the variable involved in function
syms: Tuple of symbols
Symbol whose domain is given
Raises
======
NotImplementedError
The algorithms to find the range of the given function are
not yet implemented.
ValueError
The input is not valid.
RuntimeError
It is a bug, please report it to the github issue tracker
(https://github.com/sympy/sympy/issues).
Examples
========
>>> from sympy import Symbol, S, Interval, Union, FiniteSet, codomain
>>> x = Symbol('x', real=True)
>>> codomain(x**2, Interval(-1, 1), x)
[0, 1]
>>> codomain(x/(x**2 - 4), Union(Interval(-1, 3), FiniteSet(5)), x)
(-oo, 1/3] U [3/5, oo)
>>> codomain(x**2/(x**2 - 4), S.Reals, x)
(-oo, 0] U (1, oo)
"""
func = sympify(func)
if not isinstance(domain, Set):
raise ValueError('A Set must be given, not %s: %s' %
(type(domain), domain))
# TODO: handle piecewise defined functions
# TODO: handle transcendental functions
# TODO: handle multivariate functions
if len(syms) == 0:
raise ValueError("A Symbol or a tuple of symbols must be given")
if len(syms) == 1:
sym = syms[0]
else:
raise NotImplementedError("more than one variables %s not handled" %
(syms, ))
if not func.has(sym):
return FiniteSet(func)
# this block of code can be replaced by
# sing = Intersection(FiniteSet(*sing), domain.closure)
# after the issue #9706 has been fixed
def closure_handle(set_im, singul):
if set_im.has(Interval):
if not oo in set_im.boundary:
if not S.NegativeInfinity in set_im.boundary:
return Intersection(FiniteSet(*singul), set_im.closure)
return Intersection(
FiniteSet(*singul),
Union(set_im, FiniteSet(max(set_im.boundary))))
else:
if not S.NegativeInfinity in set_im.boundary:
return Intersection(
FiniteSet(*singul),
Union(set_im, FiniteSet(min(set_im.boundary))))
return Intersection(FiniteSet(*singul), set_im)
return Intersection(FiniteSet(*singul), set_im)
# all the singularities of the function
sing = solveset(func.as_numer_denom()[1], sym, domain=S.Reals)
sing_in_domain = closure_handle(domain, sing)
domain = Complement(domain, sing_in_domain)
if domain.is_EmptySet:
return EmptySet()
def codomain_interval(f, set_val, *sym):
symb = sym[0]
df1 = diff(f, symb)
df2 = diff(df1, symb)
der_zero = solveset(df1, symb, domain=S.Reals)
der_zero_in_dom = closure_handle(set_val, der_zero)
local_maxima = set()
local_minima = set()
start_val = limit(f, symb, set_val.start)
end_val = limit(f, symb, set_val.end, '-')
if start_val is S.Infinity or end_val is S.Infinity:
local_maxima = set([(oo, True)])
elif start_val is S.NegativeInfinity or end_val is S.NegativeInfinity:
local_minima = set([(-oo, True)])
if (not start_val.is_real) or (not end_val.is_real):
raise ValueError('Function does not contain all points of %s '
'as its domain' % (domain))
if local_maxima == set():
if start_val > end_val:
local_maxima = set([(start_val, set_val.left_open)])
elif start_val < end_val:
local_maxima = set([(end_val, set_val.right_open)])
else:
local_maxima = set([(start_val, set_val.left_open
and set_val.right_open)])
if local_minima == set():
if start_val < end_val:
local_minima = set([(start_val, set_val.left_open)])
elif start_val > end_val:
local_minima = set([(end_val, set_val.right_open)])
else:
local_minima = set([(start_val, set_val.left_open
and set_val.right_open)])
for i in der_zero_in_dom:
exist = not i in set_val
if df2.subs({symb: i}) < 0:
local_maxima.add((f.subs({symb: i}), exist))
elif df2.subs({symb: i}) > 0:
local_minima.add((f.subs({symb: i}), exist))
maximum = (-oo, True)
minimum = (oo, True)
for i in local_maxima:
if i[0] > maximum[0]:
maximum = i
elif i[0] == maximum[0]:
maximum = (maximum[0], i[1] and maximum[1])
for i in local_minima:
if i[0] < minimum[0]:
minimum = i
elif i[0] == minimum[0]:
minimum = (minimum[0], i[1] and minimum[1])
return Union(Interval(minimum[0], maximum[0], minimum[1], maximum[1]))
if isinstance(domain, Union):
return Union(*[
codomain(func, intrvl_or_finset, sym)
for intrvl_or_finset in domain.args
])
if isinstance(domain, Interval):
return codomain_interval(func, domain, sym)
if isinstance(domain, FiniteSet):
return FiniteSet(*[
limit(func, sym, i) if i in
FiniteSet(-oo, oo) else func.subs({sym: i}) for i in domain
])
def not_empty_in(finset_intersection, *syms):
""" Finds the domain of the functions in `finite_set` in which the
`finite_set` is not-empty
Parameters
==========
finset_intersection: The unevaluated intersection of FiniteSet containing
real-valued functions with Union of Sets
syms: Tuple of symbols
Symbol for which domain is to be found
Raises
======
NotImplementedError
The algorithms to find the non-emptiness of the given FiniteSet are
not yet implemented.
ValueError
The input is not valid.
RuntimeError
It is a bug, please report it to the github issue tracker
(https://github.com/sympy/sympy/issues).
Examples
========
>>> from sympy import FiniteSet, Interval, not_empty_in, oo
>>> from sympy.abc import x
>>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x)
Interval(0, 2)
>>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x)
Union(Interval(-sqrt(2), -1), Interval(1, 2))
>>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x)
Union(Interval(-2, -1, True), Interval(2, oo, False, True))
"""
# TODO: handle piecewise defined functions
# TODO: handle transcendental functions
# TODO: handle multivariate functions
if len(syms) == 0:
raise ValueError("One or more symbols must be given in syms.")
if finset_intersection.is_EmptySet:
return EmptySet()
if isinstance(finset_intersection, Union):
elm_in_sets = finset_intersection.args[0]
return Union(not_empty_in(finset_intersection.args[1], *syms),
elm_in_sets)
if isinstance(finset_intersection, FiniteSet):
finite_set = finset_intersection
_sets = S.Reals
else:
finite_set = finset_intersection.args[1]
_sets = finset_intersection.args[0]
if not isinstance(finite_set, FiniteSet):
raise ValueError('A FiniteSet must be given, not %s: %s' %
(type(finite_set), finite_set))
if len(syms) == 1:
symb = syms[0]
else:
raise NotImplementedError('more than one variables %s not handled' %
(syms,))
def elm_domain(expr, intrvl):
""" Finds the domain of an expression in any given interval """
from sympy.solvers.solveset import solveset
_start = intrvl.start
_end = intrvl.end
_singularities = solveset(expr.as_numer_denom()[1], symb,
domain=S.Reals)
if intrvl.right_open:
if _end is S.Infinity:
_domain1 = S.Reals
else:
_domain1 = solveset(expr < _end, symb, domain=S.Reals)
else:
_domain1 = solveset(expr <= _end, symb, domain=S.Reals)
if intrvl.left_open:
if _start is S.NegativeInfinity:
_domain2 = S.Reals
else:
_domain2 = solveset(expr > _start, symb, domain=S.Reals)
else:
_domain2 = solveset(expr >= _start, symb, domain=S.Reals)
# domain in the interval
expr_with_sing = Intersection(_domain1, _domain2)
expr_domain = Complement(expr_with_sing, _singularities)
return expr_domain
if isinstance(_sets, Interval):
return Union(*[elm_domain(element, _sets) for element in finite_set])
if isinstance(_sets, Union):
_domain = S.EmptySet
for intrvl in _sets.args:
_domain_element = Union(*[elm_domain(element, intrvl)
for element in finite_set])
_domain = Union(_domain, _domain_element)
return _domain
def prove(Eq):
n = Symbol.n(domain=[2, oo], integer=True)
x = Symbol.x(shape=(oo, ), integer=True)
k = Symbol.k(integer=True)
j = Symbol.j(domain=[0, n - 1], integer=True, given=True)
Eq << apply(
Equality(x[:n].set_comprehension(k), Interval(0, n - 1, integer=True)),
j)
Eq << Eq[1].lhs.this.definition
Eq <<= Eq[-3].subs(Eq[-1]), Eq[-2].subs(Eq[-1])
Eq << Eq[-1].lhs.indices[0].this.expand()
Eq << Eq[-1].rhs.function.args[1].this.as_Piecewise()
Eq << Eq[-2].this.rhs.subs(Eq[-1])
Eq << Eq[-1].rhs.subs(1, 0).this.bisect({0})
assert Eq[-1].lhs.limits[0][1].args[-1][-1].step.is_zero == False
Eq << Eq[-2].subs(Eq[-1].reversed)
assert Eq[-1].rhs.limits[0][1].args[-1][-1].step.is_zero == False
sj = Symbol.s_j(definition=Eq[-1].rhs.limits[0][1])
Eq.sj_definition = sj.equality_defined()
assert Eq.sj_definition.rhs.limits[0][-1].step.is_zero == False
Eq.crossproduct = Eq[-1].subs(Eq.sj_definition.reversed)
Eq.sj_definition_reversed = Eq.sj_definition.this.rhs.limits[0][1].reversed
assert Eq.sj_definition_reversed.args[-1].args[-1][
-1].step.is_zero == False
Eq.sj_definition_reversed = Eq.sj_definition_reversed.reversed
assert Eq.sj_definition_reversed.lhs.args[-1][-1].step.is_zero == False
Eq << Eq[0].intersect({j})
Eq << Piecewise((x[k].set, Equality(x[k], j)),
(EmptySet(), True)).this.simplify()
Eq << Eq[-1].reversed.union_comprehension((k, 0, n - 1))
Eq.distribute = Eq[-1].subs(Eq[-3]).reversed
Eq << Eq.distribute.this.lhs.function.subs(
Eq.distribute.lhs.limits[0][1].args[1][1])
Eq << Eq[-1].as_Or()
Eq << Eq[-1].subs(Eq.sj_definition_reversed)
Eq.sj_greater_than_1 = greater_than.apply(Eq[-1])
Eq.distribute = Eq.distribute.subs(Eq.sj_definition_reversed)
Eq << Eq.sj_greater_than_1.lhs.assertion()
Eq.sj_less_than_1, Eq.inequality_ab = Eq[-1].split()
(a, *_), (b, *_) = Eq.inequality_ab.limits
Eq << sets.equality.imply.forall_equality.nonoverlapping.apply(
Eq[0].abs(), excludes=Eq.inequality_ab.variables_set)
Eq << Eq[-1].subs(k, a)
Eq << Eq[-1].subs(Eq[-1].variable, b)
Eq << (Eq.inequality_ab & Eq[-1])
Eq.distribute_ab = Eq[-1].this.function.distribute()
Eq.j_equality, _ = sj.assertion().split()
Eq.i_domain = ForAll[a:sj](Contains(a, Interval(0, n - 1, integer=True)),
plausible=True)
Eq << Eq.i_domain.simplify()
Eq.sj_element_contains = ForAll[b:sj](Contains(
b, Interval(0, n - 1, integer=True)),
plausible=True)
Eq << Eq.sj_element_contains.simplify()
Eq << Eq.i_domain.apply(sets.contains.imply.equality.union)
Eq << Eq.distribute_ab.subs(Eq[-1])
Eq << (Eq[-1] & Eq.sj_element_contains)
Eq << Eq.j_equality.limits_subs(k, a).reversed
Eq << Eq[-2].subs(Eq[-1])
Eq << Eq.j_equality.limits_subs(k, b).reversed
Eq << Eq[-1].subs(Eq[-2])
Eq << Eq.sj_less_than_1.subs(Eq.sj_greater_than_1)
Eq << sets.equality.imply.contains.apply(Eq[-1], var=k)
Eq.index_domain = Eq[-1].subs(Eq.crossproduct.reversed)
Eq << Eq.j_equality.subs(k, Eq.index_domain.lhs).split()
Eq <<= Eq[-2] & Eq.index_domain
Eq << Eq[-1].reversed
Eq << Subset(sj, Eq[1].rhs, plausible=True)
Eq <<= Eq[-1] & Eq.index_domain
def _intersect(self, other):
from sympy.solvers.diophantine import diophantine
if self.base_set is S.Integers:
g = None
if isinstance(other, ImageSet) and other.base_set is S.Integers:
g = other.lamda.expr
m = other.lamda.variables[0]
elif other is S.Integers:
m = g = Dummy('x')
if g is not None:
f = self.lamda.expr
n = self.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:
return
# since 'a' < 'b', select soln for n
nsol = solns[0][0]
t = nsol.free_symbols.pop()
return imageset(Lambda(n, f.subs(a, nsol.subs(t, n))),
S.Integers)
if other == S.Reals:
from sympy.solvers.solveset import solveset_real
from sympy.core.function import expand_complex
if len(self.lamda.variables) > 1:
return None
f = self.lamda.expr
n = self.lamda.variables[0]
n_ = Dummy(n.name, real=True)
f_ = f.subs(n, n_)
re, im = f_.as_real_imag()
im = expand_complex(im)
return imageset(Lambda(n_, re),
self.base_set.intersect(solveset_real(im, n_)))
elif isinstance(other, Interval):
from sympy.solvers.solveset import (invert_real, invert_complex,
solveset)
f = self.lamda.expr
n = self.lamda.variables[0]
base_set = self.base_set
new_inf, new_sup = None, None
new_lopen, new_ropen = other.left_open, other.right_open
if f.is_real:
inverter = invert_real
else:
inverter = invert_complex
g1, h1 = inverter(f, other.inf, n)
g2, h2 = inverter(f, other.sup, n)
if all(isinstance(i, FiniteSet) for i in (h1, h2)):
if g1 == n:
if len(h1) == 1:
new_inf = h1.args[0]
if g2 == n:
if len(h2) == 1:
new_sup = h2.args[0]
# TODO: Design a technique to handle multiple-inverse
# functions
# Any of the new boundary values cannot be determined
if any(i is None for i in (new_sup, new_inf)):
return
range_set = S.EmptySet
if all(i.is_real for i in (new_sup, new_inf)):
# this assumes continuity of underlying function
# however fixes the case when it is decreasing
if new_inf > new_sup:
new_inf, new_sup = new_sup, new_inf
new_interval = Interval(new_inf, new_sup, new_lopen,
new_ropen)
range_set = base_set._intersect(new_interval)
else:
if other.is_subset(S.Reals):
solutions = solveset(f, n, S.Reals)
if not isinstance(range_set, (ImageSet, ConditionSet)):
range_set = solutions._intersect(other)
else:
return
if range_set is S.EmptySet:
return S.EmptySet
elif isinstance(range_set,
Range) and range_set.size is not S.Infinity:
range_set = FiniteSet(*list(range_set))
if range_set is not None:
return imageset(Lambda(n, f), range_set)
return
else:
return
def empty_set():
return AtSet(EmptySet(), EmptySet())
def apply(e, s):
return Equality(s & e.set, Piecewise((e.set, Contains(e, s)), (EmptySet(), True)))
