def test_factorial2_rewrite():
n = Symbol('n', integer=True)
assert factorial2(n).rewrite(gamma) == \
2**(n/2)*Piecewise((1, Eq(Mod(n, 2), 0)), (sqrt(2)/sqrt(pi), Eq(Mod(n, 2), 1)))*gamma(n/2 + 1)
assert factorial2(2 * n).rewrite(gamma) == 2**n * gamma(n + 1)
assert factorial2(2*n + 1).rewrite(gamma) == \
sqrt(2)*2**(n + S.Half)*gamma(n + Rational(3, 2))/sqrt(pi)
def test_KroneckerProduct_entry():
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', o, p)
assert KroneckerProduct(A, B)._entry(
i, j) == A[Mod(floor(i / o), n),
Mod(floor(j / p), m)] * B[Mod(i, o), Mod(j, p)]
def test_simplified_FiniteSet_in_CondSet():
assert ConditionSet(x, And(x < 1, x > -3), FiniteSet(0, 1, 2)) == FiniteSet(0)
assert ConditionSet(x, x < 0, FiniteSet(0, 1, 2)) == EmptySet()
assert ConditionSet(x, And(x < -3), EmptySet()) == EmptySet()
y = Symbol('y')
assert (ConditionSet(x, And(x > 0), FiniteSet(-1, 0, 1, y)) ==
Union(FiniteSet(1), ConditionSet(x, And(x > 0), FiniteSet(y))))
assert (ConditionSet(x, Eq(Mod(x, 3), 1), FiniteSet(1, 4, 2, y)) ==
Union(FiniteSet(1, 4), ConditionSet(x, Eq(Mod(x, 3), 1), FiniteSet(y))))
def test_fcode_functions():
x, y = symbols('x,y')
assert fcode(sin(x)**cos(y)) == " sin(x)**cos(y)"
raises(NotImplementedError, lambda: fcode(Mod(x, y), standard=66))
raises(NotImplementedError, lambda: fcode(x % y, standard=66))
raises(NotImplementedError, lambda: fcode(Mod(x, y), standard=77))
raises(NotImplementedError, lambda: fcode(x % y, standard=77))
for standard in [90, 95, 2003, 2008]:
assert fcode(Mod(x, y), standard=standard) == " modulo(x, y)"
assert fcode(x % y, standard=standard) == " modulo(x, y)"
def test_mod_usual():
assert_equal("128\\mod 3", Mod(128, 3))
assert_equal("7\\mod 128", Mod(7, 128))
assert_equal("5\\mod 10", Mod(5, 10))
assert_equal("5\\mod 5", Mod(5, 5))
assert_equal("3\\mod 2", Mod(3, 2))
assert_equal("0 \\mod 6", Mod(0, 6))
assert_equal("6109\\mod 28", Mod(6109, 28))
assert_equal("4000000000\\mod 28791", Mod(4000000000, 28791))
assert_equal("128*10^300\\mod 876123", Mod(Rational('128E300'), 876123))
assert_equal("876,123\\mod 128E300)", Mod(876123, Rational('128E300')))
def test_issue_15230():
has_module('f2py')
x, y = symbols('x, y')
expr = Mod(x, 3.0) - Mod(y, -2.0)
f = autowrap(expr, args=[x, y], language='F95')
exp_res = float(expr.xreplace({x: 3.5, y: 2.7}).evalf())
assert abs(f(3.5, 2.7) - exp_res) < 1e-14
x, y = symbols('x, y', integer=True)
expr = Mod(x, 3) - Mod(y, -2)
f = autowrap(expr, args=[x, y], language='F95')
assert f(3, 2) == expr.xreplace({x: 3, y: 2})
def test_mod_symbol():
assert_equal("x\\mod y", Mod(x, y))
assert_equal("2x\\mod y", Mod(2 * x, y))
assert_equal("y + 3\\mod 2 / 4",
y + Rational(Mod(3, 2), 4),
symbolically=True)
assert_equal("0.5x * 2 + \\sqrt{x}\\mod 8y",
0.5 * x * 2 + Mod(sqrt(x), 8 * y),
symbolically=True)
assert_equal("6.673E-11 * ((8.85418782E-12\\mod 9x) + 4) / 2y",
Rational('6.673E-11') *
(Mod(Rational('8.85418782E-12'), 9 * x) + 4) / (2 * y),
symbolically=True)
def test_mod_negative():
assert_equal("-1\\mod 2", Mod(-1, 2))
assert_equal("-3\\mod 3", Mod(-3, 3))
assert_equal("-12\\mod -12", Mod(-12, -12))
assert_equal("-128\\mod 4", Mod(-128, 4))
assert_equal("9\\mod -213", Mod(9, -213))
assert_equal("123123\\mod -541", Mod(123123, -541))
assert_equal("-123123\\mod 541", Mod(-123123, 541))
assert_equal("-97E34\\mod 7", Mod(Rational('-97E34'), 7))
def gen_points(pol, points_x, prime):
points = []
for point_x in points_x:
point_y = Mod(pol, prime).subs({x: point_x})
points.append([point_x, point_y])
return points
def isst(nu, q, l, i_n, i, sigma):
return Piecewise(
(0, Eq(Mod(nu, 2), 1)),
(f(l, l, i_n, i, nu), Eq(q, 0)),
((-1/2 * (-1)**sigma * f(l, l, i_n, i, nu) *
safe_divide(Wigner3j(l, 1, l, 1, nu, -2),
Wigner3j(l, 1, l, -1, nu, 0))), Eq(Abs(q), 2)),
(0, True))
def test_Mod():
assert Mod(5, 3) == 2
assert Mod(-5, 3) == 1
assert Mod(5, -3) == -1
assert Mod(-5, -3) == -2
assert type(Mod(3.2, 2, evaluate=False)) == Mod
assert 5 % x == Mod(5, x)
assert x % 5 == Mod(x, 5)
assert x % y == Mod(x, y)
assert (x % y).subs({x: 5, y: 3}) == 2
def test_mod_fraction():
assert_equal("1/2\\mod 3", Mod(Rational(1, 2), 3))
assert_equal("6/2\\mod 3", Mod(Rational(6, 2), 3))
assert_equal("-14/2\\mod 5", Mod(Rational(-14, 2), 5))
assert_equal("123\\mod (42/6)", Mod(123, Rational(42, 6)))
assert_equal("431\\mod (2/123)", Mod(431, Rational(2, 123)))
assert_equal("5/5\\mod (5/5)", Mod(Rational(5, 5), Rational(5, 5)))
assert_equal("849/-21\\mod (092/2)",
Mod(Rational(849, -21), Rational(92, 2)))
assert_equal("13*10^9\\mod (21/-2)", Mod(13E9, Rational(21, -2)))
def compute(l):
# first check that no two differ by an integer
for i, b in enumerate(l):
if not b.is_Rational:
return oo
for j in range(i + 1, len(l)):
if not Mod((b - l[j]).simplify(), 1):
return oo
return reduce(ilcm, (x.q for x in l), 1)
def modf(x):
"""modf(x)
Return the fractional and integer parts of x. Both results carry the sign
of x.
"""
signx = sign(x)
absx = Abs(x)
return (signx * Mod(absx, 1), signx * floor(absx))
def interpolate(points, prime):
# unpack
points_x, points_y = list(points[points.columns[0]]), list(points[points.columns[1]])
# sum of Lagrange Basis Func in Finite Field
k = len(points.index)
poly = 0
for i in range(0, k):
poly += int(points_y[i])*lbf(k, points_x, i, prime)
return Mod(poly, prime)
def test_issue_15230():
has_module('f2py')
x, y = symbols('x, y')
expr = Mod(x, 3.0) - Mod(y, -2.0)
f = autowrap(expr, args=[x, y], language='F95')
exp_res = float(expr.xreplace({x: 3.5, y: 2.7}).evalf())
assert abs(f(3.5, 2.7) - exp_res) < 1e-14
x, y = symbols('x, y', integer=True)
expr = Mod(x, 3) - Mod(y, -2)
f = autowrap(expr, args=[x, y], language='F95')
assert f(3, 2) == expr.xreplace({x: 3, y: 2})
def test_mod_float():
assert_equal("0.41\\mod 2", Mod(Rational('0.41'), 2))
assert_equal("143E-13\\mod 21", Mod(Rational('143E-13'), 21))
assert_equal("-9.80665\\mod 9.80665", Mod(-9.80665, 9.80665))
assert_equal("0.0000923423\\mod -8341.234802909",
nsimplify(Mod(0.0000923423, -8341.234802909)))
assert_equal("\\sqrt{5}\\mod \\sqrt{2}", Mod(sqrt(5), sqrt(2)))
assert_equal("987\\mod \\pi", Mod(987, pi))
assert_equal("\\pi\\mod ((1+\\sqrt{5})/2)",
Mod(pi, nsimplify(GoldenRatio)),
symbolically=True)
assert_equal("1234\\mod 1E-29", Mod(1234,
Rational('1E-29'),
evaluate=False))
def create_ops_fetch(f, name_to_ops_dat, time_upper_bound):
if f.is_TimeFunction:
ops_fetch = [
namespace['ops_dat_fetch_data'](
name_to_ops_dat[f.name].indexify(
[Mod(Add(time_upper_bound, -i), f._time_size)]),
Byref(
f.indexify([Mod(Add(time_upper_bound, -i),
f._time_size)])))
for i in range(f._time_size)
]
else:
# The second parameter is the beginning of the array. But I didn't manage
# to generate a C code like: `v`. Instead, I am generating `&(v[0])`.
ops_fetch = [
namespace['ops_dat_fetch_data'](name_to_ops_dat[f.name],
Byref(f.indexify([0])))
]
return ops_fetch
def _visit_BinaryOperatorNode(self, stmt):
first = self._visit(stmt.first)
second = self._visit(stmt.second)
if stmt.value == '+':
return Add(first, second, evaluate=False)
elif stmt.value == '*':
if isinstance(first, (Tuple, List)):
return Dlist(first[0], second)
return Mul(first, second, evaluate=False)
elif stmt.value == '-':
if isinstance(stmt.second, BinaryOperatorNode) \
and isinstance(second, (Add, Mul)):
args = second.args
second = second._new_rawargs(-args[0], args[1])
else:
second = Mul(-1, second)
return Add(first, second, evaluate=False)
elif stmt.value == '/':
if isinstance(second, Mul) and isinstance(stmt.second,
BinaryOperatorNode):
args = list(second.args)
second = Pow(args[0], -1, evaluate=False)
second = Mul(second, args[1], evaluate=False)
else:
second = Pow(second, -1, evaluate=False)
return Mul(first, second, evaluate=False)
elif stmt.value == '**':
return Pow(first, second, evaluate=False)
elif stmt.value == '//':
if isinstance(second, Mul) and isinstance(stmt.second,
BinaryOperatorNode):
args = second.args
second = Pow(args[0], -1, evaluate=False)
first = floor(Mul(first, second, evaluate=False))
return Mul(first, args[1], evaluate=False)
else:
second = Pow(second, -1, evaluate=False)
return floor(Mul(first, second, evaluate=False))
elif stmt.value == '%':
return Mod(first, second)
else:
msg = 'unknown/unavailable BinaryOperatorNode {node}'
msg = msg.format(node=type(stmt.value))
raise PyccelSyntaxError(msg)
def test_mod_expr():
assert_equal("1+1\\mod 2", 1 + Mod(1, 2))
assert_equal("876123\\mod 128\\times 10^300", Mod(876123, 128) * 1E300)
assert_equal("141\\mod 9/3", Rational(Mod(141, 9) / 3))
assert_equal("872 / (12\\mod 9 * 4) * 2",
Rational(2 * 872, (Mod(12, 9) * 4)))
assert_equal("1E-32 * (1E29\\mod 74)",
Rational('1E-32') * Mod(Rational('1E29'), 74))
assert_equal("299,792,458\\mod 9.81", Mod(299792458, Rational('9.81')))
def test_mod():
e = Mod(a, b)
f = lambdify((a, b), e)
a_ = np.array([0, 1, 2, 3])
b_ = 2
assert np.array_equal(f(a_, b_), [0, 1, 0, 1])
a_ = np.array([0, 1, 2, 3])
b_ = np.array([2, 2, 2, 2])
assert np.array_equal(f(a_, b_), [0, 1, 0, 1])
a_ = np.array([2, 3, 4, 5])
b_ = np.array([2, 3, 4, 5])
assert np.array_equal(f(a_, b_), [0, 0, 0, 0])
def _factor_pairs(expr):
factors = expr.as_ordered_factors()
expanded_factors = []
for f in factors:
if f.is_Number:
continue
base, exp = f.as_base_exp()
if exp.q != 1:
expanded_factors.append(base ** Mod(exp, 1))
exp = floor(exp)
if exp >= 0:
f = (base,) * exp
else:
f = (1 / base,) * abs(exp)
expanded_factors.extend(f)
return list(itertools.combinations(expanded_factors, 2))
def test_mod():
if not np:
skip("NumPy not installed")
e = Mod(a, b)
f = lambdify((a, b), e)
a_ = np.array([0, 1, 2, 3])
b_ = 2
assert np.array_equal(f(a_, b_), [0, 1, 0, 1])
a_ = np.array([0, 1, 2, 3])
b_ = np.array([2, 2, 2, 2])
assert np.array_equal(f(a_, b_), [0, 1, 0, 1])
a_ = np.array([2, 3, 4, 5])
b_ = np.array([2, 3, 4, 5])
assert np.array_equal(f(a_, b_), [0, 0, 0, 0])
def test_binomial_Mod():
p, q = 10**5 + 3, 10**9 + 33 # prime modulo
r = 10**7 + 5 # composite modulo
# A few tests to get coverage
# Lucas Theorem
assert Mod(binomial(156675, 4433, evaluate=False), p) == Mod(binomial(156675, 4433), p)
# factorial Mod
assert Mod(binomial(1234, 432, evaluate=False), q) == Mod(binomial(1234, 432), q)
# binomial factorize
assert Mod(binomial(253, 113, evaluate=False), r) == Mod(binomial(253, 113), r)
def test_Mod():
assert Mod(5, 3) == 2
assert Mod(-5, 3) == 1
assert Mod(5, -3) == -1
assert Mod(-5, -3) == -2
assert type(Mod(3.2, 2, evaluate=False)) == Mod
assert 5 % x == Mod(5, x)
assert x % 5 == Mod(x, 5)
assert x % y == Mod(x, y)
assert (x % y).subs({x: 5, y: 3}) == 2
assert (x + 3) % 1 == Mod(x, 1)
assert (x + 3.0) % 1 == Mod(x, 1)
assert (x - S(33) / 10) % 1 == Mod(x + S(7) / 10, 1)
assert (x - 3.3) % 1 == Mod(x + 0.7, 1)
assert Mod(-3.3, 1) == Mod(0.7, 1) == Float(0.7)
e = Mod(1.3, 1)
assert e == .3 and e.is_Float
e = Mod(1.3, .7)
assert e == .6 and e.is_Float
e = Mod(1.3, Rational(7, 10))
assert e == .6 and e.is_Float
e = Mod(Rational(13, 10), 0.7)
assert e == .6 and e.is_Float
e = Mod(Rational(13, 10), Rational(7, 10))
assert e == .6 and e.is_Rational
def test_issue_10024():
x = Dummy("x")
assert Mod(x, 2 * pi).is_zero is None
def test_Mod():
assert Mod(x, 1).func is Mod
assert pi % pi == S.Zero
assert Mod(5, 3) == 2
assert Mod(-5, 3) == 1
assert Mod(5, -3) == -1
assert Mod(-5, -3) == -2
assert type(Mod(3.2, 2, evaluate=False)) == Mod
assert 5 % x == Mod(5, x)
assert x % 5 == Mod(x, 5)
assert x % y == Mod(x, y)
assert (x % y).subs({x: 5, y: 3}) == 2
# Float handling
point3 = Float(3.3) % 1
assert (x - 3.3) % 1 == Mod(1.*x + 1 - point3, 1)
assert Mod(-3.3, 1) == 1 - point3
assert Mod(0.7, 1) == Float(0.7)
e = Mod(1.3, 1)
point3 = Float._new(Float(.3)._mpf_, 51)
assert e == point3 and e.is_Float
e = Mod(1.3, .7)
point6 = Float._new(Float(.6)._mpf_, 51)
assert e == point6 and e.is_Float
e = Mod(1.3, Rational(7, 10))
assert e == point6 and e.is_Float
e = Mod(Rational(13, 10), 0.7)
assert e == point6 and e.is_Float
e = Mod(Rational(13, 10), Rational(7, 10))
assert e == .6 and e.is_Rational
# check that sign is right
r2 = sqrt(2)
r3 = sqrt(3)
for i in [-r3, -r2, r2, r3]:
for j in [-r3, -r2, r2, r3]:
assert test_numerically(i % j, i.n() % j.n())
for _x in range(4):
for _y in range(9):
reps = [(x, _x), (y, _y)]
assert Mod(3*x + y, 9).subs(reps) == (3*_x + _y) % 9
# denesting
# easy case
assert Mod(Mod(x, y), y) == Mod(x, y)
# in case someone attempts more denesting
for i in [-3, -2, 2, 3]:
for j in [-3, -2, 2, 3]:
for k in range(3):
# print i, j, k
assert Mod(Mod(k, i), j) == (k % i) % j
# known difference
assert Mod(5*sqrt(2), sqrt(5)) == 5*sqrt(2) - 3*sqrt(5)
p = symbols('p', positive=True)
assert Mod(p + 1, p + 3) == p + 1
n = symbols('n', negative=True)
assert Mod(n - 3, n - 1) == -2
assert Mod(n - 2*p, n - p) == -p
assert Mod(p - 2*n, p - n) == -n
# handling sums
assert (x + 3) % 1 == Mod(x, 1)
assert (x + 3.0) % 1 == Mod(1.*x, 1)
assert (x - S(33)/10) % 1 == Mod(x + S(7)/10, 1)
assert str(Mod(.6*x + y, .3*y)) == str(Mod(0.1*y + 0.6*x, 0.3*y))
assert (x + 1) % x == 1 % x
assert (x + y) % x == y % x
assert (x + y + 2) % x == (y + 2) % x
assert (a + 3*x + 1) % (2*x) == Mod(a + x + 1, 2*x)
assert (12*x + 18*y) % (3*x) == 3*Mod(6*y, x)
# gcd extraction
assert (-3*x) % (-2*y) == -Mod(3*x, 2*y)
assert (.6*pi) % (.3*x*pi) == 0.3*pi*Mod(2, x)
assert (.6*pi) % (.31*x*pi) == pi*Mod(0.6, 0.31*x)
assert (6*pi) % (.3*x*pi) == pi*Mod(6, 0.3*x)
assert (6*pi) % (.31*x*pi) == pi*Mod(6, 0.31*x)
assert (6*pi) % (.42*x*pi) == pi*Mod(6, 0.42*x)
assert (12*x) % (2*y) == 2*Mod(6*x, y)
assert (12*x) % (3*5*y) == 3*Mod(4*x, 5*y)
assert (12*x) % (15*x*y) == 3*x*Mod(4, 5*y)
assert (-2*pi) % (3*pi) == pi
assert (2*x + 2) % (x + 1) == 0
assert (x*(x + 1)) % (x + 1) == (x + 1)*Mod(x, 1)
assert Mod(5.0*x, 0.1*y) == 0.1*Mod(50*x, y)
i = Symbol('i', integer=True)
assert (3*i*x) % (2*i*y) == i*Mod(3*x, 2*y)
assert Mod(4*i, 4) == 0
class TestAllGood(object):
# These latex strings should parse to the corresponding SymPy expression
GOOD_PAIRS = [
("0", Rational(0)),
("1", Rational(1)),
("-3.14", Rational(-314, 100)),
("5-3", _Add(5, _Mul(-1, 3))),
("(-7.13)(1.5)", _Mul(Rational('-7.13'), Rational('1.5'))),
("\\left(-7.13\\right)\\left(1.5\\right)", _Mul(Rational('-7.13'), Rational('1.5'))),
("x", x),
("2x", 2 * x),
("x^2", x**2),
("x^{3 + 1}", x**_Add(3, 1)),
("x^{\\left\\{3 + 1\\right\\}}", x**_Add(3, 1)),
("-3y + 2x", _Add(_Mul(2, x), Mul(-1, 3, y, evaluate=False))),
("-c", -c),
("a \\cdot b", a * b),
("a / b", a / b),
("a \\div b", a / b),
("a + b", a + b),
("a + b - a", Add(a, b, _Mul(-1, a), evaluate=False)),
("a^2 + b^2 = c^2", Eq(a**2 + b**2, c**2)),
("a^2 + b^2 != 2c^2", Ne(a**2 + b**2, 2 * c**2)),
("a\\mod b", Mod(a, b)),
("\\sin \\theta", sin(theta)),
("\\sin(\\theta)", sin(theta)),
("\\sin\\left(\\theta\\right)", sin(theta)),
("\\sin^{-1} a", asin(a)),
("\\sin a \\cos b", _Mul(sin(a), cos(b))),
("\\sin \\cos \\theta", sin(cos(theta))),
("\\sin(\\cos \\theta)", sin(cos(theta))),
("\\arcsin(a)", asin(a)),
("\\arccos(a)", acos(a)),
("\\arctan(a)", atan(a)),
("\\sinh(a)", sinh(a)),
("\\cosh(a)", cosh(a)),
("\\tanh(a)", tanh(a)),
("\\sinh^{-1}(a)", asinh(a)),
("\\cosh^{-1}(a)", acosh(a)),
("\\tanh^{-1}(a)", atanh(a)),
("\\arcsinh(a)", asinh(a)),
("\\arccosh(a)", acosh(a)),
("\\arctanh(a)", atanh(a)),
("\\arsinh(a)", asinh(a)),
("\\arcosh(a)", acosh(a)),
("\\artanh(a)", atanh(a)),
("\\operatorname{arcsinh}(a)", asinh(a)),
("\\operatorname{arccosh}(a)", acosh(a)),
("\\operatorname{arctanh}(a)", atanh(a)),
("\\operatorname{arsinh}(a)", asinh(a)),
("\\operatorname{arcosh}(a)", acosh(a)),
("\\operatorname{artanh}(a)", atanh(a)),
("\\operatorname{gcd}(a, b)", UnevaluatedExpr(gcd(a, b))),
("\\operatorname{lcm}(a, b)", UnevaluatedExpr(lcm(a, b))),
("\\operatorname{gcd}(a,b)", UnevaluatedExpr(gcd(a, b))),
("\\operatorname{lcm}(a,b)", UnevaluatedExpr(lcm(a, b))),
("\\operatorname{floor}(a)", floor(a)),
("\\operatorname{ceil}(b)", ceiling(b)),
("\\cos^2(x)", cos(x)**2),
("\\cos(x)^2", cos(x)**2),
("\\gcd(a, b)", UnevaluatedExpr(gcd(a, b))),
("\\lcm(a, b)", UnevaluatedExpr(lcm(a, b))),
("\\gcd(a,b)", UnevaluatedExpr(gcd(a, b))),
("\\lcm(a,b)", UnevaluatedExpr(lcm(a, b))),
("\\floor(a)", floor(a)),
("\\ceil(b)", ceiling(b)),
("\\max(a, b)", Max(a, b)),
("\\min(a, b)", Min(a, b)),
("\\frac{a}{b}", a / b),
("\\frac{a + b}{c}", _Mul(a + b, _Pow(c, -1))),
("\\frac{7}{3}", Rational(7, 3)),
("(\\csc x)(\\sec y)", csc(x) * sec(y)),
("\\lim_{x \\to 3} a", Limit(a, x, 3)),
("\\lim_{x \\rightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\Rightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\longrightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\Longrightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\to 3^{+}} a", Limit(a, x, 3, dir='+')),
("\\lim_{x \\to 3^{-}} a", Limit(a, x, 3, dir='-')),
("\\infty", oo),
("\\infty\\%", oo),
("\\$\\infty", oo),
("-\\infty", -oo),
("-\\infty\\%", -oo),
("-\\$\\infty", -oo),
("\\lim_{x \\to \\infty} \\frac{1}{x}", Limit(_Mul(1, _Pow(x, -1)), x, oo)),
("\\frac{d}{dx} x", Derivative(x, x)),
("\\frac{d}{dt} x", Derivative(x, t)),
# ("f(x)", f(x)),
# ("f(x, y)", f(x, y)),
# ("f(x, y, z)", f(x, y, z)),
# ("\\frac{d f(x)}{dx}", Derivative(f(x), x)),
# ("\\frac{d\\theta(x)}{dx}", Derivative(theta(x), x)),
("|x|", _Abs(x)),
("\\left|x\\right|", _Abs(x)),
("||x||", _Abs(_Abs(x))),
("|x||y|", _Abs(x) * _Abs(y)),
("||x||y||", _Abs(_Abs(x) * _Abs(y))),
("\\lfloor x\\rfloor", floor(x)),
("\\lceil y\\rceil", ceiling(y)),
("\\pi^{|xy|}", pi**_Abs(x * y)),
("\\frac{\\pi}{3}", _Mul(pi, _Pow(3, -1))),
("\\sin{\\frac{\\pi}{2}}", sin(_Mul(pi, _Pow(2, -1)), evaluate=False)),
("a+bI", a + I * b),
("e^{I\\pi}", Integer(-1)),
("\\int x dx", Integral(x, x)),
("\\int x d\\theta", Integral(x, theta)),
("\\int (x^2 - y)dx", Integral(x**2 - y, x)),
("\\int x + a dx", Integral(_Add(x, a), x)),
("\\int da", Integral(1, a)),
("\\int_0^7 dx", Integral(1, (x, 0, 7))),
("\\int_a^b x dx", Integral(x, (x, a, b))),
("\\int^b_a x dx", Integral(x, (x, a, b))),
("\\int_{a}^b x dx", Integral(x, (x, a, b))),
("\\int^{b}_a x dx", Integral(x, (x, a, b))),
("\\int_{a}^{b} x dx", Integral(x, (x, a, b))),
("\\int_{ }^{}x dx", Integral(x, x)),
("\\int^{ }_{ }x dx", Integral(x, x)),
("\\int^{b}_{a} x dx", Integral(x, (x, a, b))),
# ("\\int_{f(a)}^{f(b)} f(z) dz", Integral(f(z), (z, f(a), f(b)))),
("\\int (x+a)", Integral(_Add(x, a), x)),
("\\int a + b + c dx", Integral(Add(a, b, c, evaluate=False), x)),
("\\int \\frac{dz}{z}", Integral(Pow(z, -1), z)),
("\\int \\frac{3 dz}{z}", Integral(3 * Pow(z, -1), z)),
("\\int \\frac{1}{x} dx", Integral(Pow(x, -1), x)),
("\\int \\frac{1}{a} + \\frac{1}{b} dx", Integral(_Add(_Pow(a, -1), Pow(b, -1)), x)),
("\\int \\frac{3 \\cdot d\\theta}{\\theta}", Integral(3 * _Pow(theta, -1), theta)),
("\\int \\frac{1}{x} + 1 dx", Integral(_Add(_Pow(x, -1), 1), x)),
("x_0", Symbol('x_0', real=True, positive=True)),
("x_{1}", Symbol('x_1', real=True, positive=True)),
("x_a", Symbol('x_a', real=True, positive=True)),
("x_{b}", Symbol('x_b', real=True, positive=True)),
("h_\\theta", Symbol('h_{\\theta}', real=True, positive=True)),
("h_\\theta ", Symbol('h_{\\theta}', real=True, positive=True)),
("h_{\\theta}", Symbol('h_{\\theta}', real=True, positive=True)),
# ("h_{\\theta}(x_0, x_1)", Symbol('h_{theta}', real=True)(Symbol('x_{0}', real=True), Symbol('x_{1}', real=True))),
("x!", _factorial(x)),
("100!", _factorial(100)),
("\\theta!", _factorial(theta)),
("(x + 1)!", _factorial(_Add(x, 1))),
("\\left(x + 1\\right)!", _factorial(_Add(x, 1))),
("(x!)!", _factorial(_factorial(x))),
("x!!!", _factorial(_factorial(_factorial(x)))),
("5!7!", _Mul(_factorial(5), _factorial(7))),
("\\sqrt{x}", sqrt(x)),
("\\sqrt{x + b}", sqrt(_Add(x, b))),
("\\sqrt[3]{\\sin x}", root(sin(x), 3)),
("\\sqrt[y]{\\sin x}", root(sin(x), y)),
("\\sqrt[\\theta]{\\sin x}", root(sin(x), theta)),
("x < y", StrictLessThan(x, y)),
("x \\leq y", LessThan(x, y)),
("x > y", StrictGreaterThan(x, y)),
("x \\geq y", GreaterThan(x, y)),
("\\sum_{k = 1}^{3} c", Sum(c, (k, 1, 3))),
("\\sum_{k = 1}^3 c", Sum(c, (k, 1, 3))),
("\\sum^{3}_{k = 1} c", Sum(c, (k, 1, 3))),
("\\sum^3_{k = 1} c", Sum(c, (k, 1, 3))),
("\\sum_{k = 1}^{10} k^2", Sum(k**2, (k, 1, 10))),
("\\sum_{n = 0}^{\\infty} \\frac{1}{n!}", Sum(_Pow(_factorial(n), -1), (n, 0, oo))),
("\\prod_{a = b}^{c} x", Product(x, (a, b, c))),
("\\prod_{a = b}^c x", Product(x, (a, b, c))),
("\\prod^{c}_{a = b} x", Product(x, (a, b, c))),
("\\prod^c_{a = b} x", Product(x, (a, b, c))),
("\\ln x", _log(x, E)),
("\\ln xy", _log(x * y, E)),
("\\log x", _log(x, 10)),
("\\log xy", _log(x * y, 10)),
# ("\\log_2 x", _log(x, 2)),
("\\log_{2} x", _log(x, 2)),
# ("\\log_a x", _log(x, a)),
("\\log_{a} x", _log(x, a)),
("\\log_{11} x", _log(x, 11)),
("\\log_{a^2} x", _log(x, _Pow(a, 2))),
("[x]", x),
("[a + b]", _Add(a, b)),
("\\frac{d}{dx} [ \\tan x ]", Derivative(tan(x), x)),
("2\\overline{x}", 2 * Symbol('xbar', real=True, positive=True)),
("2\\overline{x}_n", 2 * Symbol('xbar_n', real=True, positive=True)),
("\\frac{x}{\\overline{x}_n}", x / Symbol('xbar_n', real=True, positive=True)),
("\\frac{\\sin(x)}{\\overline{x}_n}", sin(x) / Symbol('xbar_n', real=True, positive=True)),
("2\\bar{x}", 2 * Symbol('xbar', real=True, positive=True)),
("2\\bar{x}_n", 2 * Symbol('xbar_n', real=True, positive=True)),
("\\sin\\left(\\theta\\right) \\cdot4", sin(theta) * 4),
("\\ln\\left(\\theta\\right)", _log(theta, E)),
("\\ln\\left(x-\\theta\\right)", _log(x - theta, E)),
("\\ln\\left(\\left(x-\\theta\\right)\\right)", _log(x - theta, E)),
("\\ln\\left(\\left[x-\\theta\\right]\\right)", _log(x - theta, E)),
("\\ln\\left(\\left\\{x-\\theta\\right\\}\\right)", _log(x - theta, E)),
("\\ln\\left(\\left|x-\\theta\\right|\\right)", _log(_Abs(x - theta), E)),
("\\frac{1}{2}xy(x+y)", Mul(Rational(1, 2), x, y, (x + y), evaluate=False)),
("\\frac{1}{2}\\theta(x+y)", Mul(Rational(1, 2), theta, (x + y), evaluate=False)),
("1-f(x)", 1 - f * x),
("\\begin{matrix}1&2\\\\3&4\\end{matrix}", Matrix([[1, 2], [3, 4]])),
("\\begin{matrix}x&x^2\\\\\\sqrt{x}&x\\end{matrix}", Matrix([[x, x**2], [_Pow(x, S.Half), x]])),
("\\begin{matrix}\\sqrt{x}\\\\\\sin(\\theta)\\end{matrix}", Matrix([_Pow(x, S.Half), sin(theta)])),
("\\begin{pmatrix}1&2\\\\3&4\\end{pmatrix}", Matrix([[1, 2], [3, 4]])),
("\\begin{bmatrix}1&2\\\\3&4\\end{bmatrix}", Matrix([[1, 2], [3, 4]])),
# scientific notation
("2.5\\times 10^2", Rational(250)),
("1,500\\times 10^{-1}", Rational(150)),
# e notation
("2.5E2", Rational(250)),
("1,500E-1", Rational(150)),
# multiplication without cmd
("2x2y", Mul(2, x, 2, y, evaluate=False)),
("2x2", Mul(2, x, 2, evaluate=False)),
("x2", x * 2),
# lin alg processing
("\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(theta, Matrix([[1, 2], [3, 4]]), evaluate=False)),
("\\theta\\begin{matrix}1\\\\3\\end{matrix} - \\begin{matrix}-1\\\\2\\end{matrix}", MatAdd(MatMul(theta, Matrix([[1], [3]]), evaluate=False), MatMul(-1, Matrix([[-1], [2]]), evaluate=False), evaluate=False)),
("\\theta\\begin{matrix}1&0\\\\0&1\\end{matrix}*\\begin{matrix}3\\\\-2\\end{matrix}", MatMul(theta, Matrix([[1, 0], [0, 1]]), Matrix([3, -2]), evaluate=False)),
("\\frac{1}{9}\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(Rational(1, 9), theta, Matrix([[1, 2], [3, 4]]), evaluate=False)),
("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix};\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix},\\begin{pmatrix}1\\\\1\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1]), Matrix([1, 1, 1])]),
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right\\}", Matrix([1, 2, 3])),
("\\left{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right}", Matrix([1, 2, 3])),
("{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}}", Matrix([1, 2, 3])),
# us dollars
("\\$1,000.00", Rational(1000)),
("\\$543.21", Rational(54321, 100)),
("\\$0.009", Rational(9, 1000)),
# percentages
("100\\%", Rational(1)),
("1.5\\%", Rational(15, 1000)),
("0.05\\%", Rational(5, 10000)),
# empty set
("\\emptyset", S.EmptySet),
# divide by zero
("\\frac{1}{0}", _Pow(0, -1)),
("1+\\frac{5}{0}", _Add(1, _Mul(5, _Pow(0, -1)))),
# adjacent single char sub sup
("4^26^2", _Mul(_Pow(4, 2), _Pow(6, 2))),
("x_22^2", _Mul(Symbol('x_2', real=True, positive=True), _Pow(2, 2)))
]
def test_good_pair(self, s, eq):
assert_equal(s, eq)
def block4(exprs, iters, dims):
# Non-perfect loop nest due to conditional
# for i
# if i % 2 == 0
# for j
return iters[0](Conditional(Eq(Mod(dims['i'], 2), 0), iters[1](exprs[0])))
def test_binomial_Mod_slow():
p, q = 10**5 + 3, 10**9 + 33 # prime modulo
r, s = 10**7 + 5, 33333333 # composite modulo
n, k, m = symbols('n k m')
assert (binomial(n, k) % q).subs({n: s, k: p}) == Mod(binomial(s, p), q)
assert (binomial(n, k) % m).subs({n: 8, k: 5, m: 13}) == 4
assert (binomial(9, k) % 7).subs(k, 2) == 1
# Lucas Theorem
assert Mod(binomial(123456, 43253, evaluate=False),
p) == Mod(binomial(123456, 43253), p)
assert Mod(binomial(-178911, 237, evaluate=False),
p) == Mod(-binomial(178911 + 237 - 1, 237), p)
assert Mod(binomial(-178911, 238, evaluate=False),
p) == Mod(binomial(178911 + 238 - 1, 238), p)
# factorial Mod
assert Mod(binomial(9734, 451, evaluate=False),
q) == Mod(binomial(9734, 451), q)
assert Mod(binomial(-10733, 4459, evaluate=False),
q) == Mod(binomial(-10733, 4459), q)
assert Mod(binomial(-15733, 4458, evaluate=False),
q) == Mod(binomial(-15733, 4458), q)
# binomial factorize
assert Mod(binomial(753, 119, evaluate=False),
r) == Mod(binomial(753, 119), r)
assert Mod(binomial(3781, 948, evaluate=False),
s) == Mod(binomial(3781, 948), s)
assert Mod(binomial(25773, 1793, evaluate=False),
s) == Mod(binomial(25773, 1793), s)
assert Mod(binomial(-753, 118, evaluate=False),
r) == Mod(binomial(-753, 118), r)
assert Mod(binomial(-25773, 1793, evaluate=False),
s) == Mod(binomial(-25773, 1793), s)
def test_factorial_Mod():
pr = Symbol('pr', prime=True)
p, q = 10**9 + 9, 10**9 + 33 # prime modulo
r, s = 10**7 + 5, 33333333 # composite modulo
assert Mod(factorial(pr - 1), pr) == pr - 1
assert Mod(factorial(pr - 1), -pr) == -1
assert Mod(factorial(r - 1, evaluate=False), r) == 0
assert Mod(factorial(s - 1, evaluate=False), s) == 0
assert Mod(factorial(p - 1, evaluate=False), p) == p - 1
assert Mod(factorial(q - 1, evaluate=False), q) == q - 1
assert Mod(factorial(p - 50, evaluate=False), p) == 854928834
assert Mod(factorial(q - 1800, evaluate=False), q) == 905504050
assert Mod(factorial(153, evaluate=False), r) == Mod(factorial(153), r)
assert Mod(factorial(255, evaluate=False), s) == Mod(factorial(255), s)