def test_Not():
assert Not(Equality(x, y)) == Unequality(x, y)
assert Not(Unequality(x, y)) == Equality(x, y)
assert Not(StrictGreaterThan(x, y)) == LessThan(x, y)
assert Not(StrictLessThan(x, y)) == GreaterThan(x, y)
assert Not(GreaterThan(x, y)) == StrictLessThan(x, y)
assert Not(LessThan(x, y)) == StrictGreaterThan(x, y)
def test_Declaration():
u = symbols('u', real=True)
vu = Variable(u, type=Type.from_expr(u))
assert Declaration(vu).variable.type == real
vn = Variable(n, type=Type.from_expr(n))
assert Declaration(vn).variable.type == integer
lt = StrictLessThan(vu, vn)
assert isinstance(lt, StrictLessThan)
vuc = Variable(u, Type.from_expr(u), value=3.0, attrs={value_const})
assert value_const in vuc.attrs
assert pointer_const not in vuc.attrs
decl = Declaration(vuc)
assert decl.variable == vuc
assert isinstance(decl.variable.value, Float)
assert decl.variable.value == 3.0
assert decl.func(*decl.args) == decl
assert vuc.as_Declaration() == decl
assert vuc.as_Declaration(value=None, attrs=None) == Declaration(vu)
vy = Variable(y, type=integer, value=3)
decl2 = Declaration(vy)
assert decl2.variable == vy
assert decl2.variable.value == Integer(3)
vi = Variable(i, type=Type.from_expr(i), value=3.0)
decl3 = Declaration(vi)
assert decl3.variable.type == integer
assert decl3.variable.value == 3.0
raises(ValueError, lambda: Declaration(vi, 42))
def test_core_relational():
x = Symbol("x")
y = Symbol("y")
for c in (Equality, Equality(x, y), GreaterThan, GreaterThan(x, y),
LessThan, LessThan(x, y), Relational, Relational(x, y),
StrictGreaterThan, StrictGreaterThan(x, y), StrictLessThan,
StrictLessThan(x, y), Unequality, Unequality(x, y)):
check(c)
def as_two_terms(self):
from sympy.sets.sets import Interval
if not isinstance(self.set, Interval):
return self
res = [None] * 2
kwargs = self.clauses()
kwargs['given'] = self if self.plausible else None
kwargs['evaluate'] = False
if self.set.left_open:
res[0] = StrictGreaterThan(self.element, self.set.start, **kwargs)
else:
res[0] = GreaterThan(self.element, self.set.start, **kwargs)
if self.set.right_open:
res[1] = StrictLessThan(self.element, self.set.stop, **kwargs)
else:
res[1] = LessThan(self.element, self.set.stop, **kwargs)
return res
def test_lt_gt():
S = sympify
x, y = Symbol('x'), Symbol('y')
assert (x >= y) == GreaterThan(x, y)
assert (x >= 0) == GreaterThan(x, 0)
assert (x <= y) == LessThan(x, y)
assert (x <= 0) == LessThan(x, 0)
assert (0 <= x) == GreaterThan(x, 0)
assert (0 >= x) == LessThan(x, 0)
assert (S(0) >= x) == GreaterThan(0, x)
assert (S(0) <= x) == LessThan(0, x)
assert (x > y) == StrictGreaterThan(x, y)
assert (x > 0) == StrictGreaterThan(x, 0)
assert (x < y) == StrictLessThan(x, y)
assert (x < 0) == StrictLessThan(x, 0)
assert (0 < x) == StrictGreaterThan(x, 0)
assert (0 > x) == StrictLessThan(x, 0)
assert (S(0) > x) == StrictGreaterThan(0, x)
assert (S(0) < x) == StrictLessThan(0, x)
e = x**2 + 4 * x + 1
assert (e >= 0) == GreaterThan(e, 0)
assert (0 <= e) == GreaterThan(e, 0)
assert (e > 0) == StrictGreaterThan(e, 0)
assert (0 < e) == StrictGreaterThan(e, 0)
assert (e <= 0) == LessThan(e, 0)
assert (0 >= e) == LessThan(e, 0)
assert (e < 0) == StrictLessThan(e, 0)
assert (0 > e) == StrictLessThan(e, 0)
assert (S(0) >= e) == GreaterThan(0, e)
assert (S(0) <= e) == LessThan(0, e)
assert (S(0) < e) == StrictLessThan(0, e)
assert (S(0) > e) == StrictGreaterThan(0, e)
def test_new_relational():
x = Symbol('x')
assert Eq(x, 0) == Relational(x, 0) # None ==> Equality
assert Eq(x, 0) == Relational(x, 0, '==')
assert Eq(x, 0) == Relational(x, 0, 'eq')
assert Eq(x, 0) == Equality(x, 0)
assert Eq(x, 0) != Relational(x, 1) # None ==> Equality
assert Eq(x, 0) != Relational(x, 1, '==')
assert Eq(x, 0) != Relational(x, 1, 'eq')
assert Eq(x, 0) != Equality(x, 1)
assert Eq(x, -1) == Relational(x, -1) # None ==> Equality
assert Eq(x, -1) == Relational(x, -1, '==')
assert Eq(x, -1) == Relational(x, -1, 'eq')
assert Eq(x, -1) == Equality(x, -1)
assert Eq(x, -1) != Relational(x, 1) # None ==> Equality
assert Eq(x, -1) != Relational(x, 1, '==')
assert Eq(x, -1) != Relational(x, 1, 'eq')
assert Eq(x, -1) != Equality(x, 1)
assert Ne(x, 0) == Relational(x, 0, '!=')
assert Ne(x, 0) == Relational(x, 0, '<>')
assert Ne(x, 0) == Relational(x, 0, 'ne')
assert Ne(x, 0) == Unequality(x, 0)
assert Ne(x, 0) != Relational(x, 1, '!=')
assert Ne(x, 0) != Relational(x, 1, '<>')
assert Ne(x, 0) != Relational(x, 1, 'ne')
assert Ne(x, 0) != Unequality(x, 1)
assert Ge(x, 0) == Relational(x, 0, '>=')
assert Ge(x, 0) == Relational(x, 0, 'ge')
assert Ge(x, 0) == GreaterThan(x, 0)
assert Ge(x, 1) != Relational(x, 0, '>=')
assert Ge(x, 1) != Relational(x, 0, 'ge')
assert Ge(x, 1) != GreaterThan(x, 0)
assert (x >= 1) == Relational(x, 1, '>=')
assert (x >= 1) == Relational(x, 1, 'ge')
assert (x >= 1) == GreaterThan(x, 1)
assert (x >= 0) != Relational(x, 1, '>=')
assert (x >= 0) != Relational(x, 1, 'ge')
assert (x >= 0) != GreaterThan(x, 1)
assert Le(x, 0) == Relational(x, 0, '<=')
assert Le(x, 0) == Relational(x, 0, 'le')
assert Le(x, 0) == LessThan(x, 0)
assert Le(x, 1) != Relational(x, 0, '<=')
assert Le(x, 1) != Relational(x, 0, 'le')
assert Le(x, 1) != LessThan(x, 0)
assert (x <= 1) == Relational(x, 1, '<=')
assert (x <= 1) == Relational(x, 1, 'le')
assert (x <= 1) == LessThan(x, 1)
assert (x <= 0) != Relational(x, 1, '<=')
assert (x <= 0) != Relational(x, 1, 'le')
assert (x <= 0) != LessThan(x, 1)
assert Gt(x, 0) == Relational(x, 0, '>')
assert Gt(x, 0) == Relational(x, 0, 'gt')
assert Gt(x, 0) == StrictGreaterThan(x, 0)
assert Gt(x, 1) != Relational(x, 0, '>')
assert Gt(x, 1) != Relational(x, 0, 'gt')
assert Gt(x, 1) != StrictGreaterThan(x, 0)
assert (x > 1) == Relational(x, 1, '>')
assert (x > 1) == Relational(x, 1, 'gt')
assert (x > 1) == StrictGreaterThan(x, 1)
assert (x > 0) != Relational(x, 1, '>')
assert (x > 0) != Relational(x, 1, 'gt')
assert (x > 0) != StrictGreaterThan(x, 1)
assert Lt(x, 0) == Relational(x, 0, '<')
assert Lt(x, 0) == Relational(x, 0, 'lt')
assert Lt(x, 0) == StrictLessThan(x, 0)
assert Lt(x, 1) != Relational(x, 0, '<')
assert Lt(x, 1) != Relational(x, 0, 'lt')
assert Lt(x, 1) != StrictLessThan(x, 0)
assert (x < 1) == Relational(x, 1, '<')
assert (x < 1) == Relational(x, 1, 'lt')
assert (x < 1) == StrictLessThan(x, 1)
assert (x < 0) != Relational(x, 1, '<')
assert (x < 0) != Relational(x, 1, 'lt')
assert (x < 0) != StrictLessThan(x, 1)
# finally, some fuzz testing
from sympy.core.random import randint
for i in range(100):
while 1:
strtype, length = (chr, 65535) if randint(0, 1) else (chr, 255)
relation_type = strtype(randint(0, length))
if randint(0, 1):
relation_type += strtype(randint(0, length))
if relation_type not in ('==', 'eq', '!=', '<>', 'ne', '>=', 'ge',
'<=', 'le', '>', 'gt', '<', 'lt', ':=',
'+=', '-=', '*=', '/=', '%='):
break
raises(ValueError, lambda: Relational(x, 1, relation_type))
assert all(Relational(x, 0, op).rel_op == '==' for op in ('eq', '=='))
assert all(
Relational(x, 0, op).rel_op == '!=' for op in ('ne', '<>', '!='))
assert all(Relational(x, 0, op).rel_op == '>' for op in ('gt', '>'))
assert all(Relational(x, 0, op).rel_op == '<' for op in ('lt', '<'))
assert all(Relational(x, 0, op).rel_op == '>=' for op in ('ge', '>='))
assert all(Relational(x, 0, op).rel_op == '<=' for op in ('le', '<='))
def test_Idx_inequalities():
i14 = Idx("i14", (1, 4))
i79 = Idx("i79", (7, 9))
i46 = Idx("i46", (4, 6))
i35 = Idx("i35", (3, 5))
assert i14 <= 5
assert i14 < 5
assert not (i14 >= 5)
assert not (i14 > 5)
assert 5 >= i14
assert 5 > i14
assert not (5 <= i14)
assert not (5 < i14)
assert LessThan(i14, 5)
assert StrictLessThan(i14, 5)
assert not GreaterThan(i14, 5)
assert not StrictGreaterThan(i14, 5)
assert i14 <= 4
assert isinstance(i14 < 4, StrictLessThan)
assert isinstance(i14 >= 4, GreaterThan)
assert not (i14 > 4)
assert isinstance(i14 <= 1, LessThan)
assert not (i14 < 1)
assert i14 >= 1
assert isinstance(i14 > 1, StrictGreaterThan)
assert not (i14 <= 0)
assert not (i14 < 0)
assert i14 >= 0
assert i14 > 0
from sympy.abc import x
assert isinstance(i14 < x, StrictLessThan)
assert isinstance(i14 > x, StrictGreaterThan)
assert isinstance(i14 <= x, LessThan)
assert isinstance(i14 >= x, GreaterThan)
assert i14 < i79
assert i14 <= i79
assert not (i14 > i79)
assert not (i14 >= i79)
assert i14 <= i46
assert isinstance(i14 < i46, StrictLessThan)
assert isinstance(i14 >= i46, GreaterThan)
assert not (i14 > i46)
assert isinstance(i14 < i35, StrictLessThan)
assert isinstance(i14 > i35, StrictGreaterThan)
assert isinstance(i14 <= i35, LessThan)
assert isinstance(i14 >= i35, GreaterThan)
iNone1 = Idx("iNone1")
iNone2 = Idx("iNone2")
assert isinstance(iNone1 < iNone2, StrictLessThan)
assert isinstance(iNone1 > iNone2, StrictGreaterThan)
assert isinstance(iNone1 <= iNone2, LessThan)
assert isinstance(iNone1 >= iNone2, GreaterThan)
def prove(Eq):
k = Symbol.k(integer=True, positive=True)
n = Symbol.n(integer=True, positive=True)
Eq << apply(n, k)
s2_quote = Symbol.s_quote_2(definition=Eq[0].rhs.limits[0][1])
Eq << s2_quote.this.definition
Eq.s2_definition = Eq[0].subs(Eq[-1].reversed)
s1_quote = Eq[2].lhs
Eq << s1_quote.assertion()
i = Eq[1].lhs.indices[0]
x_slice = Eq[-1].limits[0][0]
x = x_slice.base
Eq.x_abs_positive_s1, Eq.x_abs_sum_s1, Eq.x_union_s1 = Eq[-1].split()
j = Symbol.j(domain=Interval(0, k, integer=True))
x_quote = Eq[1].lhs.base
Eq.x_quote_set_in_s2 = Subset(image_set(UNION[i:0:k](x_quote[i].set),
x_slice, s1_quote),
Eq[0].lhs,
plausible=True)
Eq << Eq.x_quote_set_in_s2.definition
Eq << Eq[-1].subs(Eq.s2_definition)
Eq << Eq[-1].definition.definition
Eq << Eq[-1].this.function.args[0].simplify()
Eq << Eq[1].union_comprehension((i, 0, k))
x_quote_union = Eq[-1].subs(Eq.x_union_s1)
Eq << x_quote_union
Eq << Eq[1].abs()
x_quote_abs = Eq[-1]
Eq << Eq[-1].sum((i, 0, k))
Eq << sets.imply.less_than.union.apply(*Eq[-1].rhs.args[1].arg.args)
Eq << Eq[-2].subs(Eq[-1])
Eq << Eq[-1].subs(Eq.x_abs_sum_s1)
Eq << x_quote_union.abs()
x_quote_union_abs = Eq[-1]
u = Eq[-1].lhs.arg
Eq << sets.imply.less_than.union_comprehension.apply(u.function, *u.limits)
Eq << Eq[-2].subs(Eq[-1])
Eq << Eq[-4].subs(Eq[-1])
SqueezeTheorem = Eq[-1]
Eq << x_quote_abs.as_Or()
Eq << Eq[-1].subs(i, j)
Eq << Eq[-2].forall((i, Unequality(i, j)))
Eq << sets.imply.greater_than.apply(*Eq[-2].rhs.arg.args[::-1])
Eq << Eq[-1].subs(Eq.x_abs_positive_s1.limits_subs(i, j))
Eq << Eq[-4].subs(Eq[-1])
Eq << Eq[-4].subs(Eq.x_abs_positive_s1)
Eq << (Eq[-1] & Eq[-2])
Eq << (x_quote_union & SqueezeTheorem & Eq[-1])
Eq.x_quote_definition = Eq[1].reference((i, 0, k))
Eq.subset_A = Subset(Eq[4].lhs, Eq[4].rhs, plausible=True)
Eq.supset_A = Supset(Eq[4].lhs, Eq[3].lhs, plausible=True)
Eq << Eq.supset_A.subs(Eq[3])
Eq << Eq[-1].definition.definition
Eq << Eq[-1].split()
notContains = Eq[-1]
Eq << ~Eq[-1]
Eq << Eq[-1].definition
Eq << Eq.x_quote_definition[j]
Eq << Eq[-1].intersect(Eq[-2].reversed)
Eq << sets.imply.equality.inclusion_exclusion_principle.apply(
*Eq[-1].lhs.args)
Eq << Eq[-1].subs(Eq[-2])
Eq.set_size_inequality = Eq[-1].subs(
StrictLessThan(Eq[-1].function.rhs,
Eq[-1].function.rhs + 1,
plausible=True))
Eq << x_quote_union.this.function.lhs.bisect({i, j})
Eq << sets.imply.less_than.union.apply(*Eq[-1].lhs.args)
Eq << sets.imply.less_than.union_comprehension.apply(
*Eq[-2].lhs.args[0].args)
Eq << Eq[-2].subs(Eq[-1]) + Eq.set_size_inequality
Eq << Eq[-1].this().function.rhs.args[-1].simplify()
Eq << Eq[-1].this().function.rhs.args[0].arg.simplify()
Eq << Eq[-1].subs(x_quote_union_abs)
Eq << Eq[-1].subs(SqueezeTheorem)
Eq << Eq.subset_A.subs(Eq[3])
Eq << Eq[-1].definition.definition
s2_hat_n = Symbol("\hat{s}_{2, n}", definition=Eq[-1].limits[0][1])
Eq << s2_hat_n.this.definition
Eq.s2_hat_n_assertion = Eq[-2].this.limits[0].subs(Eq[-1].reversed)
Eq << Eq[-1].this.rhs.as_image_set()
s2_quote_n = Symbol("s'_{2, n}", definition=Eq[-1].rhs.limits[0][1])
assert s2_quote_n in s2_quote
assert Supset(s2_quote, s2_quote_n)
Eq << s2_quote_n.this.definition
Eq << Eq[-2].subs(Eq[-1].reversed)
Eq.s2_hat_n_hypothesis = Eq.s2_hat_n_assertion.this.limits[0].subs(Eq[-1])
Eq << s2_quote_n.assertion()
Eq.n_not_in_x, Eq.x_abs_positive_s2_n, Eq.x_abs_sum_s2_n, Eq.x_union_s2_n = Eq[
-1].split()
Eq << Eq.n_not_in_x.definition
Eq.x_j_inequality = Eq[-1].limits_subs(i, j)
Eq << Eq.x_union_s2_n.func(Contains(n, Eq.x_union_s2_n.lhs),
*Eq.x_union_s2_n.limits,
plausible=True)
Eq << Eq[-1].subs(Eq.x_union_s2_n)
Eq << Eq[-1].definition
x_hat = Symbol(r"\hat{x}",
shape=(oo, ),
dtype=dtype.integer,
definition=LAMBDA[i](Piecewise(
(x_slice[i] - {n}, Equality(i, j)),
(x_slice[i], True))))
Eq.x_hat_definition = x_hat.equality_defined()
Eq << Eq[-1].this.function.limits_subs(i, j)
Eq.x_j_subset = Eq[-1].apply(sets.contains.imply.subset, simplify=False)
Eq << Eq.x_j_subset.apply(sets.inequality.subset.imply.inequality,
Eq.x_j_inequality,
simplify=False)
Eq.x_j_abs_positive = Eq[-1].apply(
sets.inequality.imply.strict_greater_than)
Eq.x_hat_abs = Eq.x_hat_definition.abs()
Eq << Eq.x_hat_abs.as_Or()
Eq << Eq[-1].subs(i, j)
Eq << Eq[-2].forall((i, Unequality(i, j)))
Eq << Eq[-1].subs(Eq.x_abs_positive_s2_n) # -1
Eq << Eq[-3].subs(Eq.x_j_abs_positive)
Eq.x_hat_abs_positive = Eq[-1] & Eq[-2]
Eq.x_hat_union = Eq.x_hat_definition.union_comprehension((i, 0, k))
Eq.x_union_complement = Eq.x_union_s2_n - {n}
Eq << Eq.x_union_s2_n.abs().subs(Eq.x_abs_sum_s2_n.reversed).apply(
sets.equality.imply.forall_equality.nonoverlapping)
Eq << Eq[-1].limits_subs(Eq[-1].variables[1], j).limits_subs(
Eq[-1].variable, i)
Eq.x_complement_n = Eq[-1].apply(sets.equality.subset.imply.equality,
Eq.x_j_subset)
Eq << Eq.x_complement_n.this.function.function.union_comprehension(
*Eq.x_complement_n.function.function.limits)
Eq << Eq.x_hat_union.subs(Eq[-1].reversed)
Eq.x_hat_union = Eq[-1].subs(Eq.x_union_complement)
Eq << Eq.x_hat_abs.sum((i, 0, k)).subs(Eq.x_abs_sum_s2_n)
Eq << Eq.x_j_subset.apply(sets.subset.imply.equality.complement)
Eq << Eq[-2].subs(Eq[-1])
Eq << (Eq[-1] & Eq.x_hat_abs_positive & Eq.x_hat_union)
function = Contains(x_hat[:k + 1], s1_quote)
function = Eq[-1].function.func(function, *Eq[-1].function.limits)
Eq.x_hat_in_s1 = Eq[-1].func(function, *Eq[-1].limits, plausible=True)
Eq << Eq.x_hat_in_s1.definition
Eq << Eq.x_hat_definition.as_Or()
Eq << Eq[-1].subs(i, j)
Eq << Eq[-2].forall((i, Unequality(i, j)))
Eq <<= Eq[-1] & Eq.x_complement_n.reversed
Eq << (Eq[-1] & Eq[-3])
Eq << Eq[-1].this.function.function.reference(
*Eq[-1].function.function.limits)
Eq << Eq.x_hat_in_s1.subs(Eq[-1])
Eq << Eq.s2_hat_n_hypothesis.strip().strip()
Eq << Eq[-1].subs(Eq.x_quote_definition)
Eq.equation = Eq[-1] - {n}
Eq << Eq.x_union_s1.intersect({n})
Eq.nonoverlapping_s1_quote = Eq[-1].apply(
sets.equality.imply.equality.given.emptyset.intersect)
Eq.xi_complement_n = Eq.nonoverlapping_s1_quote.apply(
sets.equality.imply.equality.given.emptyset.complement, reverse=True)
Eq << Eq.equation.subs(Eq.xi_complement_n)
a = Eq[-1].variable
b = Symbol.b(**a.dtype.dict)
Eq << Eq[-1].limits_subs(a, b)
Eq << Eq[-1].this.function.subs(x[:k + 1], a)
Eq << Eq[-1].limits_subs(b, x[:k + 1])
Eq << Eq[-1].this.function.function.reference((i, 0, k))
Eq.supset_A = sets.supset.imply.supset.apply(Eq.supset_A, (j, ),
simplify=False)
Eq << Eq.supset_A.subs(Eq.subset_A)
def test_new_relational():
x = Symbol('x')
assert Eq(x) == Relational(x, 0) # None ==> Equality
assert Eq(x) == Relational(x, 0, '==')
assert Eq(x) == Relational(x, 0, 'eq')
assert Eq(x) == Equality(x, 0)
assert Eq(x, -1) == Relational(x, -1) # None ==> Equality
assert Eq(x, -1) == Relational(x, -1, '==')
assert Eq(x, -1) == Relational(x, -1, 'eq')
assert Eq(x, -1) == Equality(x, -1)
assert Eq(x) != Relational(x, 1) # None ==> Equality
assert Eq(x) != Relational(x, 1, '==')
assert Eq(x) != Relational(x, 1, 'eq')
assert Eq(x) != Equality(x, 1)
assert Eq(x, -1) != Relational(x, 1) # None ==> Equality
assert Eq(x, -1) != Relational(x, 1, '==')
assert Eq(x, -1) != Relational(x, 1, 'eq')
assert Eq(x, -1) != Equality(x, 1)
assert Ne(x, 0) == Relational(x, 0, '!=')
assert Ne(x, 0) == Relational(x, 0, '<>')
assert Ne(x, 0) == Relational(x, 0, 'ne')
assert Ne(x, 0) == Unequality(x, 0)
assert Ne(x, 0) != Relational(x, 1, '!=')
assert Ne(x, 0) != Relational(x, 1, '<>')
assert Ne(x, 0) != Relational(x, 1, 'ne')
assert Ne(x, 0) != Unequality(x, 1)
assert Ge(x, 0) == Relational(x, 0, '>=')
assert Ge(x, 0) == Relational(x, 0, 'ge')
assert Ge(x, 0) == GreaterThan(x, 0)
assert Ge(x, 1) != Relational(x, 0, '>=')
assert Ge(x, 1) != Relational(x, 0, 'ge')
assert Ge(x, 1) != GreaterThan(x, 0)
assert (x >= 1) == Relational(x, 1, '>=')
assert (x >= 1) == Relational(x, 1, 'ge')
assert (x >= 1) == GreaterThan(x, 1)
assert (x >= 0) != Relational(x, 1, '>=')
assert (x >= 0) != Relational(x, 1, 'ge')
assert (x >= 0) != GreaterThan(x, 1)
assert Le(x, 0) == Relational(x, 0, '<=')
assert Le(x, 0) == Relational(x, 0, 'le')
assert Le(x, 0) == LessThan(x, 0)
assert Le(x, 1) != Relational(x, 0, '<=')
assert Le(x, 1) != Relational(x, 0, 'le')
assert Le(x, 1) != LessThan(x, 0)
assert (x <= 1) == Relational(x, 1, '<=')
assert (x <= 1) == Relational(x, 1, 'le')
assert (x <= 1) == LessThan(x, 1)
assert (x <= 0) != Relational(x, 1, '<=')
assert (x <= 0) != Relational(x, 1, 'le')
assert (x <= 0) != LessThan(x, 1)
assert Gt(x, 0) == Relational(x, 0, '>')
assert Gt(x, 0) == Relational(x, 0, 'gt')
assert Gt(x, 0) == StrictGreaterThan(x, 0)
assert Gt(x, 1) != Relational(x, 0, '>')
assert Gt(x, 1) != Relational(x, 0, 'gt')
assert Gt(x, 1) != StrictGreaterThan(x, 0)
assert (x > 1) == Relational(x, 1, '>')
assert (x > 1) == Relational(x, 1, 'gt')
assert (x > 1) == StrictGreaterThan(x, 1)
assert (x > 0) != Relational(x, 1, '>')
assert (x > 0) != Relational(x, 1, 'gt')
assert (x > 0) != StrictGreaterThan(x, 1)
assert Lt(x, 0) == Relational(x, 0, '<')
assert Lt(x, 0) == Relational(x, 0, 'lt')
assert Lt(x, 0) == StrictLessThan(x, 0)
assert Lt(x, 1) != Relational(x, 0, '<')
assert Lt(x, 1) != Relational(x, 0, 'lt')
assert Lt(x, 1) != StrictLessThan(x, 0)
assert (x < 1) == Relational(x, 1, '<')
assert (x < 1) == Relational(x, 1, 'lt')
assert (x < 1) == StrictLessThan(x, 1)
assert (x < 0) != Relational(x, 1, '<')
assert (x < 0) != Relational(x, 1, 'lt')
assert (x < 0) != StrictLessThan(x, 1)
# finally, some fuzz testing
from random import randint
for i in range(100):
while 1:
if sys.version_info[0] >= 3:
strtype, length = (chr, 65535) if randint(0, 1) else (chr, 255)
else:
strtype, length = (unichr, 65535) if randint(0, 1) else (chr, 255)
relation_type = strtype( randint(0, length) )
if randint(0, 1):
relation_type += strtype( randint(0, length) )
if relation_type not in ('==', 'eq', '!=', '<>', 'ne', '>=', 'ge',
'<=', 'le', '>', 'gt', '<', 'lt'):
break
raises(ValueError, lambda: Relational(x, 1, relation_type))
(r"\theta!", _factorial(theta)),
(r"(x + 1)!", _factorial(_Add(x, 1))),
(r"(x!)!", _factorial(_factorial(x))),
(r"x!!!", _factorial(_factorial(_factorial(x)))),
(r"5!7!", _Mul(_factorial(5), _factorial(7))),
(r"\sqrt{x}", sqrt(x)),
(r"\sqrt{x + b}", sqrt(_Add(x, b))),
(r"\sqrt[3]{\sin x}", root(sin(x), 3)),
(r"\sqrt[y]{\sin x}", root(sin(x), y)),
(r"\sqrt[\theta]{\sin x}", root(sin(x), theta)),
(r"\sqrt{\frac{12}{6}}", _Sqrt(_Mul(12, _Pow(6, -1)))),
(r"\overline{z}", _Conjugate(z)),
(r"\overline{\overline{z}}", _Conjugate(_Conjugate(z))),
(r"\overline{x + y}", _Conjugate(_Add(x, y))),
(r"\overline{x} + \overline{y}", _Conjugate(x) + _Conjugate(y)),
(r"x < y", StrictLessThan(x, y)),
(r"x \leq y", LessThan(x, y)),
(r"x > y", StrictGreaterThan(x, y)),
(r"x \geq y", GreaterThan(x, y)),
(r"\mathit{x}", Symbol('x')),
(r"\mathit{test}", Symbol('test')),
(r"\mathit{TEST}", Symbol('TEST')),
(r"\mathit{HELLO world}", Symbol('HELLO world')),
(r"\sum_{k = 1}^{3} c", Sum(c, (k, 1, 3))),
(r"\sum_{k = 1}^3 c", Sum(c, (k, 1, 3))),
(r"\sum^{3}_{k = 1} c", Sum(c, (k, 1, 3))),
(r"\sum^3_{k = 1} c", Sum(c, (k, 1, 3))),
(r"\sum_{k = 1}^{10} k^2", Sum(k**2, (k, 1, 10))),
(r"\sum_{n = 0}^{\infty} \frac{1}{n!}",
Sum(_Pow(_factorial(n), -1), (n, 0, oo))),
(r"\prod_{a = b}^{c} x", Product(x, (a, b, c))),
def test_new_relational():
x = Symbol("x")
assert Eq(x, 0) == Relational(x, 0) # None ==> Equality
assert Eq(x, 0) == Relational(x, 0, "==")
assert Eq(x, 0) == Relational(x, 0, "eq")
assert Eq(x, 0) == Equality(x, 0)
assert Eq(x, 0) != Relational(x, 1) # None ==> Equality
assert Eq(x, 0) != Relational(x, 1, "==")
assert Eq(x, 0) != Relational(x, 1, "eq")
assert Eq(x, 0) != Equality(x, 1)
assert Eq(x, -1) == Relational(x, -1) # None ==> Equality
assert Eq(x, -1) == Relational(x, -1, "==")
assert Eq(x, -1) == Relational(x, -1, "eq")
assert Eq(x, -1) == Equality(x, -1)
assert Eq(x, -1) != Relational(x, 1) # None ==> Equality
assert Eq(x, -1) != Relational(x, 1, "==")
assert Eq(x, -1) != Relational(x, 1, "eq")
assert Eq(x, -1) != Equality(x, 1)
assert Ne(x, 0) == Relational(x, 0, "!=")
assert Ne(x, 0) == Relational(x, 0, "<>")
assert Ne(x, 0) == Relational(x, 0, "ne")
assert Ne(x, 0) == Unequality(x, 0)
assert Ne(x, 0) != Relational(x, 1, "!=")
assert Ne(x, 0) != Relational(x, 1, "<>")
assert Ne(x, 0) != Relational(x, 1, "ne")
assert Ne(x, 0) != Unequality(x, 1)
assert Ge(x, 0) == Relational(x, 0, ">=")
assert Ge(x, 0) == Relational(x, 0, "ge")
assert Ge(x, 0) == GreaterThan(x, 0)
assert Ge(x, 1) != Relational(x, 0, ">=")
assert Ge(x, 1) != Relational(x, 0, "ge")
assert Ge(x, 1) != GreaterThan(x, 0)
assert (x >= 1) == Relational(x, 1, ">=")
assert (x >= 1) == Relational(x, 1, "ge")
assert (x >= 1) == GreaterThan(x, 1)
assert (x >= 0) != Relational(x, 1, ">=")
assert (x >= 0) != Relational(x, 1, "ge")
assert (x >= 0) != GreaterThan(x, 1)
assert Le(x, 0) == Relational(x, 0, "<=")
assert Le(x, 0) == Relational(x, 0, "le")
assert Le(x, 0) == LessThan(x, 0)
assert Le(x, 1) != Relational(x, 0, "<=")
assert Le(x, 1) != Relational(x, 0, "le")
assert Le(x, 1) != LessThan(x, 0)
assert (x <= 1) == Relational(x, 1, "<=")
assert (x <= 1) == Relational(x, 1, "le")
assert (x <= 1) == LessThan(x, 1)
assert (x <= 0) != Relational(x, 1, "<=")
assert (x <= 0) != Relational(x, 1, "le")
assert (x <= 0) != LessThan(x, 1)
assert Gt(x, 0) == Relational(x, 0, ">")
assert Gt(x, 0) == Relational(x, 0, "gt")
assert Gt(x, 0) == StrictGreaterThan(x, 0)
assert Gt(x, 1) != Relational(x, 0, ">")
assert Gt(x, 1) != Relational(x, 0, "gt")
assert Gt(x, 1) != StrictGreaterThan(x, 0)
assert (x > 1) == Relational(x, 1, ">")
assert (x > 1) == Relational(x, 1, "gt")
assert (x > 1) == StrictGreaterThan(x, 1)
assert (x > 0) != Relational(x, 1, ">")
assert (x > 0) != Relational(x, 1, "gt")
assert (x > 0) != StrictGreaterThan(x, 1)
assert Lt(x, 0) == Relational(x, 0, "<")
assert Lt(x, 0) == Relational(x, 0, "lt")
assert Lt(x, 0) == StrictLessThan(x, 0)
assert Lt(x, 1) != Relational(x, 0, "<")
assert Lt(x, 1) != Relational(x, 0, "lt")
assert Lt(x, 1) != StrictLessThan(x, 0)
assert (x < 1) == Relational(x, 1, "<")
assert (x < 1) == Relational(x, 1, "lt")
assert (x < 1) == StrictLessThan(x, 1)
assert (x < 0) != Relational(x, 1, "<")
assert (x < 0) != Relational(x, 1, "lt")
assert (x < 0) != StrictLessThan(x, 1)
# finally, some fuzz testing
from random import randint
from sympy.core.compatibility import unichr
for i in range(100):
while 1:
strtype, length = (unichr, 65535) if randint(0, 1) else (chr, 255)
relation_type = strtype(randint(0, length))
if randint(0, 1):
relation_type += strtype(randint(0, length))
if relation_type not in (
"==",
"eq",
"!=",
"<>",
"ne",
">=",
"ge",
"<=",
"le",
">",
"gt",
"<",
"lt",
":=",
"+=",
"-=",
"*=",
"/=",
"%=",
):
break
raises(ValueError, lambda: Relational(x, 1, relation_type))
assert all(Relational(x, 0, op).rel_op == "==" for op in ("eq", "=="))
assert all(Relational(x, 0, op).rel_op == "!=" for op in ("ne", "<>", "!="))
assert all(Relational(x, 0, op).rel_op == ">" for op in ("gt", ">"))
assert all(Relational(x, 0, op).rel_op == "<" for op in ("lt", "<"))
assert all(Relational(x, 0, op).rel_op == ">=" for op in ("ge", ">="))
assert all(Relational(x, 0, op).rel_op == "<=" for op in ("le", "<="))
