def test_cosh_series():
assert cosh(x).series(x, 0, 10) == \
1 + x**2/2 + x**4/24 + x**6/720 + x**8/40320 + O(x**10)
assert cosh(x).taylor_term(0, x) == 1
assert cosh(x).taylor_term(2, x) == x**2/2
assert cosh(x).taylor_term(2, x, *(1, 0)) == cosh(x).taylor_term(2, x)
def test_simplifications():
assert sinh(asinh(x)) == x
assert sinh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1)
assert sinh(atanh(x)) == x/sqrt(1 - x**2)
assert sinh(acoth(x)) == 1/(sqrt(x - 1) * sqrt(x + 1))
assert cosh(asinh(x)) == sqrt(1 + x**2)
assert cosh(acosh(x)) == x
assert cosh(atanh(x)) == 1/sqrt(1 - x**2)
assert cosh(acoth(x)) == x/(sqrt(x - 1) * sqrt(x + 1))
assert tanh(asinh(x)) == x/sqrt(1 + x**2)
assert tanh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1) / x
assert tanh(atanh(x)) == x
assert tanh(acoth(x)) == 1/x
assert coth(asinh(x)) == sqrt(1 + x**2)/x
assert coth(acosh(x)) == x/(sqrt(x - 1) * sqrt(x + 1))
assert coth(atanh(x)) == 1/x
assert coth(acoth(x)) == x
assert csch(asinh(x)) == 1/x
assert csch(acosh(x)) == 1/(sqrt(x - 1) * sqrt(x + 1))
assert csch(atanh(x)) == sqrt(1 - x**2)/x
assert csch(acoth(x)) == sqrt(x - 1) * sqrt(x + 1)
assert sech(asinh(x)) == 1/sqrt(1 + x**2)
assert sech(acosh(x)) == 1/x
assert sech(atanh(x)) == sqrt(1 - x**2)
assert sech(acoth(x)) == sqrt(x - 1) * sqrt(x + 1)/x
def test_ode_solutions():
# only a few examples here, the rest will be tested in the actual dsolve tests
assert constant_renumber(constantsimp(C1*exp(2*x) + exp(x)*(C2 + C3), [C1, C2, C3]), 'C', 1, 3) == \
constant_renumber((C1*exp(x) + C2*exp(2*x)), 'C', 1, 2)
assert constant_renumber(
constantsimp(Eq(f(x), I*C1*sinh(x/3) + C2*cosh(x/3)), [C1, C2]),
'C', 1, 2) == constant_renumber(Eq(f(x), C1*sinh(x/3) + C2*cosh(x/3)), 'C', 1, 2)
assert constant_renumber(constantsimp(Eq(f(x), acos((-C1)/cos(x))), [C1]), 'C', 1, 1) == \
Eq(f(x), acos(C1/cos(x)))
assert constant_renumber(
constantsimp(Eq(log(f(x)/C1) + 2*exp(x/f(x)), 0), [C1]),
'C', 1, 1) == Eq(log(C1*f(x)) + 2*exp(x/f(x)), 0)
assert constant_renumber(constantsimp(Eq(log(x*sqrt(2)*sqrt(1/x)*sqrt(f(x))
/ C1) + x**2/(2*f(x)**2), 0), [C1]), 'C', 1, 1) == \
Eq(log(C1*sqrt(x)*sqrt(f(x))) + x**2/(2*f(x)**2), 0)
assert constant_renumber(constantsimp(Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(x/C1) -
cos(f(x)/x)*exp(-f(x)/x)/2, 0), [C1]), 'C', 1, 1) == \
Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(C1*x) - cos(f(x)/x) *
exp(-f(x)/x)/2, 0)
u2 = Symbol('u2')
_a = Symbol('_a')
assert constant_renumber(constantsimp(Eq(-Integral(-1/(sqrt(1 - u2**2)*u2),
(u2, _a, x/f(x))) + log(f(x)/C1), 0), [C1]), 'C', 1, 1) == \
Eq(-Integral(-1/(u2*sqrt(1 - u2**2)), (u2, _a, x/f(x))) +
log(C1*f(x)), 0)
assert [constantsimp(i, [C1]) for i in [Eq(f(x), sqrt(-C1*x + x**2)), Eq(f(x), -sqrt(-C1*x + x**2))]] == \
[Eq(f(x), sqrt(x*(C1 + x))), Eq(f(x), -sqrt(x*(C1 + x)))]
def test_heurisch_hyperbolic():
assert heurisch(sinh(x), x) == cosh(x)
assert heurisch(cosh(x), x) == sinh(x)
assert heurisch(x*sinh(x), x) == x*cosh(x) - sinh(x)
assert heurisch(x*cosh(x), x) == x*sinh(x) - cosh(x)
assert heurisch(
x*asinh(x/2), x) == x**2*asinh(x/2)/2 + asinh(x/2) - x*sqrt(4 + x**2)/4
def test_sympyissue_3210():
eqs = (sin(2)*cos(3) + sin(3)*cos(2),
-sin(2)*sin(3) + cos(2)*cos(3),
sin(2)*cos(3) - sin(3)*cos(2),
sin(2)*sin(3) + cos(2)*cos(3),
sin(2)*sin(3) + cos(2)*cos(3) + cos(2),
sinh(2)*cosh(3) + sinh(3)*cosh(2),
sinh(2)*sinh(3) + cosh(2)*cosh(3))
assert [trigsimp(e) for e in eqs] == [sin(5), cos(5), -sin(1), cos(1),
cos(1) + cos(2), sinh(5), cosh(5)]
def test_sympyissue_8368_7173():
LT = laplace_transform
# hyperbolic
assert LT(sinh(x), x, s) == (1/(s**2 - 1), 1, True)
assert LT(cosh(x), x, s) == (s/(s**2 - 1), 1, True)
assert LT(sinh(x + 3), x, s) == (
(s*sinh(3) + cosh(3))/(s**2 - 1), 1, True)
assert LT(sinh(x)*cosh(x), x, s) == (1/(s**2 - 4), 2, Ne(s/2, 1))
# trig (make sure they are not being rewritten in terms of exp)
assert LT(cos(x + 3), x, s) == ((s*cos(3) - sin(3))/(s**2 + 1), 0, True)
def test_derivs():
assert coth(x).diff(x) == -sinh(x)**(-2)
assert sinh(x).diff(x) == cosh(x)
assert cosh(x).diff(x) == sinh(x)
assert tanh(x).diff(x) == -tanh(x)**2 + 1
assert csch(x).diff(x) == -coth(x)*csch(x)
assert sech(x).diff(x) == -tanh(x)*sech(x)
assert acoth(x).diff(x) == 1/(-x**2 + 1)
assert asinh(x).diff(x) == 1/sqrt(x**2 + 1)
assert acosh(x).diff(x) == 1/sqrt(x**2 - 1)
assert atanh(x).diff(x) == 1/(-x**2 + 1)
def test_gruntz_hyperbolic():
assert gruntz(cosh(x), x) == oo
assert gruntz(cosh(-x), x) == oo
assert gruntz(sinh(x), x) == oo
assert gruntz(sinh(-x), x) == -oo
assert gruntz(2*cosh(x)*exp(x), x) == oo
assert gruntz(2*cosh(-x)*exp(-x), x) == 1
assert gruntz(2*sinh(x)*exp(x), x) == oo
assert gruntz(2*sinh(-x)*exp(-x), x) == -1
assert gruntz(tanh(x), x) == 1
assert gruntz(tanh(-x), x) == -1
assert gruntz(coth(x), x) == 1
assert gruntz(coth(-x), x) == -1
def test_trigsimp1a():
assert trigsimp(sin(2)**2*cos(3)*exp(2)/cos(2)**2) == tan(2)**2*cos(3)*exp(2)
assert trigsimp(tan(2)**2*cos(3)*exp(2)*cos(2)**2) == sin(2)**2*cos(3)*exp(2)
assert trigsimp(cot(2)*cos(3)*exp(2)*sin(2)) == cos(3)*exp(2)*cos(2)
assert trigsimp(tan(2)*cos(3)*exp(2)/sin(2)) == cos(3)*exp(2)/cos(2)
assert trigsimp(cot(2)*cos(3)*exp(2)/cos(2)) == cos(3)*exp(2)/sin(2)
assert trigsimp(cot(2)*cos(3)*exp(2)*tan(2)) == cos(3)*exp(2)
assert trigsimp(sinh(2)*cos(3)*exp(2)/cosh(2)) == tanh(2)*cos(3)*exp(2)
assert trigsimp(tanh(2)*cos(3)*exp(2)*cosh(2)) == sinh(2)*cos(3)*exp(2)
assert trigsimp(coth(2)*cos(3)*exp(2)*sinh(2)) == cosh(2)*cos(3)*exp(2)
assert trigsimp(tanh(2)*cos(3)*exp(2)/sinh(2)) == cos(3)*exp(2)/cosh(2)
assert trigsimp(coth(2)*cos(3)*exp(2)/cosh(2)) == cos(3)*exp(2)/sinh(2)
assert trigsimp(coth(2)*cos(3)*exp(2)*tanh(2)) == cos(3)*exp(2)
def test_expint():
""" Test various exponential integrals. """
assert simplify(integrate(exp(-z*x)/x**y,
(x, 1, oo),
meijerg=True,
conds='none').rewrite(expint)) == expint(y, z)
assert integrate(exp(-z*x)/x, (x, 1, oo), meijerg=True,
conds='none').rewrite(expint).expand() == \
expint(1, z)
assert integrate(exp(-z*x)/x**2, (x, 1, oo), meijerg=True,
conds='none').rewrite(expint).expand() == \
expint(2, z).rewrite(Ei).rewrite(expint)
assert integrate(exp(-z*x)/x**3, (x, 1, oo), meijerg=True,
conds='none').rewrite(expint).expand() == \
expint(3, z).rewrite(Ei).rewrite(expint).expand()
t = Symbol('t', positive=True)
assert integrate(-cos(x)/x, (x, t, oo), meijerg=True).expand() == Ci(t)
assert integrate(-sin(x)/x, (x, t, oo), meijerg=True).expand() == \
Si(t) - pi/2
assert integrate(sin(x)/x, (x, 0, z), meijerg=True) == Si(z)
assert integrate(sinh(x)/x, (x, 0, z), meijerg=True) == Shi(z)
assert integrate(exp(-x)/x, x, meijerg=True).expand().rewrite(expint) == \
I*pi - expint(1, x)
assert integrate(exp(-x)/x**2, x, meijerg=True).rewrite(expint).expand() \
== expint(1, x) - exp(-x)/x - I*pi
u = Symbol('u', polar=True)
assert integrate(cos(u)/u, u, meijerg=True).expand().as_independent(u)[1] \
== Ci(u)
assert integrate(cosh(u)/u, u, meijerg=True).expand().as_independent(u)[1] \
== Chi(u)
assert (integrate(expint(1, x), x,
meijerg=True).rewrite(expint).expand() ==
x*expint(1, x) - exp(-x))
assert (integrate(expint(2, x), x,
meijerg=True).rewrite(expint).expand() ==
-x**2*expint(1, x)/2 + x*exp(-x)/2 - exp(-x)/2)
assert (simplify(unpolarify(integrate(expint(y, x), x,
meijerg=True).rewrite(expint))) ==
-expint(y + 1, x))
assert integrate(Si(x), x, meijerg=True) == x*Si(x) + cos(x)
assert integrate(Ci(u), u, meijerg=True).expand() == u*Ci(u) - sin(u)
assert integrate(Shi(x), x, meijerg=True) == x*Shi(x) - cosh(x)
assert integrate(Chi(u), u, meijerg=True).expand() == u*Chi(u) - sinh(u)
assert integrate(Si(x)*exp(-x), (x, 0, oo), meijerg=True) == pi/4
assert integrate(expint(1, x)*sin(x), (x, 0, oo), meijerg=True) == log(2)/2
def test_trigsimp_noncommutative():
A, B = symbols('A,B', commutative=False)
assert trigsimp(A - A*sin(x)**2) == A*cos(x)**2
assert trigsimp(A - A*cos(x)**2) == A*sin(x)**2
assert trigsimp(A*sin(x)**2 + A*cos(x)**2) == A
assert trigsimp(A + A*tan(x)**2) == A/cos(x)**2
assert trigsimp(A/cos(x)**2 - A) == A*tan(x)**2
assert trigsimp(A/cos(x)**2 - A*tan(x)**2) == A
assert trigsimp(A + A*cot(x)**2) == A/sin(x)**2
assert trigsimp(A/sin(x)**2 - A) == A/tan(x)**2
assert trigsimp(A/sin(x)**2 - A*cot(x)**2) == A
assert trigsimp(y*A*cos(x)**2 + y*A*sin(x)**2) == y*A
assert trigsimp(A*sin(x)/cos(x)) == A*tan(x)
assert trigsimp(A*tan(x)*cos(x)) == A*sin(x)
assert trigsimp(A*cot(x)**3*sin(x)**3) == A*cos(x)**3
assert trigsimp(y*A*tan(x)**2/sin(x)**2) == y*A/cos(x)**2
assert trigsimp(A*cot(x)/cos(x)) == A/sin(x)
assert trigsimp(A*sin(x + y) + A*sin(x - y)) == 2*A*sin(x)*cos(y)
assert trigsimp(A*sin(x + y) - A*sin(x - y)) == 2*A*sin(y)*cos(x)
assert trigsimp(A*cos(x + y) + A*cos(x - y)) == 2*A*cos(x)*cos(y)
assert trigsimp(A*cos(x + y) - A*cos(x - y)) == -2*A*sin(x)*sin(y)
assert trigsimp(A*sinh(x + y) + A*sinh(x - y)) == 2*A*sinh(x)*cosh(y)
assert trigsimp(A*sinh(x + y) - A*sinh(x - y)) == 2*A*sinh(y)*cosh(x)
assert trigsimp(A*cosh(x + y) + A*cosh(x - y)) == 2*A*cosh(x)*cosh(y)
assert trigsimp(A*cosh(x + y) - A*cosh(x - y)) == 2*A*sinh(x)*sinh(y)
assert trigsimp(A*cos(0.12345)**2 + A*sin(0.12345)**2) == 1.0*A
def test_sympyissue_7173():
assert laplace_transform(sinh(a*x)*cosh(a*x), x, s) == \
(a/(s**2 - 4*a**2), 0,
And(Or(Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <
pi/2, Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <=
pi/2), Or(Abs(periodic_argument(a, oo)) < pi/2,
Abs(periodic_argument(a, oo)) <= pi/2)))
def test_intrinsic_math1_codegen():
# not included: log10
name_expr = [
("test_fabs", abs(x)),
("test_acos", acos(x)),
("test_asin", asin(x)),
("test_atan", atan(x)),
("test_cos", cos(x)),
("test_cosh", cosh(x)),
("test_log", log(x)),
("test_ln", ln(x)),
("test_sin", sin(x)),
("test_sinh", sinh(x)),
("test_sqrt", sqrt(x)),
("test_tan", tan(x)),
("test_tanh", tanh(x)),
]
numerical_tests = []
for name, expr in name_expr:
for xval in 0.2, 0.5, 0.8:
expected = N(expr.subs({x: xval}), strict=False)
numerical_tests.append((name, (xval,), expected, 1e-14))
for lang, commands in valid_lang_commands:
if lang == "C":
name_expr_C = [("test_floor", floor(x)), ("test_ceil", ceiling(x))]
else:
name_expr_C = []
run_test("intrinsic_math1", name_expr + name_expr_C,
numerical_tests, lang, commands)
def test_sympyissue_8368():
assert integrate(exp(-s*x)*cosh(x), (x, 0, oo)) == \
Piecewise((pi*Piecewise((-s/(pi*(-s**2 + 1)), Abs(s**2) < 1),
(1/(pi*s*(1 - 1/s**2)), Abs(s**(-2)) < 1), (meijerg(((Rational(1, 2),), (0, 0)),
((0, Rational(1, 2)), (0,)), polar_lift(s)**2), True)),
And(Abs(periodic_argument(polar_lift(s)**2, oo)) < pi, Ne(s**2, 1),
cos(Abs(periodic_argument(polar_lift(s)**2, oo))/2)*sqrt(Abs(s**2)) -
1 > 0)), (Integral(exp(-s*x)*cosh(x), (x, 0, oo)), True))
assert integrate(exp(-s*x)*sinh(x), (x, 0, oo)) == \
Piecewise((pi*Piecewise((2/(pi*(2*s**2 - 2)), Abs(s**2) < 1),
(-2/(pi*s**2*(-2 + 2/s**2)), Abs(s**(-2)) < 1),
(meijerg(((0,), (Rational(-1, 2), Rational(1, 2))),
((0, Rational(1, 2)), (Rational(-1, 2),)),
polar_lift(s)**2), True)),
And(Abs(periodic_argument(polar_lift(s)**2, oo)) < pi, Ne(s**2, 1),
cos(Abs(periodic_argument(polar_lift(s)**2, oo))/2)*sqrt(Abs(s**2)) - 1 > 0)),
(Integral(E**(-s*x)*sinh(x), (x, 0, oo)), True))
def test_inverses():
assert sinh(x).inverse() == asinh
pytest.raises(AttributeError, lambda: cosh(x).inverse())
assert tanh(x).inverse() == atanh
assert coth(x).inverse() == acoth
assert asinh(x).inverse() == sinh
assert acosh(x).inverse() == cosh
assert atanh(x).inverse() == tanh
assert acoth(x).inverse() == coth
def test_hyperbolic():
assert sinh(x).nseries(x, n=6) == x + x**3/6 + x**5/120 + O(x**7)
assert cosh(x).nseries(x, n=5) == 1 + x**2/2 + x**4/24 + O(x**6)
assert tanh(x).nseries(x, n=6) == x - x**3/3 + 2*x**5/15 + O(x**7)
assert coth(x).nseries(x, n=6) == \
1/x - x**3/45 + x/3 + 2*x**5/945 + O(x**7)
assert asinh(x).nseries(x, n=6) == x - x**3/6 + 3*x**5/40 + O(x**7)
assert acosh(x).nseries(x, n=6) == \
pi*I/2 - I*x - 3*I*x**5/40 - I*x**3/6 + O(x**7)
assert atanh(x).nseries(x, n=6) == x + x**3/3 + x**5/5 + O(x**7)
assert acoth(x).nseries(x, n=6) == x + x**3/3 + x**5/5 + pi*I/2 + O(x**7)
def test_evalc():
x = Symbol("x", extended_real=True)
y = Symbol("y", extended_real=True)
z = Symbol("z")
assert ((x + I*y)**2).expand(complex=True) == x**2 + 2*I*x*y - y**2
assert expand_complex(z**(2*I)) == (re((re(z) + I*im(z))**(2*I)) +
I*im((re(z) + I*im(z))**(2*I)))
assert expand_complex(
z**(2*I), deep=False) == I*im(z**(2*I)) + re(z**(2*I))
assert exp(I*x) != cos(x) + I*sin(x)
assert exp(I*x).expand(complex=True) == cos(x) + I*sin(x)
assert exp(I*x + y).expand(complex=True) == exp(y)*cos(x) + I*sin(x)*exp(y)
assert sin(I*x).expand(complex=True) == I * sinh(x)
assert sin(x + I*y).expand(complex=True) == sin(x)*cosh(y) + \
I * sinh(y) * cos(x)
assert cos(I*x).expand(complex=True) == cosh(x)
assert cos(x + I*y).expand(complex=True) == cos(x)*cosh(y) - \
I * sinh(y) * sin(x)
assert tan(I*x).expand(complex=True) == tanh(x) * I
assert tan(x + I*y).expand(complex=True) == (
sin(2*x)/(cos(2*x) + cosh(2*y)) +
I*sinh(2*y)/(cos(2*x) + cosh(2*y)))
assert sinh(I*x).expand(complex=True) == I * sin(x)
assert sinh(x + I*y).expand(complex=True) == sinh(x)*cos(y) + \
I * sin(y) * cosh(x)
assert cosh(I*x).expand(complex=True) == cos(x)
assert cosh(x + I*y).expand(complex=True) == cosh(x)*cos(y) + \
I * sin(y) * sinh(x)
assert tanh(I*x).expand(complex=True) == tan(x) * I
assert tanh(x + I*y).expand(complex=True) == (
(sinh(x)*cosh(x) + I*cos(y)*sin(y)) /
(sinh(x)**2 + cos(y)**2)).expand()
def test_conjugate():
a = Symbol("a", extended_real=True)
b = Symbol("b", extended_real=True)
c = Symbol("c", imaginary=True)
d = Symbol("d", imaginary=True)
x = Symbol('x')
z = a + I*b + c + I*d
zc = a - I*b - c + I*d
assert conjugate(z) == zc
assert conjugate(exp(z)) == exp(zc)
assert conjugate(exp(I*x)) == exp(-I*conjugate(x))
assert conjugate(z**5) == zc**5
assert conjugate(abs(x)) == abs(x)
assert conjugate(sign(z)) == sign(zc)
assert conjugate(sin(z)) == sin(zc)
assert conjugate(cos(z)) == cos(zc)
assert conjugate(tan(z)) == tan(zc)
assert conjugate(cot(z)) == cot(zc)
assert conjugate(sinh(z)) == sinh(zc)
assert conjugate(cosh(z)) == cosh(zc)
assert conjugate(tanh(z)) == tanh(zc)
assert conjugate(coth(z)) == coth(zc)
def test_ansi_math1_codegen():
# not included: log10
name_expr = [
("test_fabs", Abs(x)),
("test_acos", acos(x)),
("test_asin", asin(x)),
("test_atan", atan(x)),
("test_ceil", ceiling(x)),
("test_cos", cos(x)),
("test_cosh", cosh(x)),
("test_floor", floor(x)),
("test_log", log(x)),
("test_ln", ln(x)),
("test_sin", sin(x)),
("test_sinh", sinh(x)),
("test_sqrt", sqrt(x)),
("test_tan", tan(x)),
("test_tanh", tanh(x)),
]
result = codegen(name_expr, "C", "file", header=False, empty=False)
assert result[0][0] == "file.c"
assert result[0][1] == (
'#include "file.h"\n#include <math.h>\n'
'double test_fabs(double x) {\n double test_fabs_result;\n test_fabs_result = fabs(x);\n return test_fabs_result;\n}\n'
'double test_acos(double x) {\n double test_acos_result;\n test_acos_result = acos(x);\n return test_acos_result;\n}\n'
'double test_asin(double x) {\n double test_asin_result;\n test_asin_result = asin(x);\n return test_asin_result;\n}\n'
'double test_atan(double x) {\n double test_atan_result;\n test_atan_result = atan(x);\n return test_atan_result;\n}\n'
'double test_ceil(double x) {\n double test_ceil_result;\n test_ceil_result = ceil(x);\n return test_ceil_result;\n}\n'
'double test_cos(double x) {\n double test_cos_result;\n test_cos_result = cos(x);\n return test_cos_result;\n}\n'
'double test_cosh(double x) {\n double test_cosh_result;\n test_cosh_result = cosh(x);\n return test_cosh_result;\n}\n'
'double test_floor(double x) {\n double test_floor_result;\n test_floor_result = floor(x);\n return test_floor_result;\n}\n'
'double test_log(double x) {\n double test_log_result;\n test_log_result = log(x);\n return test_log_result;\n}\n'
'double test_ln(double x) {\n double test_ln_result;\n test_ln_result = log(x);\n return test_ln_result;\n}\n'
'double test_sin(double x) {\n double test_sin_result;\n test_sin_result = sin(x);\n return test_sin_result;\n}\n'
'double test_sinh(double x) {\n double test_sinh_result;\n test_sinh_result = sinh(x);\n return test_sinh_result;\n}\n'
'double test_sqrt(double x) {\n double test_sqrt_result;\n test_sqrt_result = sqrt(x);\n return test_sqrt_result;\n}\n'
'double test_tan(double x) {\n double test_tan_result;\n test_tan_result = tan(x);\n return test_tan_result;\n}\n'
'double test_tanh(double x) {\n double test_tanh_result;\n test_tanh_result = tanh(x);\n return test_tanh_result;\n}\n'
)
assert result[1][0] == "file.h"
assert result[1][1] == (
'#ifndef PROJECT__FILE__H\n#define PROJECT__FILE__H\n'
'double test_fabs(double x);\ndouble test_acos(double x);\n'
'double test_asin(double x);\ndouble test_atan(double x);\n'
'double test_ceil(double x);\ndouble test_cos(double x);\n'
'double test_cosh(double x);\ndouble test_floor(double x);\n'
'double test_log(double x);\ndouble test_ln(double x);\n'
'double test_sin(double x);\ndouble test_sinh(double x);\n'
'double test_sqrt(double x);\ndouble test_tan(double x);\n'
'double test_tanh(double x);\n#endif\n'
)
def test_hyper_as_trig():
eq = sinh(x)**2 + cosh(x)**2
t, f = hyper_as_trig(eq)
assert f(fu(t)) == cosh(2*x)
e, f = hyper_as_trig(tanh(x + y))
assert f(TR12(e)) == (tanh(x) + tanh(y))/(tanh(x)*tanh(y) + 1)
d = Dummy()
assert o(sinh(x), d) == I*sin(x*d)
assert o(tanh(x), d) == I*tan(x*d)
assert o(coth(x), d) == cot(x*d)/I
assert o(cosh(x), d) == cos(x*d)
for func in (sinh, cosh, tanh, coth):
h = func(pi)
assert i(o(h, d), d) == h
# /!\ the _osborne functions are not meant to work
# in the o(i(trig, d), d) direction so we just check
# that they work as they are supposed to work
assert i(cos(x*y), y) == cosh(x)
assert i(sin(x*y), y) == sinh(x)/I
assert i(tan(x*y), y) == tanh(x)/I
assert i(cot(x*y), y) == coth(x)*I
assert i(sec(x*y), y) == 1/cosh(x)
assert i(csc(x*y), y) == I/sinh(x)
def test_leading_term():
assert cosh(x).as_leading_term(x) == 1
assert coth(x).as_leading_term(x) == 1/x
assert acosh(x).as_leading_term(x) == I*pi/2
assert acoth(x).as_leading_term(x) == I*pi/2
for func in [sinh, tanh, asinh, atanh]:
assert func(x).as_leading_term(x) == x
for func in [sinh, cosh, tanh, coth, asinh, acosh, atanh, acoth]:
for arg in (1/x, Rational(1, 2)):
eq = func(arg)
assert eq.as_leading_term(x) == eq
for func in [csch, sech]:
eq = func(Rational(1, 2))
assert eq.as_leading_term(x) == eq
assert csch(x).as_leading_term(x) == 1/x
def test_trigsimp1():
assert trigsimp(1 - sin(x)**2) == cos(x)**2
assert trigsimp(1 - cos(x)**2) == sin(x)**2
assert trigsimp(sin(x)**2 + cos(x)**2) == 1
assert trigsimp(1 + tan(x)**2) == 1/cos(x)**2
assert trigsimp(1/cos(x)**2 - 1) == tan(x)**2
assert trigsimp(1/cos(x)**2 - tan(x)**2) == 1
assert trigsimp(1 + cot(x)**2) == 1/sin(x)**2
assert trigsimp(1/sin(x)**2 - 1) == 1/tan(x)**2
assert trigsimp(1/sin(x)**2 - cot(x)**2) == 1
assert trigsimp(5*cos(x)**2 + 5*sin(x)**2) == 5
assert trigsimp(5*cos(x/2)**2 + 2*sin(x/2)**2) == 3*cos(x)/2 + Rational(7, 2)
assert trigsimp(sin(x)/cos(x)) == tan(x)
assert trigsimp(2*tan(x)*cos(x)) == 2*sin(x)
assert trigsimp(cot(x)**3*sin(x)**3) == cos(x)**3
assert trigsimp(y*tan(x)**2/sin(x)**2) == y/cos(x)**2
assert trigsimp(cot(x)/cos(x)) == 1/sin(x)
assert trigsimp(sin(x + y) + sin(x - y)) == 2*sin(x)*cos(y)
assert trigsimp(sin(x + y) - sin(x - y)) == 2*sin(y)*cos(x)
assert trigsimp(cos(x + y) + cos(x - y)) == 2*cos(x)*cos(y)
assert trigsimp(cos(x + y) - cos(x - y)) == -2*sin(x)*sin(y)
assert trigsimp(tan(x + y) - tan(x)/(1 - tan(x)*tan(y))) == \
sin(y)/(-sin(y)*tan(x) + cos(y)) # -tan(y)/(tan(x)*tan(y) - 1)
assert trigsimp(sinh(x + y) + sinh(x - y)) == 2*sinh(x)*cosh(y)
assert trigsimp(sinh(x + y) - sinh(x - y)) == 2*sinh(y)*cosh(x)
assert trigsimp(cosh(x + y) + cosh(x - y)) == 2*cosh(x)*cosh(y)
assert trigsimp(cosh(x + y) - cosh(x - y)) == 2*sinh(x)*sinh(y)
assert trigsimp(tanh(x + y) - tanh(x)/(1 + tanh(x)*tanh(y))) == \
sinh(y)/(sinh(y)*tanh(x) + cosh(y))
assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2) == 1
e = 2*sin(x)**2 + 2*cos(x)**2
assert trigsimp(log(e)) == log(2)
def test_inverse_laplace_transform():
ILT = inverse_laplace_transform
a, b, c, = symbols('a b c', positive=True, finite=True)
def simp_hyp(expr):
return factor_terms(expand_mul(expr)).rewrite(sin)
# just test inverses of all of the above
assert ILT(1/s, s, t) == Heaviside(t)
assert ILT(1/s**2, s, t) == t*Heaviside(t)
assert ILT(1/s**5, s, t) == t**4*Heaviside(t)/24
assert ILT(exp(-a*s)/s, s, t) == Heaviside(t - a)
assert ILT(exp(-a*s)/(s + b), s, t) == exp(b*(a - t))*Heaviside(-a + t)
assert ILT(a/(s**2 + a**2), s, t) == sin(a*t)*Heaviside(t)
assert ILT(s/(s**2 + a**2), s, t) == cos(a*t)*Heaviside(t)
# TODO is there a way around simp_hyp?
assert simp_hyp(ILT(a/(s**2 - a**2), s, t)) == sinh(a*t)*Heaviside(t)
assert simp_hyp(ILT(s/(s**2 - a**2), s, t)) == cosh(a*t)*Heaviside(t)
assert ILT(a/((s + b)**2 + a**2), s, t) == exp(-b*t)*sin(a*t)*Heaviside(t)
assert ILT(
(s + b)/((s + b)**2 + a**2), s, t) == exp(-b*t)*cos(a*t)*Heaviside(t)
# TODO sinh/cosh shifted come out a mess. also delayed trig is a mess
# TODO should this simplify further?
assert ILT(exp(-a*s)/s**b, s, t) == \
(t - a)**(b - 1)*Heaviside(t - a)/gamma(b)
assert ILT(exp(-a*s)/sqrt(1 + s**2), s, t) == \
Heaviside(t - a)*besselj(0, a - t) # note: besselj(0, x) is even
# XXX ILT turns these branch factor into trig functions ...
assert simplify(ILT(a**b*(s + sqrt(s**2 - a**2))**(-b)/sqrt(s**2 - a**2),
s, t).rewrite(exp)) == \
Heaviside(t)*besseli(b, a*t)
assert ILT(a**b*(s + sqrt(s**2 + a**2))**(-b)/sqrt(s**2 + a**2),
s, t).rewrite(exp) == \
Heaviside(t)*besselj(b, a*t)
assert ILT(1/(s*sqrt(s + 1)), s, t) == Heaviside(t)*erf(sqrt(t))
# TODO can we make erf(t) work?
assert ILT(1/(s**2*(s**2 + 1)), s, t) == (t - sin(t))*Heaviside(t)
assert ILT( (s * eye(2) - Matrix([[1, 0], [0, 2]])).inv(), s, t) ==\
Matrix([[exp(t)*Heaviside(t), 0], [0, exp(2*t)*Heaviside(t)]])
def test_ci():
m1 = exp_polar(I*pi)
m1_ = exp_polar(-I*pi)
pI = exp_polar(I*pi/2)
mI = exp_polar(-I*pi/2)
assert Ci(m1*x) == Ci(x) + I*pi
assert Ci(m1_*x) == Ci(x) - I*pi
assert Ci(pI*x) == Chi(x) + I*pi/2
assert Ci(mI*x) == Chi(x) - I*pi/2
assert Chi(m1*x) == Chi(x) + I*pi
assert Chi(m1_*x) == Chi(x) - I*pi
assert Chi(pI*x) == Ci(x) + I*pi/2
assert Chi(mI*x) == Ci(x) - I*pi/2
assert Ci(exp_polar(2*I*pi)*x) == Ci(x) + 2*I*pi
assert Chi(exp_polar(-2*I*pi)*x) == Chi(x) - 2*I*pi
assert Chi(exp_polar(2*I*pi)*x) == Chi(x) + 2*I*pi
assert Ci(exp_polar(-2*I*pi)*x) == Ci(x) - 2*I*pi
assert Ci(oo) == 0
assert Ci(-oo) == I*pi
assert Chi(oo) == oo
assert Chi(-oo) == oo
assert mytd(Ci(x), cos(x)/x, x)
assert mytd(Chi(x), cosh(x)/x, x)
assert mytn(Ci(x), Ci(x).rewrite(Ei),
Ei(x*exp_polar(-I*pi/2))/2 + Ei(x*exp_polar(I*pi/2))/2, x)
assert mytn(Chi(x), Chi(x).rewrite(Ei),
Ei(x)/2 + Ei(x*exp_polar(I*pi))/2 - I*pi/2, x)
assert tn_arg(Ci)
assert tn_arg(Chi)
assert Ci(x).nseries(x, n=4) == \
EulerGamma + log(x) - x**2/4 + x**4/96 + O(x**6)
assert Chi(x).nseries(x, n=4) == \
EulerGamma + log(x) + x**2/4 + x**4/96 + O(x**6)
assert limit(log(x) - Ci(2*x), x, 0) == -log(2) - EulerGamma
def test_complex():
a, b = symbols('a,b', extended_real=True)
z = a + b*I
for func in [sinh, cosh, tanh, coth, sech, csch]:
assert func(z).conjugate() == func(a - b*I)
for deep in [True, False]:
assert sinh(z).expand(
complex=True, deep=deep) == sinh(a)*cos(b) + I*cosh(a)*sin(b)
assert cosh(z).expand(
complex=True, deep=deep) == cosh(a)*cos(b) + I*sinh(a)*sin(b)
assert tanh(z).expand(complex=True, deep=deep) == sinh(a)*cosh(
a)/(cos(b)**2 + sinh(a)**2) + I*sin(b)*cos(b)/(cos(b)**2 + sinh(a)**2)
assert coth(z).expand(complex=True, deep=deep) == sinh(a)*cosh(
a)/(sin(b)**2 + sinh(a)**2) - I*sin(b)*cos(b)/(sin(b)**2 + sinh(a)**2)
assert csch(z).expand(complex=True, deep=deep) == cos(b) * sinh(a) / (sin(b)**2
* cosh(a)**2 + cos(b)**2 * sinh(a)**2) - I*sin(b) * cosh(a) / (sin(b)**2
* cosh(a)**2 + cos(b)**2 * sinh(a)**2)
assert sech(z).expand(complex=True, deep=deep) == cos(b) * cosh(a) / (sin(b)**2
* sinh(a)**2 + cos(b)**2 * cosh(a)**2) - I*sin(b) * sinh(a) / (sin(b)**2
* sinh(a)**2 + cos(b)**2 * cosh(a)**2)
def test_mathml_trig():
mml = mp._print(sin(x))
assert mml.childNodes[0].nodeName == 'sin'
mml = mp._print(cos(x))
assert mml.childNodes[0].nodeName == 'cos'
mml = mp._print(tan(x))
assert mml.childNodes[0].nodeName == 'tan'
mml = mp._print(asin(x))
assert mml.childNodes[0].nodeName == 'arcsin'
mml = mp._print(acos(x))
assert mml.childNodes[0].nodeName == 'arccos'
mml = mp._print(atan(x))
assert mml.childNodes[0].nodeName == 'arctan'
mml = mp._print(sinh(x))
assert mml.childNodes[0].nodeName == 'sinh'
mml = mp._print(cosh(x))
assert mml.childNodes[0].nodeName == 'cosh'
mml = mp._print(tanh(x))
assert mml.childNodes[0].nodeName == 'tanh'
mml = mp._print(asinh(x))
assert mml.childNodes[0].nodeName == 'arcsinh'
mml = mp._print(atanh(x))
assert mml.childNodes[0].nodeName == 'arctanh'
mml = mp._print(acosh(x))
assert mml.childNodes[0].nodeName == 'arccosh'
def test_exptrigsimp():
def valid(a, b):
if not (tn(a, b) and a == b):
return False
return True
assert exptrigsimp(exp(x) + exp(-x)) == 2*cosh(x)
assert exptrigsimp(exp(x) - exp(-x)) == 2*sinh(x)
e = [cos(x) + I*sin(x), cos(x) - I*sin(x),
cosh(x) - sinh(x), cosh(x) + sinh(x)]
ok = [exp(I*x), exp(-I*x), exp(-x), exp(x)]
assert all(valid(i, j) for i, j in zip(
[exptrigsimp(ei) for ei in e], ok))
ue = [cos(x) + sin(x), cos(x) - sin(x),
cosh(x) + I*sinh(x), cosh(x) - I*sinh(x)]
assert [exptrigsimp(ei) == ei for ei in ue]
res = []
ok = [y*tanh(1), 1/(y*tanh(1)), I*y*tan(1), -I/(y*tan(1)),
y*tanh(x), 1/(y*tanh(x)), I*y*tan(x), -I/(y*tan(x)),
y*tanh(1 + I), 1/(y*tanh(1 + I))]
for a in (1, I, x, I*x, 1 + I):
w = exp(a)
eq = y*(w - 1/w)/(w + 1/w)
s = simplify(eq)
assert s == exptrigsimp(eq)
res.append(s)
sinv = simplify(1/eq)
assert sinv == exptrigsimp(1/eq)
res.append(sinv)
assert all(valid(i, j) for i, j in zip(res, ok))
for a in range(1, 3):
w = exp(a)
e = w + 1/w
s = simplify(e)
assert s == exptrigsimp(e)
assert valid(s, 2*cosh(a))
e = w - 1/w
s = simplify(e)
assert s == exptrigsimp(e)
assert valid(s, 2*sinh(a))
def test_sympyissue_5236():
assert (cos(1 + I)**3).as_real_imag() == (
-3 * sin(1)**2 * sinh(1)**2 * cos(1) * cosh(1) +
cos(1)**3 * cosh(1)**3,
-3 * cos(1)**2 * cosh(1)**2 * sin(1) * sinh(1) +
sin(1)**3 * sinh(1)**3)
def test_cosh_series():
x = Symbol('x')
assert cosh(x).series(x, 0, 10) == \
1 + x**2/2 + x**4/24 + x**6/720 + x**8/40320 + O(x**10)
def test_sec():
x = symbols('x', extended_real=True)
z = symbols('z')
assert sec.nargs == FiniteSet(1)
assert sec(0) == 1
assert sec(pi) == -1
assert sec(pi/2) == zoo
assert sec(-pi/2) == zoo
assert sec(pi/6) == 2*sqrt(3)/3
assert sec(pi/3) == 2
assert sec(5*pi/2) == zoo
assert sec(9*pi/7) == -sec(2*pi/7)
assert sec(3*pi/4) == -sqrt(2) # issue sympy/sympy#8421
assert sec(I) == sech(1)
assert sec(x*I) == sech(x)
assert sec(-x) == sec(x)
assert sec(asec(x)) == x
assert sec(x).rewrite(exp) == 1/(exp(I*x)/2 + exp(-I*x)/2)
assert sec(x).rewrite(sin) == sec(x)
assert sec(x).rewrite(cos) == 1/cos(x)
assert sec(x).rewrite(tan) == (tan(x/2)**2 + 1)/(-tan(x/2)**2 + 1)
assert sec(x).rewrite(sqrt) == sec(x)
assert sec(z).rewrite(cot) == (cot(z/2)**2 + 1)/(cot(z/2)**2 - 1)
assert sec(z).conjugate() == sec(conjugate(z))
assert (sec(z).as_real_imag() ==
(cos(re(z))*cosh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
cos(re(z))**2*cosh(im(z))**2),
sin(re(z))*sinh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
cos(re(z))**2*cosh(im(z))**2)))
assert sec(x).expand(trig=True) == 1/cos(x)
assert sec(2*x).expand(trig=True) == 1/(2*cos(x)**2 - 1)
assert sec(a).is_algebraic is None
assert sec(na).is_algebraic is False
assert sec(x).as_leading_term() == sec(x)
assert sec(0).is_finite
assert sec(x).is_finite is None
assert sec(pi/2).is_finite is False
assert series(sec(x), x, x0=0, n=6) == 1 + x**2/2 + 5*x**4/24 + O(x**6)
# https://github.com/sympy/sympy/issues/7166
assert series(sqrt(sec(x))) == 1 + x**2/4 + 7*x**4/96 + O(x**6)
# https://github.com/sympy/sympy/issues/7167
assert (series(sqrt(sec(x)), x, x0=pi*3/2, n=4) ==
1/sqrt(x - 3*pi/2) + (x - 3*pi/2)**Rational(3, 2)/12 +
(x - 3*pi/2)**Rational(7, 2)/160 + O((x - 3*pi/2)**4, (x, 3*pi/2)))
assert sec(x).diff(x) == tan(x)*sec(x)
# Taylor Term checks
assert sec(z).taylor_term(4, z) == 5*z**4/24
assert sec(z).taylor_term(6, z) == 61*z**6/720
assert sec(z).taylor_term(5, z) == 0
pytest.raises(ArgumentIndexError, lambda: sec(x).fdiff(2))
def test_csch_rewrite():
assert csch(x).rewrite(exp) == 1 / (exp(x)/2 - exp(-x)/2) \
== csch(x).rewrite('tractable')
assert csch(x).rewrite(cosh) == I / cosh(x + I * pi / 2)
assert csch(x).rewrite(tanh) == (1 - tanh(x / 2)**2) / (2 * tanh(x / 2))
assert csch(x).rewrite(coth) == (coth(x / 2)**2 - 1) / (2 * coth(x / 2))
def test_meijerint():
s, t, mu = symbols('s t mu', extended_real=True)
assert integrate(meijerg([], [], [0], [], s*t)
* meijerg([], [], [mu/2], [-mu/2], t**2/4),
(t, 0, oo)).is_Piecewise
s = symbols('s', positive=True)
assert integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo)) == \
gamma(s + 1)
assert integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo),
meijerg=True) == gamma(s + 1)
assert isinstance(integrate(x**s*meijerg([[], []], [[0], []], x),
(x, 0, oo), meijerg=False),
Integral)
assert meijerint_indefinite(exp(x), x) == exp(x)
# issue sympy/sympy#8368
assert meijerint_indefinite(cosh(x)*exp(-x*t), x) == (
(exp(x*(-t + 1))*(-t - 1) + exp(-x*(t + 1))*(-t + 1))/(t**2 - 1)/2)
# TODO what simplifications should be done automatically?
# This tests "extra case" for antecedents_1.
a, b = symbols('a b', positive=True)
assert simplify(meijerint_definite(x**a, x, 0, b)[0]) == \
b**(a + 1)/(a + 1)
# This tests various conditions and expansions:
assert meijerint_definite((x + 1)**3*exp(-x), x, 0, oo) == (16, True)
# Again, how about simplifications?
sigma, mu = symbols('sigma mu', positive=True)
i, c = meijerint_definite(exp(-((x - mu)/(2*sigma))**2), x, 0, oo)
assert simplify(i) == sqrt(pi)*sigma*(erf(mu/(2*sigma)) + 1)
assert c
i, _ = meijerint_definite(exp(-mu*x)*exp(sigma*x), x, 0, oo)
# TODO it would be nice to test the condition
assert simplify(i) == 1/(mu - sigma)
# Test substitutions to change limits
assert meijerint_definite(exp(x), x, -oo, 2) == (exp(2), True)
# Note: causes a NaN in _check_antecedents
assert expand(meijerint_definite(exp(x), x, 0, I)[0]) == exp(I) - 1
assert expand(meijerint_definite(exp(-x), x, 0, x)[0]) == \
1 - exp(-exp(I*arg(x))*abs(x))
# Test -oo to oo
assert meijerint_definite(exp(-x**2), x, -oo, oo) == (sqrt(pi), True)
assert meijerint_definite(exp(-abs(x)), x, -oo, oo) == (2, True)
assert meijerint_definite(exp(-(2*x - 3)**2), x, -oo, oo) == \
(sqrt(pi)/2, True)
assert meijerint_definite(exp(-abs(2*x - 3)), x, -oo, oo) == (1, True)
assert meijerint_definite(exp(-((x - mu)/sigma)**2/2)/sqrt(2*pi*sigma**2),
x, -oo, oo) == (1, True)
# Test one of the extra conditions for 2 g-functinos
assert meijerint_definite(exp(-x)*sin(x), x, 0, oo) == (Rational(1, 2), True)
# Test a bug
def res(n):
return (1/(1 + x**2)).diff((x, n)).subs({x: 1})*(-1)**n
for n in range(6):
assert integrate(exp(-x)*sin(x)*x**n, (x, 0, oo), meijerg=True) == \
res(n)
# This used to test trigexpand... now it is done by linear substitution
assert simplify(integrate(exp(-x)*sin(x + a), (x, 0, oo), meijerg=True)
) == sqrt(2)*sin(a + pi/4)/2
# Test the condition 14 from prudnikov.
# (This is besselj*besselj in disguise, to stop the product from being
# recognised in the tables.)
a, b, s = symbols('a b s')
assert meijerint_definite(meijerg([], [], [a/2], [-a/2], x/4)
* meijerg([], [], [b/2], [-b/2], x/4)*x**(s - 1), x, 0, oo) == \
(4*2**(2*s - 2)*gamma(-2*s + 1)*gamma(a/2 + b/2 + s)
/ (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1)
* gamma(a/2 + b/2 - s + 1)),
And(0 < -2*re(4*s) + 8, 0 < re(a/2 + b/2 + s), re(2*s) < 1))
# test a bug
assert integrate(sin(x**a)*sin(x**b), (x, 0, oo), meijerg=True) == \
Integral(sin(x**a)*sin(x**b), (x, 0, oo))
# test better hyperexpand
assert integrate(exp(-x**2)*log(x), (x, 0, oo), meijerg=True) == \
(sqrt(pi)*polygamma(0, Rational(1, 2))/4).expand()
# Test hyperexpand bug.
n = symbols('n', integer=True)
assert simplify(integrate(exp(-x)*x**n, x, meijerg=True)) == \
lowergamma(n + 1, x)
# Test a bug with argument 1/x
alpha = symbols('alpha', positive=True)
assert meijerint_definite((2 - x)**alpha*sin(alpha/x), x, 0, 2) == \
(sqrt(pi)*alpha*gamma(alpha + 1)*meijerg(((), (alpha/2 + Rational(1, 2),
alpha/2 + 1)), ((0, 0, Rational(1, 2)), (-Rational(1, 2),)), alpha**2/16)/4, True)
# test a bug related to 3016
a, s = symbols('a s', positive=True)
assert simplify(integrate(x**s*exp(-a*x**2), (x, -oo, oo))) == \
a**(-s/2 - Rational(1, 2))*((-1)**s + 1)*gamma(s/2 + Rational(1, 2))/2
# issue sympy/sympy#6348
assert integrate(exp(I*x)/(1 + x**2),
(x, -oo, oo)).simplify().rewrite(exp) == pi*exp(-1)
# issue sympy/sympy#13536
a = Symbol('a', real=True, positive=True)
assert integrate(1/x**2, (x, oo, a)) == -1/a
def test_sympyissue_4136():
assert cosh(asinh(Rational(3, 2))) == sqrt(Rational(13, 4))
def test_cosh_rewrite():
assert cosh(x).rewrite(exp) == (exp(x) + exp(-x))/2 \
== cosh(x).rewrite('tractable')
assert cosh(x).rewrite(sinh) == -I * sinh(x + I * pi / 2)
assert cosh(x).rewrite(tanh) == (1 + tanh(x / 2)**2) / (1 - tanh(x / 2)**2)
assert cosh(x).rewrite(coth) == (coth(x / 2)**2 + 1) / (coth(x / 2)**2 - 1)
def test_hyperbolic_simp():
assert trigsimp(sinh(x)**2 + 1) == cosh(x)**2
assert trigsimp(cosh(x)**2 - 1) == sinh(x)**2
assert trigsimp(cosh(x)**2 - sinh(x)**2) == 1
assert trigsimp(1 - tanh(x)**2) == 1 / cosh(x)**2
assert trigsimp(1 - 1 / cosh(x)**2) == tanh(x)**2
assert trigsimp(tanh(x)**2 + 1 / cosh(x)**2) == 1
assert trigsimp(coth(x)**2 - 1) == 1 / sinh(x)**2
assert trigsimp(1 / sinh(x)**2 + 1) == 1 / tanh(x)**2
assert trigsimp(coth(x)**2 - 1 / sinh(x)**2) == 1
assert trigsimp(5 * cosh(x)**2 - 5 * sinh(x)**2) == 5
assert trigsimp(5 * cosh(x / 2)**2 -
2 * sinh(x / 2)**2) == 3 * cosh(x) / 2 + Rational(7, 2)
assert trigsimp(sinh(x) / cosh(x)) == tanh(x)
assert trigsimp(tanh(x)) == trigsimp(sinh(x) / cosh(x))
assert trigsimp(cosh(x) / sinh(x)) == 1 / tanh(x)
assert trigsimp(2 * tanh(x) * cosh(x)) == 2 * sinh(x)
assert trigsimp(coth(x)**3 * sinh(x)**3) == cosh(x)**3
assert trigsimp(y * tanh(x)**2 / sinh(x)**2) == y / cosh(x)**2
assert trigsimp(coth(x) / cosh(x)) == 1 / sinh(x)
e = 2 * cosh(x)**2 - 2 * sinh(x)**2
assert trigsimp(log(e)) == log(2)
assert trigsimp(cosh(x)**2 * cosh(y)**2 - cosh(x)**2 * sinh(y)**2 -
sinh(x)**2,
recursive=True) == 1
assert trigsimp(sinh(x)**2 * sinh(y)**2 - sinh(x)**2 * cosh(y)**2 +
cosh(x)**2,
recursive=True) == 1
assert abs(trigsimp(2.0 * cosh(x)**2 - 2.0 * sinh(x)**2) - 2.0) < 1e-10
assert trigsimp(sinh(x)**2 / cosh(x)**2) == tanh(x)**2
assert trigsimp(sinh(x)**3 / cosh(x)**3) == tanh(x)**3
assert trigsimp(sinh(x)**10 / cosh(x)**10) == tanh(x)**10
assert trigsimp(cosh(x)**3 / sinh(x)**3) == 1 / tanh(x)**3
assert trigsimp(cosh(x) / sinh(x)) == 1 / tanh(x)
assert trigsimp(cosh(x)**2 / sinh(x)**2) == 1 / tanh(x)**2
assert trigsimp(cosh(x)**10 / sinh(x)**10) == 1 / tanh(x)**10
assert trigsimp(x * cosh(x) * tanh(x)) == x * sinh(x)
assert trigsimp(-sinh(x) + cosh(x) * tanh(x)) == 0
assert tan(x) != 1 / cot(x) # cot doesn't auto-simplify
assert trigsimp(tan(x) - 1 / cot(x)) == 0
assert trigsimp(3 * tanh(x)**7 - 2 / coth(x)**7) == tanh(x)**7
def test_sympyissue_8901():
assert integrate(sinh(1.0 * x)) == 1.0 * cosh(1.0 * x)
assert integrate(tanh(1.0 * x)) == 1.0 * x - 1.0 * log(tanh(1.0 * x) + 1)
assert integrate(tanh(x)) == x - log(tanh(x) + 1)
def test_sympyissue_8368():
assert meijerint_indefinite(cosh(x)*exp(-x*t), x) == (
(-t - 1)*exp(x) + (-t + 1)*exp(-x))*exp(-t*x)/2/(t**2 - 1)
def test_trigsimp_sympyissue_7761():
assert trigsimp(cosh(pi / 4)) == cosh(pi / 4)
def test_unrad1():
pytest.raises(NotImplementedError,
lambda: unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x)) + 3))
pytest.raises(
NotImplementedError,
lambda: unrad(sqrt(x) + (x + 1)**Rational(1, 3) + 2 * sqrt(y)))
s = symbols('s', cls=Dummy)
# checkers to deal with possibility of answer coming
# back with a sign change (cf issue sympy/sympy#5203)
def check(rv, ans):
assert bool(rv[1]) == bool(ans[1])
if ans[1]:
return s_check(rv, ans)
e = rv[0].expand()
a = ans[0].expand()
return e in [a, -a] and rv[1] == ans[1]
def s_check(rv, ans):
# get the dummy
rv = list(rv)
d = rv[0].atoms(Dummy)
reps = list(zip(d, [s] * len(d)))
# replace s with this dummy
rv = (rv[0].subs(reps).expand(),
[rv[1][0].subs(reps), rv[1][1].subs(reps)])
ans = (ans[0].subs(reps).expand(),
[ans[1][0].subs(reps), ans[1][1].subs(reps)])
return str(rv[0]) in [str(ans[0]), str(-ans[0])] and \
str(rv[1]) == str(ans[1])
assert check(unrad(sqrt(x)), (x, []))
assert check(unrad(sqrt(x) + 1), (x - 1, []))
assert check(unrad(sqrt(x) + root(x, 3) + 2),
(s**3 + s**2 + 2, [s, s**6 - x]))
assert check(unrad(sqrt(x) * root(x, 3) + 2), (x**5 - 64, []))
assert check(unrad(sqrt(x) + (x + 1)**Rational(1, 3)),
(x**3 - (x + 1)**2, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(2 * x)),
(-2 * sqrt(2) * x - 2 * x + 1, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + 2), (16 * x - 9, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - x)),
(5 * x**2 - 4 * x, []))
assert check(unrad(a * sqrt(x) + b * sqrt(x) + c * sqrt(y) + d * sqrt(y)),
((a * sqrt(x) + b * sqrt(x))**2 -
(c * sqrt(y) + d * sqrt(y))**2, []))
assert check(unrad(sqrt(x) + sqrt(1 - x)), (2 * x - 1, []))
assert check(unrad(sqrt(x) + sqrt(1 - x) - 3), (x**2 - x + 16, []))
assert check(unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x)),
(5 * x**2 - 2 * x + 1, []))
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - 3) in [
(25 * x**4 + 376 * x**3 + 1256 * x**2 - 2272 * x + 784, []),
(25 * x**8 - 476 * x**6 + 2534 * x**4 - 1468 * x**2 + 169, [])
]
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - sqrt(1 - 2*x)) == \
(41*x**4 + 40*x**3 + 232*x**2 - 160*x + 16, []) # orig root at 0.487
assert check(unrad(sqrt(x) + sqrt(x + 1)), (Integer(1), []))
eq = sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x))
assert check(unrad(eq), (16 * x**2 - 9 * x, []))
assert set(solve(eq, check=False)) == {Integer(0), Rational(9, 16)}
assert solve(eq) == []
# but this one really does have those solutions
assert set(solve(sqrt(x) - sqrt(x + 1) + sqrt(1 - sqrt(x)))) == \
{S.Zero, Rational(9, 16)}
assert check(unrad(sqrt(x) + root(x + 1, 3) + 2 * sqrt(y), y),
(2 * sqrt(x) * (x + 1)**Rational(1, 3) + x - 4 * y +
(x + 1)**Rational(2, 3), []))
assert check(unrad(sqrt(x / (1 - x)) + (x + 1)**Rational(1, 3)),
(x**5 - x**4 - x**3 + 2 * x**2 + x - 1, []))
assert check(unrad(sqrt(x / (1 - x)) + 2 * sqrt(y), y),
(4 * x * y + x - 4 * y, []))
assert check(unrad(sqrt(x) * sqrt(1 - x) + 2, x), (x**2 - x + 4, []))
# http://tutorial.math.lamar.edu/
# Classes/Alg/SolveRadicalEqns.aspx#Solve_Rad_Ex2_a
assert solve(Eq(x, sqrt(x + 6))) == [3]
assert solve(Eq(x + sqrt(x - 4), 4)) == [4]
assert solve(Eq(1, x + sqrt(2 * x - 3))) == []
assert set(solve(Eq(sqrt(5 * x + 6) - 2, x))) == {-Integer(1), Integer(2)}
assert set(solve(Eq(sqrt(2 * x - 1) - sqrt(x - 4),
2))) == {Integer(5), Integer(13)}
assert solve(Eq(sqrt(x + 7) + 2, sqrt(3 - x))) == [-6]
# http://www.purplemath.com/modules/solverad.htm
assert solve((2 * x - 5)**Rational(1, 3) - 3) == [16]
assert set(solve(x + 1 - root(x**4 + 4*x**3 - x, 4))) == \
{-Rational(1, 2), -Rational(1, 3)}
assert set(solve(sqrt(2 * x**2 - 7) -
(3 - x))) == {-Integer(8), Integer(2)}
assert solve(sqrt(2 * x + 9) - sqrt(x + 1) - sqrt(x + 4)) == [0]
assert solve(sqrt(x + 4) + sqrt(2 * x - 1) - 3 * sqrt(x - 1)) == [5]
assert solve(sqrt(x) * sqrt(x - 7) - 12) == [16]
assert solve(sqrt(x - 3) + sqrt(x) - 3) == [4]
assert solve(sqrt(9 * x**2 + 4) - (3 * x + 2)) == [0]
assert solve(sqrt(x) - 2 - 5) == [49]
assert solve(sqrt(x - 3) - sqrt(x) - 3) == []
assert solve(sqrt(x - 1) - x + 7) == [10]
assert solve(sqrt(x - 2) - 5) == [27]
assert solve(sqrt(17 * x - sqrt(x**2 - 5)) - 7) == [3]
assert solve(sqrt(x) - sqrt(x - 1) + sqrt(sqrt(x))) == []
# don't posify the expression in unrad and do use _mexpand
z = sqrt(2 * x + 1) / sqrt(x) - sqrt(2 + 1 / x)
p = posify(z)[0]
assert solve(p) == []
assert solve(z) == []
assert solve(z + 6 * I) == [-Rational(1, 11)]
assert solve(p + 6 * I) == []
# issue sympy/sympy#8622
assert unrad(
(root(x + 1, 5) - root(x, 3))) == (x**5 - x**3 - 3 * x**2 - 3 * x - 1,
[])
# issue sympy/sympy#8679
assert check(unrad(x + root(x, 3) + root(x, 3)**2 + sqrt(y), x),
(s**3 + s**2 + s + sqrt(y), [s, s**3 - x]))
# for coverage
assert check(unrad(sqrt(x) + root(x, 3) + y),
(s**3 + s**2 + y, [s, s**6 - x]))
assert solve(sqrt(x) + root(x, 3) - 2) == [1]
pytest.raises(NotImplementedError,
lambda: solve(sqrt(x) + root(x, 3) + root(x + 1, 5) - 2))
# fails through a different code path
pytest.raises(NotImplementedError, lambda: solve(-sqrt(2) + cosh(x) / x))
# unrad some
assert check(unrad(sqrt(x) - root(x + 1, 3) * sqrt(x + 2) + 2),
(s**10 + 8 * s**8 + 24 * s**6 - 12 * s**5 - 22 * s**4 -
160 * s**3 - 212 * s**2 - 192 * s - 56, [s, s**2 - x]))
e = root(x + 1, 3) + root(x, 3)
assert unrad(e) == (2 * x + 1, [])
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5)
assert check(unrad(eq), (15625 * x**4 + 173000 * x**3 + 355600 * x**2 -
817920 * x + 331776, []))
assert check(unrad(root(x, 4) + root(x, 4)**3 - 1),
(s**3 + s - 1, [s, s**4 - x]))
assert check(unrad(root(x, 2) + root(x, 2)**3 - 1),
(x**3 + 2 * x**2 + x - 1, []))
assert unrad(x**0.5) is None
assert check(unrad(t + root(x + y, 5) + root(x + y, 5)**3),
(s**3 + s + t, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, y),
(s**3 + s + x, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, x),
(s**5 + s**3 + s - y, [s, s**5 - x - y]))
assert check(
unrad(root(x - 1, 3) + root(x + 1, 5) + root(2, 5)),
(s**5 + 5 * 2**Rational(1, 5) * s**4 + s**3 +
10 * 2**Rational(2, 5) * s**3 + 10 * 2**Rational(3, 5) * s**2 +
5 * 2**Rational(4, 5) * s + 4, [s, s**3 - x + 1]))
pytest.raises(
NotImplementedError, lambda: unrad(
(root(x, 2) + root(x, 3) + root(x, 4)).subs(x, x**5 - x + 1)))
# the simplify flag should be reset to False for unrad results;
# if it's not then this next test will take a long time
assert solve(root(x, 3) + root(x, 5) - 2) == [1]
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5)
assert check(unrad(eq),
((5 * x - 4) *
(3125 * x**3 + 37100 * x**2 + 100800 * x - 82944), []))
ans = [
Rational(4, 5),
Rational(-1484, 375) + 172564 /
(140625 * (114 * sqrt(12657) / 78125 + Rational(12459439, 52734375))**
Rational(1, 3)) + 4 * (114 * sqrt(12657) / 78125 +
Rational(12459439, 52734375))**Rational(1, 3)
]
assert solve(eq) == ans
# duplicate radical handling
assert check(unrad(sqrt(x + root(x + 1, 3)) - root(x + 1, 3) - 2),
(s**3 - s**2 - 3 * s - 5, [s, s**3 - x - 1]))
# cov post-processing
e = root(x**2 + 1, 3) - root(x**2 - 1, 5) - 2
assert check(unrad(e),
(s**5 - 10 * s**4 + 39 * s**3 - 80 * s**2 + 80 * s - 30,
[s, s**3 - x**2 - 1]))
e = sqrt(x + root(x + 1, 2)) - root(x + 1, 3) - 2
assert check(unrad(e), (s**6 - 2 * s**5 - 7 * s**4 - 3 * s**3 + 26 * s**2 +
40 * s + 25, [s, s**3 - x - 1]))
assert check(unrad(e, _reverse=True),
(s**6 - 14 * s**5 + 73 * s**4 - 187 * s**3 + 276 * s**2 -
228 * s + 89, [s, s**2 - x - sqrt(x + 1)]))
# this one needs r0, r1 reversal to work
assert check(unrad(sqrt(x + sqrt(root(x, 3) - 1)) - root(x, 6) - 2),
(s**12 - 2 * s**8 - 8 * s**7 - 8 * s**6 + s**4 + 8 * s**3 +
23 * s**2 + 32 * s + 17, [s, s**6 - x]))
# is this needed?
# assert unrad(root(cosh(x), 3)/x*root(x + 1, 5) - 1) == (
# x**15 - x**3*cosh(x)**5 - 3*x**2*cosh(x)**5 - 3*x*cosh(x)**5 - cosh(x)**5, [])
pytest.raises(
NotImplementedError,
lambda: unrad(sqrt(cosh(x) / x) + root(x + 1, 3) * sqrt(x) - 1))
assert unrad((x + y)**(2 * y / 3) + (x + y)**Rational(1, 3) + 1) is None
assert check(unrad((x + y)**(2 * y / 3) + (x + y)**Rational(1, 3) + 1, x),
(s**(2 * y) + s + 1, [s, s**3 - x - y]))
# This tests two things: that if full unrad is attempted and fails
# the solution should still be found; also it tests that the use of
# composite
assert len(solve(sqrt(y) * x + x**3 - 1, x)) == 3
assert len(
solve(-512 * y**3 + 1344 * (x + 2)**Rational(1, 3) * y**2 - 1176 *
(x + 2)**Rational(2, 3) * y - 169 * x + 686,
y,
_unrad=False)) == 3
# watch out for when the cov doesn't involve the symbol of interest
eq = -x + (7 * y / 8 -
(27 * x / 2 + 27 * sqrt(x**2) / 2)**Rational(1, 3) / 3)**3 - 1
assert solve(eq,
y) == [
4 * 2**Rational(2, 3) *
(27 * x + 27 * sqrt(x**2))**Rational(1, 3) / 21 -
(-Rational(1, 2) - sqrt(3) * I / 2) *
(-6912 * x / 343 + sqrt(
(-13824 * x / 343 - Rational(13824, 343))**2) / 2 -
Rational(6912, 343))**Rational(1, 3) / 3,
4 * 2**Rational(2, 3) *
(27 * x + 27 * sqrt(x**2))**Rational(1, 3) / 21 -
(-Rational(1, 2) + sqrt(3) * I / 2) *
(-6912 * x / 343 + sqrt(
(-13824 * x / 343 - Rational(13824, 343))**2) / 2 -
Rational(6912, 343))**Rational(1, 3) / 3,
4 * 2**Rational(2, 3) *
(27 * x + 27 * sqrt(x**2))**Rational(1, 3) / 21 -
(-6912 * x / 343 + sqrt(
(-13824 * x / 343 - Rational(13824, 343))**2) / 2 -
Rational(6912, 343))**Rational(1, 3) / 3
]
eq = root(x + 1, 3) - (root(x, 3) + root(x, 5))
assert check(unrad(eq), (3 * s**13 + 3 * s**11 + s**9 - 1, [s, s**15 - x]))
assert check(unrad(eq - 2),
(3 * s**13 + 3 * s**11 + 6 * s**10 + s**9 + 12 * s**8 +
6 * s**6 + 12 * s**5 + 12 * s**3 + 7, [s, s**15 - x]))
assert check(
unrad(root(x, 3) - root(x + 1, 4) / 2 + root(x + 2, 3)),
(4096 * s**13 + 960 * s**12 + 48 * s**11 - s**10 - 1728 * s**4,
[s, s**4 - x - 1])) # orig expr has two real roots: -1, -.389
assert check(
unrad(root(x, 3) + root(x + 1, 4) - root(x + 2, 3) / 2),
(343 * s**13 + 2904 * s**12 + 1344 * s**11 + 512 * s**10 -
1323 * s**9 - 3024 * s**8 - 1728 * s**7 + 1701 * s**5 + 216 * s**4 -
729 * s, [s, s**4 - x - 1])) # orig expr has one real root: -0.048
assert check(
unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3)),
(729 * s**13 - 216 * s**12 + 1728 * s**11 - 512 * s**10 + 1701 * s**9 -
3024 * s**8 + 1344 * s**7 + 1323 * s**5 - 2904 * s**4 + 343 * s,
[s, s**4 - x - 1])) # orig expr has 2 real roots: -0.91, -0.15
# orig expr has 1 real root: 19.53
assert check(unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3) - 2),
(729 * s**13 + 1242 * s**12 + 18496 * s**10 + 129701 * s**9 +
388602 * s**8 + 453312 * s**7 - 612864 * s**6 -
3337173 * s**5 - 6332418 * s**4 - 7134912 * s**3 -
5064768 * s**2 - 2111913 * s - 398034, [s, s**4 - x - 1]))
ans = solve(sqrt(x) + sqrt(x + 1) - sqrt(1 - x) - sqrt(2 + x))
assert len(ans) == 1 and NS(ans[0])[:4] == '0.73'
# the fence optimization problem
# https://github.com/sympy/sympy/issues/4793#issuecomment-36994519
F = symbols('F')
eq = F - (2 * x + 2 * y + sqrt(x**2 + y**2))
ans = 2 * F / 7 - sqrt(2) * F / 14
X = solve(eq, x, check=False)
for xi in reversed(X): # reverse since currently, ans is the 2nd one
Y = solve((x * y).subs(x, xi).diff(y), y, simplify=False, check=False)
if any((a - ans).expand().is_zero for a in Y):
break
else:
assert None # no answer was found
assert solve(sqrt(x + 1) + root(x, 3) - 2) == ([
(-11 / (9 * (Rational(47, 54) + sqrt(93) / 6)**Rational(1, 3)) +
Rational(1, 3) + (Rational(47, 54) + sqrt(93) / 6)**Rational(1, 3))**3
])
assert solve(sqrt(sqrt(x + 1)) + x**Rational(1, 3) - 2) == ([
(-sqrt(-2 * (Rational(-1, 16) + sqrt(6913) / 16)**Rational(1, 3) + 6 /
(Rational(-1, 16) + sqrt(6913) / 16)**Rational(1, 3) +
Rational(17, 2) + 121 /
(4 *
sqrt(-6 /
(Rational(-1, 16) + sqrt(6913) / 16)**Rational(1, 3) + 2 *
(Rational(-1, 16) + sqrt(6913) / 16)**Rational(1, 3) +
Rational(17, 4)))) / 2 +
sqrt(-6 / (Rational(-1, 16) + sqrt(6913) / 16)**Rational(1, 3) + 2 *
(Rational(-1, 16) + sqrt(6913) / 16)**Rational(1, 3) +
Rational(17, 4)) / 2 + Rational(9, 4))**3
])
assert solve(sqrt(x) + root(sqrt(x) + 1, 3) - 2) == ([
(-(Rational(81, 2) + 3 * sqrt(741) / 2)**Rational(1, 3) / 3 +
(Rational(81, 2) + 3 * sqrt(741) / 2)**Rational(-1, 3) + 2)**2
])
eq = (-x + (Rational(1, 2) - sqrt(3) * I / 2) *
(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt(
(-3 * x**3 + x *
(3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45)**
Rational(1, 3) + 34 /
(3 * (Rational(1, 2) - sqrt(3) * I / 2) *
(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt(
(-3 * x**3 + x *
(3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45)**
Rational(1, 3)))
assert check(
unrad(eq),
(s**7 - sqrt(3) * s**7 * I + 102 * 12**Rational(1, 3) * s**5 +
102 * 2**Rational(2, 3) * 3**Rational(5, 6) * s**5 * I + 1620 * s**4 -
1620 * sqrt(3) * s**4 * I - 13872 * 18**Rational(1, 3) * s**3 +
471648 * s - 471648 * sqrt(3) * s * I, [
s, s**3 - 306 * x -
sqrt(3) * sqrt(31212 * x**2 - 165240 * x + 61484) + 810
]))
assert solve(eq, x, check=False) != [] # not other code errors
def test_cosh():
k = Symbol('k', integer=True)
assert cosh(nan) == nan
assert cosh(zoo) == nan
assert cosh(oo) == oo
assert cosh(-oo) == oo
assert cosh(0) == 1
assert cosh(1) == cosh(1)
assert cosh(-1) == cosh(1)
assert cosh(x) == cosh(x)
assert cosh(-x) == cosh(x)
assert cosh(pi*I) == cos(pi)
assert cosh(-pi*I) == cos(pi)
assert cosh(2**1024 * E) == cosh(2**1024 * E)
assert cosh(-2**1024 * E) == cosh(2**1024 * E)
assert cosh(pi*I/2) == 0
assert cosh(-pi*I/2) == 0
assert cosh((-3*10**73 + 1)*pi*I/2) == 0
assert cosh((7*10**103 + 1)*pi*I/2) == 0
assert cosh(pi*I) == -1
assert cosh(-pi*I) == -1
assert cosh(5*pi*I) == -1
assert cosh(8*pi*I) == 1
assert cosh(pi*I/3) == Rational(1, 2)
assert cosh(-2*pi*I/3) == Rational(-1, 2)
assert cosh(pi*I/4) == sqrt(2)/2
assert cosh(-pi*I/4) == sqrt(2)/2
assert cosh(11*pi*I/4) == -sqrt(2)/2
assert cosh(-3*pi*I/4) == -sqrt(2)/2
assert cosh(pi*I/6) == sqrt(3)/2
assert cosh(-pi*I/6) == sqrt(3)/2
assert cosh(7*pi*I/6) == -sqrt(3)/2
assert cosh(-5*pi*I/6) == -sqrt(3)/2
assert cosh(pi*I/105) == cos(pi/105)
assert cosh(-pi*I/105) == cos(pi/105)
assert cosh(2 + 3*I) == cosh(2 + 3*I)
assert cosh(x*I) == cos(x)
assert cosh(k*pi*I) == cos(k*pi)
assert cosh(17*k*pi*I) == cos(17*k*pi)
assert cosh(k*pi) == cosh(k*pi)
r = Symbol('r', extended_real=True)
assert cosh(r).is_extended_real
assert cosh(x).is_extended_real is None
i = Symbol('i', imaginary=True)
assert cosh(i).is_finite
assert cosh(x).is_finite is None
pytest.raises(ArgumentIndexError, lambda: cosh(x).fdiff(2))
a, b = symbols('a b', extended_real=True)
z = a + b*I
for deep in [True, False]:
assert cosh(z).as_real_imag(deep=deep) == (cosh(a)*cos(b),
sinh(a)*sin(b))
assert cosh(a).as_real_imag(deep=deep) == (cosh(a), 0)
def test_cosh_expansion():
assert cosh(x+y).expand(trig=True) == cosh(x)*cosh(y) + sinh(x)*sinh(y)
assert cosh(2*x).expand(trig=True) == cosh(x)**2 + sinh(x)**2
assert cosh(3*x).expand(trig=True).expand() == \
3*sinh(x)**2*cosh(x) + cosh(x)**3
def test_reciprocal():
class FakeSech(ReciprocalHyperbolicFunction):
_reciprocal_of = cosh
assert FakeSech(-x) == 1 / cosh(x)
def test_expand():
assert expand_func(besselj(Rational(1, 2), z).rewrite(jn)) == \
sqrt(2)*sin(z)/(sqrt(pi)*sqrt(z))
assert expand_func(bessely(Rational(1, 2), z).rewrite(yn)) == \
-sqrt(2)*cos(z)/(sqrt(pi)*sqrt(z))
assert expand_func(besselj(I, z)) == besselj(I, z)
# XXX: teach sin/cos to work around arguments like
# x*exp_polar(I*pi*n/2). Then change besselsimp -> expand_func
assert besselsimp(besselj(Rational(1, 2),
z)) == sqrt(2) * sin(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(besselj(Rational(-1, 2),
z)) == sqrt(2) * cos(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(besselj(Rational(5, 2), z)) == \
-sqrt(2)*(z**2*sin(z) + 3*z*cos(z) - 3*sin(z))/(sqrt(pi)*z**Rational(5, 2))
assert besselsimp(besselj(-Rational(5, 2), z)) == \
-sqrt(2)*(z**2*cos(z) - 3*z*sin(z) - 3*cos(z))/(sqrt(pi)*z**Rational(5, 2))
assert besselsimp(bessely(Rational(1, 2), z)) == \
-(sqrt(2)*cos(z))/(sqrt(pi)*sqrt(z))
assert besselsimp(bessely(Rational(-1, 2),
z)) == sqrt(2) * sin(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(bessely(Rational(5, 2), z)) == \
sqrt(2)*(z**2*cos(z) - 3*z*sin(z) - 3*cos(z))/(sqrt(pi)*z**Rational(5, 2))
assert besselsimp(bessely(Rational(-5, 2), z)) == \
-sqrt(2)*(z**2*sin(z) + 3*z*cos(z) - 3*sin(z))/(sqrt(pi)*z**Rational(5, 2))
assert besselsimp(besseli(Rational(1, 2),
z)) == sqrt(2) * sinh(z) / (sqrt(pi) * sqrt(z))
assert besselsimp(besseli(Rational(-1, 2), z)) == \
sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
assert besselsimp(besseli(Rational(5, 2), z)) == \
sqrt(2)*(z**2*sinh(z) - 3*z*cosh(z) + 3*sinh(z))/(sqrt(pi)*z**Rational(5, 2))
assert besselsimp(besseli(Rational(-5, 2), z)) == \
sqrt(2)*(z**2*cosh(z) - 3*z*sinh(z) + 3*cosh(z))/(sqrt(pi)*z**Rational(5, 2))
assert besselsimp(besselk(Rational(1, 2), z)) == \
besselsimp(besselk(Rational(-1, 2), z)) == sqrt(pi)*exp(-z)/(sqrt(2)*sqrt(z))
assert besselsimp(besselk(Rational(5, 2), z)) == \
besselsimp(besselk(Rational(-5, 2), z)) == \
sqrt(2)*sqrt(pi)*(z**2 + 3*z + 3)*exp(-z)/(2*z**Rational(5, 2))
def check(eq, ans):
return tn(eq, ans) and eq == ans
rn = randcplx(a=1, b=0, d=0, c=2)
for besselx in [besselj, bessely, besseli, besselk]:
ri = Rational(2 * randint(-11, 10) + 1,
2) # half integer in [-21/2, 21/2]
assert tn(besselsimp(besselx(ri, z)), besselx(ri, z))
assert check(expand_func(besseli(rn, x)),
besseli(rn - 2, x) - 2 * (rn - 1) * besseli(rn - 1, x) / x)
assert check(expand_func(besseli(-rn, x)),
besseli(-rn + 2, x) + 2 * (-rn + 1) * besseli(-rn + 1, x) / x)
assert check(expand_func(besselj(rn, x)),
-besselj(rn - 2, x) + 2 * (rn - 1) * besselj(rn - 1, x) / x)
assert check(
expand_func(besselj(-rn, x)),
-besselj(-rn + 2, x) + 2 * (-rn + 1) * besselj(-rn + 1, x) / x)
assert check(expand_func(besselk(rn, x)),
besselk(rn - 2, x) + 2 * (rn - 1) * besselk(rn - 1, x) / x)
assert check(expand_func(besselk(-rn, x)),
besselk(-rn + 2, x) - 2 * (-rn + 1) * besselk(-rn + 1, x) / x)
assert check(expand_func(bessely(rn, x)),
-bessely(rn - 2, x) + 2 * (rn - 1) * bessely(rn - 1, x) / x)
assert check(
expand_func(bessely(-rn, x)),
-bessely(-rn + 2, x) + 2 * (-rn + 1) * bessely(-rn + 1, x) / x)
n = Symbol('n', integer=True, positive=True)
assert expand_func(besseli(n + 2, z)) == \
besseli(n, z) + (-2*n - 2)*(-2*n*besseli(n, z)/z + besseli(n - 1, z))/z
assert expand_func(besselj(n + 2, z)) == \
-besselj(n, z) + (2*n + 2)*(2*n*besselj(n, z)/z - besselj(n - 1, z))/z
assert expand_func(besselk(n + 2, z)) == \
besselk(n, z) + (2*n + 2)*(2*n*besselk(n, z)/z + besselk(n - 1, z))/z
assert expand_func(bessely(n + 2, z)) == \
-bessely(n, z) + (2*n + 2)*(2*n*bessely(n, z)/z - bessely(n - 1, z))/z
assert expand_func(besseli(n + Rational(1, 2), z).rewrite(jn)) == \
(sqrt(2)*sqrt(z)*exp(-I*pi*(n + Rational(1, 2))/2) *
exp_polar(I*pi/4)*jn(n, z*exp_polar(I*pi/2))/sqrt(pi))
assert expand_func(besselj(n + Rational(1, 2), z).rewrite(jn)) == \
sqrt(2)*sqrt(z)*jn(n, z)/sqrt(pi)
r = Symbol('r', extended_real=True)
p = Symbol('p', positive=True)
i = Symbol('i', integer=True)
for besselx in [besselj, bessely, besseli, besselk]:
assert besselx(i, p).is_extended_real
assert besselx(i, x).is_extended_real is None
assert besselx(x, z).is_extended_real is None
for besselx in [besselj, besseli]:
assert besselx(i, r).is_extended_real
for besselx in [bessely, besselk]:
assert besselx(i, r).is_extended_real is None
def test_complex():
a, b = symbols('a,b', extended_real=True)
z = a + b * I
for func in [sinh, cosh, tanh, coth, sech, csch]:
assert func(z).conjugate() == func(a - b * I)
for deep in [True, False]:
assert sinh(z).expand(
complex=True, deep=deep) == sinh(a) * cos(b) + I * cosh(a) * sin(b)
assert cosh(z).expand(
complex=True, deep=deep) == cosh(a) * cos(b) + I * sinh(a) * sin(b)
assert tanh(z).expand(
complex=True, deep=deep) == sinh(a) * cosh(a) / (cos(b)**2 + sinh(
a)**2) + I * sin(b) * cos(b) / (cos(b)**2 + sinh(a)**2)
assert coth(z).expand(
complex=True, deep=deep) == sinh(a) * cosh(a) / (sin(b)**2 + sinh(
a)**2) - I * sin(b) * cos(b) / (sin(b)**2 + sinh(a)**2)
assert csch(z).expand(complex=True, deep=deep) == cos(b) * sinh(a) / (
sin(b)**2 * cosh(a)**2 +
cos(b)**2 * sinh(a)**2) - I * sin(b) * cosh(a) / (
sin(b)**2 * cosh(a)**2 + cos(b)**2 * sinh(a)**2)
assert sech(z).expand(complex=True, deep=deep) == cos(b) * cosh(a) / (
sin(b)**2 * sinh(a)**2 +
cos(b)**2 * cosh(a)**2) - I * sin(b) * sinh(a) / (
sin(b)**2 * sinh(a)**2 + cos(b)**2 * cosh(a)**2)
def test_sympyissue_9630():
psi = (-0.999999972295856*sin(13.3579685223169*x/y) + 1.0*cos(13.3579685223169*x/y) +
0.999999972295856*sinh(13.3579685223169*x/y) - 1.0*cosh(13.3579685223169*x/y))
assert simplify(psi) == psi
def test_sinh_rewrite():
assert sinh(x).rewrite(exp) == (exp(x) - exp(-x))/2 \
== sinh(x).rewrite('tractable')
assert sinh(x).rewrite(cosh) == -I * cosh(x + I * pi / 2)
assert sinh(x).rewrite(tanh) == 2 * tanh(x / 2) / (1 - tanh(x / 2)**2)
assert sinh(x).rewrite(coth) == 2 * coth(x / 2) / (coth(x / 2)**2 - 1)
def test_Function():
assert mathematica_code(f(x, y, z)) == 'f[x, y, z]'
assert mathematica_code(sin(x)**cos(x)) == 'Sin[x]^Cos[x]'
assert mathematica_code(sign(x)) == 'Sign[x]'
assert mathematica_code(atanh(x),
user_functions={'atanh':
'ArcTanh'}) == 'ArcTanh[x]'
assert (mathematica_code(meijerg(
((1, 1), (3, 4)), ((1, ), ()),
x)) == 'MeijerG[{{1, 1}, {3, 4}}, {{1}, {}}, x]')
assert (mathematica_code(hyper(
(1, 2, 3), (3, 4), x)) == 'HypergeometricPFQ[{1, 2, 3}, {3, 4}, x]')
assert mathematica_code(Min(x, y)) == 'Min[x, y]'
assert mathematica_code(Max(x, y)) == 'Max[x, y]'
assert mathematica_code(Max(x,
2)) == 'Max[2, x]' # issue sympy/sympy#15344
assert mathematica_code(binomial(x, y)) == 'Binomial[x, y]'
assert mathematica_code(log(x)) == 'Log[x]'
assert mathematica_code(tan(x)) == 'Tan[x]'
assert mathematica_code(cot(x)) == 'Cot[x]'
assert mathematica_code(asin(x)) == 'ArcSin[x]'
assert mathematica_code(acos(x)) == 'ArcCos[x]'
assert mathematica_code(atan(x)) == 'ArcTan[x]'
assert mathematica_code(acot(x)) == 'ArcCot[x]'
assert mathematica_code(sinh(x)) == 'Sinh[x]'
assert mathematica_code(cosh(x)) == 'Cosh[x]'
assert mathematica_code(tanh(x)) == 'Tanh[x]'
assert mathematica_code(coth(x)) == 'Coth[x]'
assert mathematica_code(asinh(x)) == 'ArcSinh[x]'
assert mathematica_code(acosh(x)) == 'ArcCosh[x]'
assert mathematica_code(atanh(x)) == 'ArcTanh[x]'
assert mathematica_code(acoth(x)) == 'ArcCoth[x]'
assert mathematica_code(sech(x)) == 'Sech[x]'
assert mathematica_code(csch(x)) == 'Csch[x]'
assert mathematica_code(erf(x)) == 'Erf[x]'
assert mathematica_code(erfi(x)) == 'Erfi[x]'
assert mathematica_code(erfc(x)) == 'Erfc[x]'
assert mathematica_code(conjugate(x)) == 'Conjugate[x]'
assert mathematica_code(re(x)) == 'Re[x]'
assert mathematica_code(im(x)) == 'Im[x]'
assert mathematica_code(polygamma(x, y)) == 'PolyGamma[x, y]'
assert mathematica_code(factorial(x)) == 'Factorial[x]'
assert mathematica_code(factorial2(x)) == 'Factorial2[x]'
assert mathematica_code(rf(x, y)) == 'Pochhammer[x, y]'
assert mathematica_code(gamma(x)) == 'Gamma[x]'
assert mathematica_code(zeta(x)) == 'Zeta[x]'
assert mathematica_code(Heaviside(x)) == 'UnitStep[x]'
assert mathematica_code(fibonacci(x)) == 'Fibonacci[x]'
assert mathematica_code(polylog(x, y)) == 'PolyLog[x, y]'
assert mathematica_code(loggamma(x)) == 'LogGamma[x]'
assert mathematica_code(uppergamma(x, y)) == 'Gamma[x, y]'
class MyFunc1(Function):
@classmethod
def eval(cls, x):
pass
class MyFunc2(Function):
@classmethod
def eval(cls, x, y):
pass
pytest.raises(
ValueError,
lambda: mathematica_code(MyFunc1(x),
user_functions={'MyFunc1': ['Myfunc1']}))
assert mathematica_code(MyFunc1(x),
user_functions={'MyFunc1':
'Myfunc1'}) == 'Myfunc1[x]'
assert mathematica_code(
MyFunc2(x, y),
user_functions={'MyFunc2':
[(lambda *x: False, 'Myfunc2')]}) == 'MyFunc2[x, y]'
def test_coth_rewrite():
assert coth(x).rewrite(exp) == (exp(x) + exp(-x))/(exp(x) - exp(-x)) \
== coth(x).rewrite('tractable')
assert coth(x).rewrite(sinh) == -I * sinh(I * pi / 2 - x) / sinh(x)
assert coth(x).rewrite(cosh) == -I * cosh(x) / cosh(I * pi / 2 - x)
assert coth(x).rewrite(tanh) == 1 / tanh(x)
def test_exp_rewrite():
assert exp(x).rewrite(sin) == sinh(x) + cosh(x)
assert exp(x*I).rewrite(cos) == cos(x) + I*sin(x)
assert exp(1).rewrite(cos) == sinh(1) + cosh(1)
assert exp(1).rewrite(sin) == sinh(1) + cosh(1)
assert exp(x).rewrite(tanh) == (1 + tanh(x/2))/(1 - tanh(x/2))
def test_sinh_expansion():
assert sinh(x +
y).expand(trig=True) == sinh(x) * cosh(y) + cosh(x) * sinh(y)
assert sinh(2 * x).expand(trig=True) == 2 * sinh(x) * cosh(x)
assert sinh(3*x).expand(trig=True).expand() == \
sinh(x)**3 + 3*sinh(x)*cosh(x)**2
def test_cos():
x, y = symbols('x y')
assert cos.nargs == FiniteSet(1)
assert cos(nan) == nan
assert cos(oo) == cos(oo, evaluate=False)
assert cos(oo*I) == oo
assert cos(-oo*I) == oo
assert cos(0) == 1
assert cos(acos(x)) == x
assert cos(atan(x)) == 1 / sqrt(1 + x**2)
assert cos(asin(x)) == sqrt(1 - x**2)
assert cos(acot(x)) == 1 / sqrt(1 + 1 / x**2)
assert cos(atan2(y, x)) == x / sqrt(x**2 + y**2)
assert cos(pi*I) == cosh(pi)
assert cos(-pi*I) == cosh(pi)
assert cos(-2*I) == cosh(2)
assert cos(pi/2) == 0
assert cos(-pi/2) == 0
assert cos(pi/2) == 0
assert cos(-pi/2) == 0
assert cos((-3*10**73 + 1)*pi/2) == 0
assert cos((7*10**103 + 1)*pi/2) == 0
n = symbols('n', integer=True, even=False)
e = symbols('e', even=True)
assert cos(pi*n/2) == 0
assert cos(pi*e/2) == (-1)**(e/2)
assert cos(pi) == -1
assert cos(-pi) == -1
assert cos(2*pi) == 1
assert cos(5*pi) == -1
assert cos(8*pi) == 1
assert cos(pi/3) == Rational(1, 2)
assert cos(-2*pi/3) == Rational(-1, 2)
assert cos(pi/4) == sqrt(2)/2
assert cos(-pi/4) == sqrt(2)/2
assert cos(11*pi/4) == -sqrt(2)/2
assert cos(-3*pi/4) == -sqrt(2)/2
assert cos(pi/6) == sqrt(3)/2
assert cos(-pi/6) == sqrt(3)/2
assert cos(7*pi/6) == -sqrt(3)/2
assert cos(-5*pi/6) == -sqrt(3)/2
assert cos(1*pi/5) == (sqrt(5) + 1)/4
assert cos(2*pi/5) == (sqrt(5) - 1)/4
assert cos(3*pi/5) == -cos(2*pi/5)
assert cos(4*pi/5) == -cos(1*pi/5)
assert cos(6*pi/5) == -cos(1*pi/5)
assert cos(8*pi/5) == cos(2*pi/5)
assert cos(-1273*pi/5) == -cos(2*pi/5)
assert cos(pi/8) == sqrt((2 + sqrt(2))/4)
assert cos(pi/12) == sqrt(2)/4 + sqrt(6)/4
assert cos(5*pi/12) == -sqrt(2)/4 + sqrt(6)/4
assert cos(7*pi/12) == sqrt(2)/4 - sqrt(6)/4
assert cos(11*pi/12) == -sqrt(2)/4 - sqrt(6)/4
assert cos(104*pi/105) == -cos(pi/105)
assert cos(106*pi/105) == -cos(pi/105)
assert cos(-104*pi/105) == -cos(pi/105)
assert cos(-106*pi/105) == -cos(pi/105)
assert cos(x*I) == cosh(x)
assert cos(k*pi*I) == cosh(k*pi)
assert cos(r).is_real
assert cos(c).is_complex
assert cos(0, evaluate=False).is_algebraic
assert cos(a).is_algebraic is None
assert cos(na).is_algebraic is False
q = Symbol('q', rational=True)
assert cos(pi*q).is_algebraic
assert cos(2*pi/7).is_algebraic
qz = Symbol('qz', zero=True)
qn = Symbol('qn', rational=True, nonzero=True)
assert cos(qz).is_rational
assert cos(0, evaluate=False).is_rational
assert cos(qn).is_rational is False
assert cos(q).is_rational is None
assert cos(k*pi) == (-1)**k
assert cos(2*k*pi) == 1
for d in list(range(1, 22)) + [60, 85]:
for n in range(2*d + 1):
x = n*pi/d
e = abs( float(cos(x)) - cos(float(x)) )
assert e < 1e-12
assert cos(z).taylor_term(2, z, *(1, 0)) == -z**2/2
pytest.raises(ArgumentIndexError, lambda: cos(z).fdiff(2))
def test_sympyissue_8368():
assert meijerint_indefinite(cosh(x)*exp(-x*t), x) == (
(-t - 1)*exp(x) + (-t + 1)*exp(-x))*exp(-t*x)/2/(t**2 - 1)
def test_cosh():
x, y = symbols('x,y')
k = Symbol('k', integer=True)
assert cosh(nan) == nan
assert cosh(zoo) == nan
assert cosh(oo) == oo
assert cosh(-oo) == oo
assert cosh(0) == 1
assert cosh(1) == cosh(1)
assert cosh(-1) == cosh(1)
assert cosh(x) == cosh(x)
assert cosh(-x) == cosh(x)
assert cosh(pi * I) == cos(pi)
assert cosh(-pi * I) == cos(pi)
assert cosh(2**1024 * E) == cosh(2**1024 * E)
assert cosh(-2**1024 * E) == cosh(2**1024 * E)
assert cosh(pi * I / 2) == 0
assert cosh(-pi * I / 2) == 0
assert cosh((-3 * 10**73 + 1) * pi * I / 2) == 0
assert cosh((7 * 10**103 + 1) * pi * I / 2) == 0
assert cosh(pi * I) == -1
assert cosh(-pi * I) == -1
assert cosh(5 * pi * I) == -1
assert cosh(8 * pi * I) == 1
assert cosh(pi * I / 3) == S.Half
assert cosh(-2 * pi * I / 3) == -S.Half
assert cosh(pi * I / 4) == S.Half * sqrt(2)
assert cosh(-pi * I / 4) == S.Half * sqrt(2)
assert cosh(11 * pi * I / 4) == -S.Half * sqrt(2)
assert cosh(-3 * pi * I / 4) == -S.Half * sqrt(2)
assert cosh(pi * I / 6) == S.Half * sqrt(3)
assert cosh(-pi * I / 6) == S.Half * sqrt(3)
assert cosh(7 * pi * I / 6) == -S.Half * sqrt(3)
assert cosh(-5 * pi * I / 6) == -S.Half * sqrt(3)
assert cosh(pi * I / 105) == cos(pi / 105)
assert cosh(-pi * I / 105) == cos(pi / 105)
assert cosh(2 + 3 * I) == cosh(2 + 3 * I)
assert cosh(x * I) == cos(x)
assert cosh(k * pi * I) == cos(k * pi)
assert cosh(17 * k * pi * I) == cos(17 * k * pi)
assert cosh(k * pi) == cosh(k * pi)
r = Symbol('r', extended_real=True)
assert cosh(r).is_extended_real
assert cosh(x).is_extended_real is None
i = Symbol('i', imaginary=True)
assert cosh(i).is_finite
assert cosh(x).is_finite is None
def test_exp_rewrite():
assert exp(x).rewrite(sin) == sinh(x) + cosh(x)
assert exp(x*I).rewrite(cos) == cos(x) + I*sin(x)
assert exp(1).rewrite(cos) == sinh(1) + cosh(1)
assert exp(1).rewrite(sin) == sinh(1) + cosh(1)
assert exp(x).rewrite(tanh) == (1 + tanh(x/2))/(1 - tanh(x/2))
def test_tanh():
k = Symbol('k', integer=True)
assert tanh(nan) == nan
assert tanh(zoo) == nan
assert tanh(oo) == 1
assert tanh(-oo) == -1
assert tanh(0) == 0
assert tanh(1) == tanh(1)
assert tanh(-1) == -tanh(1)
assert tanh(x) == tanh(x)
assert tanh(-x) == -tanh(x)
assert tanh(pi) == tanh(pi)
assert tanh(-pi) == -tanh(pi)
assert tanh(2**1024 * E) == tanh(2**1024 * E)
assert tanh(-2**1024 * E) == -tanh(2**1024 * E)
assert tanh(pi * I) == 0
assert tanh(-pi * I) == 0
assert tanh(2 * pi * I) == 0
assert tanh(-2 * pi * I) == 0
assert tanh(-3 * 10**73 * pi * I) == 0
assert tanh(7 * 10**103 * pi * I) == 0
assert tanh(pi * I / 2) == tanh(pi * I / 2)
assert tanh(-pi * I / 2) == -tanh(pi * I / 2)
assert tanh(5 * pi * I / 2) == tanh(5 * pi * I / 2)
assert tanh(7 * pi * I / 2) == tanh(7 * pi * I / 2)
assert tanh(pi * I / 3) == sqrt(3) * I
assert tanh(-2 * pi * I / 3) == sqrt(3) * I
assert tanh(pi * I / 4) == I
assert tanh(-pi * I / 4) == -I
assert tanh(17 * pi * I / 4) == I
assert tanh(-3 * pi * I / 4) == I
assert tanh(pi * I / 6) == I / sqrt(3)
assert tanh(-pi * I / 6) == -I / sqrt(3)
assert tanh(7 * pi * I / 6) == I / sqrt(3)
assert tanh(-5 * pi * I / 6) == I / sqrt(3)
assert tanh(pi * I / 105) == tan(pi / 105) * I
assert tanh(-pi * I / 105) == -tan(pi / 105) * I
assert tanh(2 + 3 * I) == tanh(2 + 3 * I)
assert tanh(x * I) == tan(x) * I
assert tanh(k * pi * I) == 0
assert tanh(17 * k * pi * I) == 0
assert tanh(k * pi * I / 2) == tan(k * pi / 2) * I
r = Symbol('r', extended_real=True)
assert tanh(r).is_extended_real
assert tanh(x).is_extended_real is None
assert tanh(r).is_finite
assert tanh(x).is_finite is None
pytest.raises(ArgumentIndexError, lambda: tanh(x).fdiff(2))
a, b = symbols('a b', extended_real=True)
z = a + b * I
for deep in [True, False]:
d = sinh(a)**2 + cos(b)**2
assert tanh(z).as_real_imag(deep=deep) == (sinh(a) * cosh(a) / d,
sin(b) * cos(b) / d)
assert tanh(a).as_real_imag(deep=deep) == (tanh(a), 0)
def test_csc():
x = symbols('x', extended_real=True)
z = symbols('z')
# https://github.com/sympy/sympy/issues/6707
cosecant = csc('x')
alternate = 1/sin('x')
assert cosecant.equals(alternate)
assert alternate.equals(cosecant)
assert csc.nargs == FiniteSet(1)
assert csc(0) == zoo
assert csc(pi) == zoo
assert csc(pi/2) == 1
assert csc(-pi/2) == -1
assert csc(pi/6) == 2
assert csc(pi/3) == 2*sqrt(3)/3
assert csc(5*pi/2) == 1
assert csc(9*pi/7) == -csc(2*pi/7)
assert csc(3*pi/4) == sqrt(2) # issue sympy/sympy#8421
assert csc(I) == -I*csch(1)
assert csc(x*I) == -I*csch(x)
assert csc(-x) == -csc(x)
assert csc(acsc(x)) == x
assert csc(x).rewrite(exp) == 2*I/(exp(I*x) - exp(-I*x))
assert csc(x).rewrite(sin) == 1/sin(x)
assert csc(x).rewrite(cos) == csc(x)
assert csc(x).rewrite(tan) == (tan(x/2)**2 + 1)/(2*tan(x/2))
assert csc(x).rewrite(cot) == (cot(x/2)**2 + 1)/(2*cot(x/2))
assert csc(z).conjugate() == csc(conjugate(z))
assert (csc(z).as_real_imag() ==
(sin(re(z))*cosh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
cos(re(z))**2*sinh(im(z))**2),
-cos(re(z))*sinh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
cos(re(z))**2*sinh(im(z))**2)))
assert csc(x).expand(trig=True) == 1/sin(x)
assert csc(2*x).expand(trig=True) == 1/(2*sin(x)*cos(x))
assert csc(a).is_algebraic is None
assert csc(na).is_algebraic is False
assert csc(x).as_leading_term() == csc(x)
assert csc(0).is_finite is False
assert csc(x).is_finite is None
assert csc(pi/2).is_finite
assert series(csc(x), x, x0=pi/2, n=6) == \
1 + (x - pi/2)**2/2 + 5*(x - pi/2)**4/24 + O((x - pi/2)**6, (x, pi/2))
assert series(csc(x), x, x0=0, n=6) == \
1/x + x/6 + 7*x**3/360 + 31*x**5/15120 + O(x**6)
assert csc(x).diff(x) == -cot(x)*csc(x)
assert csc(x).taylor_term(0, x) == 1/x
assert csc(x).taylor_term(2, x) == 0
assert csc(x).taylor_term(3, x) == 7*x**3/360
assert csc(x).taylor_term(5, x) == 31*x**5/15120
pytest.raises(ArgumentIndexError, lambda: csc(x).fdiff(2))
def test_coth():
k = Symbol('k', integer=True)
assert coth(nan) == nan
assert coth(zoo) == nan
assert coth(oo) == 1
assert coth(-oo) == -1
assert coth(0) == coth(0)
assert coth(0) == zoo
assert coth(1) == coth(1)
assert coth(-1) == -coth(1)
assert coth(x) == coth(x)
assert coth(-x) == -coth(x)
assert coth(pi * I) == -I * cot(pi)
assert coth(-pi * I) == cot(pi) * I
assert coth(2**1024 * E) == coth(2**1024 * E)
assert coth(-2**1024 * E) == -coth(2**1024 * E)
assert coth(pi * I) == -I * cot(pi)
assert coth(-pi * I) == I * cot(pi)
assert coth(2 * pi * I) == -I * cot(2 * pi)
assert coth(-2 * pi * I) == I * cot(2 * pi)
assert coth(-3 * 10**73 * pi * I) == I * cot(3 * 10**73 * pi)
assert coth(7 * 10**103 * pi * I) == -I * cot(7 * 10**103 * pi)
assert coth(pi * I / 2) == 0
assert coth(-pi * I / 2) == 0
assert coth(5 * pi * I / 2) == 0
assert coth(7 * pi * I / 2) == 0
assert coth(pi * I / 3) == -I / sqrt(3)
assert coth(-2 * pi * I / 3) == -I / sqrt(3)
assert coth(pi * I / 4) == -I
assert coth(-pi * I / 4) == I
assert coth(17 * pi * I / 4) == -I
assert coth(-3 * pi * I / 4) == -I
assert coth(pi * I / 6) == -sqrt(3) * I
assert coth(-pi * I / 6) == sqrt(3) * I
assert coth(7 * pi * I / 6) == -sqrt(3) * I
assert coth(-5 * pi * I / 6) == -sqrt(3) * I
assert coth(pi * I / 105) == -cot(pi / 105) * I
assert coth(-pi * I / 105) == cot(pi / 105) * I
assert coth(2 + 3 * I) == coth(2 + 3 * I)
assert coth(x * I) == -cot(x) * I
assert coth(k * pi * I) == -cot(k * pi) * I
assert coth(17 * k * pi * I) == -cot(17 * k * pi) * I
assert coth(k * pi * I) == -cot(k * pi) * I
pytest.raises(ArgumentIndexError, lambda: coth(x).fdiff(2))
a, b = symbols('a b', extended_real=True)
z = a + b * I
for deep in [True, False]:
d = sinh(a)**2 + sin(b)**2
assert coth(z).as_real_imag(deep=deep) == (sinh(a) * cosh(a) / d,
-sin(b) * cos(b) / d)
assert coth(a).as_real_imag(deep=deep) == (coth(a), 0)
def test_unrad1():
pytest.raises(NotImplementedError, lambda:
unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x)) + 3))
pytest.raises(NotImplementedError, lambda:
unrad(sqrt(x) + cbrt(x + 1) + 2*sqrt(y)))
s = symbols('s', cls=Dummy)
# checkers to deal with possibility of answer coming
# back with a sign change (cf issue sympy/sympy#5203)
def check(rv, ans):
assert bool(rv[1]) == bool(ans[1])
if ans[1]:
return s_check(rv, ans)
e = rv[0].expand()
a = ans[0].expand()
return e in [a, -a] and rv[1] == ans[1]
def s_check(rv, ans):
# get the dummy
rv = list(rv)
d = rv[0].atoms(Dummy)
reps = list(zip(d, [s]*len(d)))
# replace s with this dummy
rv = (rv[0].subs(reps).expand(), [rv[1][0].subs(reps), rv[1][1].subs(reps)])
ans = (ans[0].subs(reps).expand(), [ans[1][0].subs(reps), ans[1][1].subs(reps)])
return str(rv[0]) in [str(ans[0]), str(-ans[0])] and \
str(rv[1]) == str(ans[1])
assert check(unrad(sqrt(x)),
(x, []))
assert check(unrad(sqrt(x) + 1),
(x - 1, []))
assert check(unrad(sqrt(x) + root(x, 3) + 2),
(s**3 + s**2 + 2, [s, s**6 - x]))
assert check(unrad(sqrt(x)*root(x, 3) + 2),
(x**5 - 64, []))
assert check(unrad(sqrt(x) + cbrt(x + 1)),
(x**3 - (x + 1)**2, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(2*x)),
(-2*sqrt(2)*x - 2*x + 1, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + 2),
(16*x - 9, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - x)),
(5*x**2 - 4*x, []))
assert check(unrad(a*sqrt(x) + b*sqrt(x) + c*sqrt(y) + d*sqrt(y)),
((a*sqrt(x) + b*sqrt(x))**2 - (c*sqrt(y) + d*sqrt(y))**2, []))
assert check(unrad(sqrt(x) + sqrt(1 - x)),
(2*x - 1, []))
assert check(unrad(sqrt(x) + sqrt(1 - x) - 3),
(x**2 - x + 16, []))
assert check(unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x)),
(5*x**2 - 2*x + 1, []))
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - 3) in [
(25*x**4 + 376*x**3 + 1256*x**2 - 2272*x + 784, []),
(25*x**8 - 476*x**6 + 2534*x**4 - 1468*x**2 + 169, [])]
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - sqrt(1 - 2*x)) == \
(41*x**4 + 40*x**3 + 232*x**2 - 160*x + 16, []) # orig root at 0.487
assert check(unrad(sqrt(x) + sqrt(x + 1)), (Integer(1), []))
eq = sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x))
assert check(unrad(eq),
(16*x**2 - 9*x, []))
assert {s[x] for s in solve(eq, check=False)} == {0, Rational(9, 16)}
assert solve(eq) == []
# but this one really does have those solutions
assert ({s[x] for s in solve(sqrt(x) - sqrt(x + 1) +
sqrt(1 - sqrt(x)))} ==
{0, Rational(9, 16)})
assert check(unrad(sqrt(x) + root(x + 1, 3) + 2*sqrt(y), y),
(2*sqrt(x)*cbrt(x + 1) + x - 4*y +
(x + 1)**Rational(2, 3), []))
assert check(unrad(sqrt(x/(1 - x)) + cbrt(x + 1)),
(x**5 - x**4 - x**3 + 2*x**2 + x - 1, []))
assert check(unrad(sqrt(x/(1 - x)) + 2*sqrt(y), y),
(4*x*y + x - 4*y, []))
assert check(unrad(sqrt(x)*sqrt(1 - x) + 2, x),
(x**2 - x + 4, []))
# http://tutorial.math.lamar.edu/
# Classes/Alg/SolveRadicalEqns.aspx#Solve_Rad_Ex2_a
assert solve(Eq(x, sqrt(x + 6))) == [{x: 3}]
assert solve(Eq(x + sqrt(x - 4), 4)) == [{x: 4}]
assert solve(Eq(1, x + sqrt(2*x - 3))) == []
assert {s[x] for s in solve(Eq(sqrt(5*x + 6) - 2, x))} == {-1, 2}
assert {s[x] for s in solve(Eq(sqrt(2*x - 1) - sqrt(x - 4), 2))} == {5, 13}
assert solve(Eq(sqrt(x + 7) + 2, sqrt(3 - x))) == [{x: -6}]
# http://www.purplemath.com/modules/solverad.htm
assert solve(cbrt(2*x - 5) - 3) == [{x: 16}]
assert {s[x] for s in solve(x + 1 - root(x**4 + 4*x**3 - x, 4))} == {-Rational(1, 2),
-Rational(1, 3)}
assert {s[x] for s in solve(sqrt(2*x**2 - 7) - (3 - x))} == {-8, 2}
assert solve(sqrt(2*x + 9) - sqrt(x + 1) - sqrt(x + 4)) == [{x: 0}]
assert solve(sqrt(x + 4) + sqrt(2*x - 1) - 3*sqrt(x - 1)) == [{x: 5}]
assert solve(sqrt(x)*sqrt(x - 7) - 12) == [{x: 16}]
assert solve(sqrt(x - 3) + sqrt(x) - 3) == [{x: 4}]
assert solve(sqrt(9*x**2 + 4) - (3*x + 2)) == [{x: 0}]
assert solve(sqrt(x) - 2 - 5) == [{x: 49}]
assert solve(sqrt(x - 3) - sqrt(x) - 3) == []
assert solve(sqrt(x - 1) - x + 7) == [{x: 10}]
assert solve(sqrt(x - 2) - 5) == [{x: 27}]
assert solve(sqrt(17*x - sqrt(x**2 - 5)) - 7) == [{x: 3}]
assert solve(sqrt(x) - sqrt(x - 1) + sqrt(sqrt(x))) == []
# don't posify the expression in unrad and do use _mexpand
z = sqrt(2*x + 1)/sqrt(x) - sqrt(2 + 1/x)
p = posify(z)[0]
assert solve(p) == []
assert solve(z) == []
assert solve(z + 6*I) == [{x: -Rational(1, 11)}]
assert solve(p + 6*I) == []
# issue sympy/sympy#8622
assert unrad((root(x + 1, 5) - root(x, 3))) == (
x**5 - x**3 - 3*x**2 - 3*x - 1, [])
# issue sympy/sympy#8679
assert check(unrad(x + root(x, 3) + root(x, 3)**2 + sqrt(y), x),
(s**3 + s**2 + s + sqrt(y), [s, s**3 - x]))
# for coverage
assert check(unrad(sqrt(x) + root(x, 3) + y),
(s**3 + s**2 + y, [s, s**6 - x]))
assert solve(sqrt(x) + root(x, 3) - 2) == [{x: 1}]
pytest.raises(NotImplementedError, lambda:
solve(sqrt(x) + root(x, 3) + root(x + 1, 5) - 2))
# fails through a different code path
pytest.raises(NotImplementedError, lambda: solve(-sqrt(2) + cosh(x)/x))
# unrad some
e = root(x + 1, 3) + root(x, 3)
assert unrad(e) == (2*x + 1, [])
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6*sqrt(5)/5)
assert check(unrad(eq),
(15625*x**4 + 173000*x**3 + 355600*x**2 - 817920*x + 331776, []))
assert check(unrad(root(x, 4) + root(x, 4)**3 - 1),
(s**3 + s - 1, [s, s**4 - x]))
assert check(unrad(root(x, 2) + root(x, 2)**3 - 1),
(x**3 + 2*x**2 + x - 1, []))
assert unrad(x**0.5) is None
assert check(unrad(t + root(x + y, 5) + root(x + y, 5)**3),
(s**3 + s + t, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, y),
(s**3 + s + x, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, x),
(s**5 + s**3 + s - y, [s, s**5 - x - y]))
assert check(unrad(root(x - 1, 3) + root(x + 1, 5) + root(2, 5)),
(s**5 + 5*root(2, 5)*s**4 + s**3 + 10*2**Rational(2, 5)*s**3 +
10*2**Rational(3, 5)*s**2 + 5*2**Rational(4, 5)*s + 4, [s, s**3 - x + 1]))
pytest.raises(NotImplementedError,
lambda: unrad((root(x, 2) + root(x, 3) +
root(x, 4)).subs({x: x**5 - x + 1})))
# the simplify flag should be reset to False for unrad results;
# if it's not then this next test will take a long time
assert solve(root(x, 3) + root(x, 5) - 2) == [{x: 1}]
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6*sqrt(5)/5)
assert check(unrad(eq),
((5*x - 4)*(3125*x**3 + 37100*x**2 + 100800*x - 82944), []))
ans = [{x: Rational(4, 5)},
{x: Rational(-1484, 375) + 172564/(140625*cbrt(114*sqrt(12657)/78125 +
Rational(12459439, 52734375))) +
4*cbrt(114*sqrt(12657)/78125 +
Rational(12459439, 52734375))}]
assert solve(eq) == ans
# duplicate radical handling
assert check(unrad(sqrt(x + root(x + 1, 3)) - root(x + 1, 3) - 2),
(s**3 - s**2 - 3*s - 5, [s, s**3 - x - 1]))
# cov post-processing
e = root(x**2 + 1, 3) - root(x**2 - 1, 5) - 2
assert check(unrad(e),
(s**5 - 10*s**4 + 39*s**3 - 80*s**2 + 80*s - 30,
[s, s**3 - x**2 - 1]))
e = sqrt(x + root(x + 1, 2)) - root(x + 1, 3) - 2
assert check(unrad(e),
(s**6 - 2*s**5 - 7*s**4 - 3*s**3 + 26*s**2 + 40*s + 25,
[s, s**3 - x - 1]))
assert check(unrad(e, _reverse=True),
(s**6 - 14*s**5 + 73*s**4 - 187*s**3 + 276*s**2 - 228*s + 89,
[s, s**2 - x - sqrt(x + 1)]))
# this one needs r0, r1 reversal to work
assert check(unrad(sqrt(x + sqrt(root(x, 3) - 1)) - root(x, 6) - 2),
(s**12 - 2*s**8 - 8*s**7 - 8*s**6 + s**4 + 8*s**3 + 23*s**2 +
32*s + 17, [s, s**6 - x]))
# is this needed?
# assert unrad(root(cosh(x), 3)/x*root(x + 1, 5) - 1) == (
# x**15 - x**3*cosh(x)**5 - 3*x**2*cosh(x)**5 - 3*x*cosh(x)**5 - cosh(x)**5, [])
pytest.raises(NotImplementedError, lambda:
unrad(sqrt(cosh(x)/x) + root(x + 1, 3)*sqrt(x) - 1))
assert unrad((x+y)**(2*y/3) + cbrt(x+y) + 1) is None
assert check(unrad((x+y)**(2*y/3) + cbrt(x+y) + 1, x),
(s**(2*y) + s + 1, [s, s**3 - x - y]))
# This tests two things: that if full unrad is attempted and fails
# the solution should still be found; also it tests that the use of
# composite
assert len(solve(sqrt(y)*x + x**3 - 1, x)) == 3
assert len(solve(-512*y**3 + 1344*cbrt(x + 2)*y**2 -
1176*(x + 2)**Rational(2, 3)*y -
169*x + 686, y, _unrad=False)) == 3
# watch out for when the cov doesn't involve the symbol of interest
eq = -x + (7*y/8 - cbrt(27*x/2 + 27*sqrt(x**2)/2)/3)**3 - 1
assert solve(eq, y) == [
{y: RootOf(-2304*x + 1029*y**3 - 1764*cbrt(4)*y**2*cbrt(x + sqrt(x**2)) +
2016*cbrt(2)*y*(x + sqrt(x**2))**Rational(2, 3) -
768*sqrt(x**2) - 1536, y, 0, evaluate=False)},
{y: RootOf(-2304*x + 1029*y**3 - 1764*cbrt(4)*y**2*cbrt(x + sqrt(x**2)) +
2016*cbrt(2)*y*(x + sqrt(x**2))**Rational(2, 3) -
768*sqrt(x**2) - 1536, y, 1, evaluate=False)},
{y: RootOf(-2304*x + 1029*y**3 - 1764*cbrt(4)*y**2*cbrt(x + sqrt(x**2)) +
2016*cbrt(2)*y*(x + sqrt(x**2))**Rational(2, 3) -
768*sqrt(x**2) - 1536, y, 2, evaluate=False)}]
eq = root(x + 1, 3) - (root(x, 3) + root(x, 5))
assert check(unrad(eq),
(3*s**13 + 3*s**11 + s**9 - 1, [s, s**15 - x]))
assert check(unrad(eq - 2),
(3*s**13 + 3*s**11 + 6*s**10 + s**9 + 12*s**8 + 6*s**6 + 12*s**5 +
12*s**3 + 7, [s, s**15 - x]))
assert check(unrad(root(x, 3) - root(x + 1, 4)/2 + root(x + 2, 3)),
(4096*s**13 + 960*s**12 + 48*s**11 - s**10 - 1728*s**4,
[s, s**4 - x - 1])) # orig expr has two real roots: -1, -.389
assert check(unrad(root(x, 3) + root(x + 1, 4) - root(x + 2, 3)/2),
(343*s**13 + 2904*s**12 + 1344*s**11 + 512*s**10 - 1323*s**9 -
3024*s**8 - 1728*s**7 + 1701*s**5 + 216*s**4 - 729*s, [s, s**4 - x -
1])) # orig expr has one real root: -0.048
assert check(unrad(root(x, 3)/2 - root(x + 1, 4) + root(x + 2, 3)),
(729*s**13 - 216*s**12 + 1728*s**11 - 512*s**10 + 1701*s**9 -
3024*s**8 + 1344*s**7 + 1323*s**5 - 2904*s**4 + 343*s, [s, s**4 - x -
1])) # orig expr has 2 real roots: -0.91, -0.15
# orig expr has 1 real root: 19.53
assert check(unrad(root(x, 3)/2 - root(x + 1, 4) + root(x + 2, 3) - 2),
(729*s**13 + 1242*s**12 + 18496*s**10 + 129701*s**9 + 388602*s**8 +
453312*s**7 - 612864*s**6 - 3337173*s**5 - 6332418*s**4 - 7134912*s**3
- 5064768*s**2 - 2111913*s - 398034, [s, s**4 - x - 1]))
ans = solve(sqrt(x) + sqrt(x + 1) -
sqrt(1 - x) - sqrt(2 + x))
assert len(ans) == 1 and NS(ans[0][x])[:4] == '0.73'
# the fence optimization problem
# https://github.com/sympy/sympy/issues/4793#issuecomment-36994519
eq = F - (2*x + 2*y + sqrt(x**2 + y**2))
ans = 2*F/7 - sqrt(2)*F/14
X = solve(eq, x, check=False)
for xi in reversed(X): # reverse since currently, ans is the 2nd one
Y = solve((x*y).subs(xi).diff(y), y,
simplify=False, check=False)
if any((a[y] - ans).expand().is_zero for a in Y):
break
else:
assert None # no answer was found
assert (solve(sqrt(x + 1) + root(x, 3) - 2) ==
[{x: (-11/(9*cbrt(Rational(47, 54) + sqrt(93)/6)) +
Rational(1, 3) + cbrt(Rational(47, 54) +
sqrt(93)/6))**3}])
assert (solve(sqrt(sqrt(x + 1)) + cbrt(x) - 2) ==
[{x: (-sqrt(-2*cbrt(Rational(-1, 16) + sqrt(6913)/16) +
6/cbrt(Rational(-1, 16) + sqrt(6913)/16) +
Rational(17, 2) +
121/(4*sqrt(-6/cbrt(Rational(-1, 16) +
sqrt(6913)/16) +
2*cbrt(Rational(-1, 16) +
sqrt(6913)/16) +
Rational(17, 4))))/2 +
sqrt(-6/cbrt(Rational(-1, 16) + sqrt(6913)/16) +
2*cbrt(Rational(-1, 16) + sqrt(6913)/16) +
Rational(17, 4))/2 + Rational(9, 4))**3}])
assert (solve(sqrt(x) + root(sqrt(x) + 1, 3) - 2) ==
[{x: (-cbrt(Rational(81, 2) + 3*sqrt(741)/2)/3 +
(Rational(81, 2) + 3*sqrt(741)/2)**Rational(-1, 3) + 2)**2}])
eq = (-x + (Rational(1, 2) - sqrt(3)*I/2)*cbrt(3*x**3/2 - x*(3*x**2 - 34)/2 +
sqrt((-3*x**3 + x*(3*x**2 - 34) + 90)**2/4 - Rational(39304, 27)) -
45) + 34/(3*(Rational(1, 2) - sqrt(3)*I/2)*cbrt(3*x**3/2 -
x*(3*x**2 - 34)/2 + sqrt((-3*x**3 + x*(3*x**2 - 34) + 90)**2/4 -
Rational(39304, 27)) - 45)))
assert check(unrad(eq),
(s**6 - sqrt(3)*s**6*I + 102*cbrt(12)*s**4 +
102*2**Rational(2, 3)*3**Rational(5, 6)*s**4*I + 1620*s**3 - 1620*sqrt(3)*s**3*I -
13872*cbrt(18)*s**2 + 471648 - 471648*sqrt(3)*I, [s, s**3 - 306*x
- sqrt(3)*sqrt(31212*x**2 - 165240*x + 61484) + 810]))
assert solve(eq, x, check=False) != [] # not other code errors
def test_unrad1():
pytest.raises(NotImplementedError,
lambda: unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x)) + 3))
pytest.raises(NotImplementedError,
lambda: unrad(sqrt(x) + cbrt(x + 1) + 2 * sqrt(y)))
s = symbols('s', cls=Dummy)
# checkers to deal with possibility of answer coming
# back with a sign change (cf issue sympy/sympy#5203)
def check(rv, ans):
assert bool(rv[1]) == bool(ans[1])
if ans[1]:
return s_check(rv, ans)
e = rv[0].expand()
a = ans[0].expand()
return e in [a, -a] and rv[1] == ans[1]
def s_check(rv, ans):
# get the dummy
rv = list(rv)
d = rv[0].atoms(Dummy)
reps = list(zip(d, [s] * len(d)))
# replace s with this dummy
rv = (rv[0].subs(reps).expand(),
[rv[1][0].subs(reps), rv[1][1].subs(reps)])
ans = (ans[0].subs(reps).expand(),
[ans[1][0].subs(reps), ans[1][1].subs(reps)])
return str(rv[0]) in [str(ans[0]), str(-ans[0])] and \
str(rv[1]) == str(ans[1])
assert check(unrad(sqrt(x)), (x, []))
assert check(unrad(sqrt(x) + 1), (x - 1, []))
assert check(unrad(sqrt(x) + root(x, 3) + 2),
(s**3 + s**2 + 2, [s, s**6 - x]))
assert check(unrad(sqrt(x) * root(x, 3) + 2), (x**5 - 64, []))
assert check(unrad(sqrt(x) + cbrt(x + 1)), (x**3 - (x + 1)**2, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(2 * x)),
(-2 * sqrt(2) * x - 2 * x + 1, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + 2), (16 * x - 9, []))
assert check(unrad(sqrt(x) + sqrt(x + 1) + sqrt(1 - x)),
(5 * x**2 - 4 * x, []))
assert check(unrad(a * sqrt(x) + b * sqrt(x) + c * sqrt(y) + d * sqrt(y)),
((a * sqrt(x) + b * sqrt(x))**2 -
(c * sqrt(y) + d * sqrt(y))**2, []))
assert check(unrad(sqrt(x) + sqrt(1 - x)), (2 * x - 1, []))
assert check(unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x)),
(5 * x**2 - 2 * x + 1, []))
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - 3) in [
(25 * x**4 + 376 * x**3 + 1256 * x**2 - 2272 * x + 784, []),
(25 * x**8 - 476 * x**6 + 2534 * x**4 - 1468 * x**2 + 169, [])
]
assert unrad(sqrt(x) + sqrt(1 - x) + sqrt(2 + x) - sqrt(1 - 2*x)) == \
(41*x**4 + 40*x**3 + 232*x**2 - 160*x + 16, []) # orig root at 0.487
assert check(unrad(sqrt(x) + sqrt(x + 1)), (Integer(1), []))
eq = sqrt(x) + sqrt(x + 1) + sqrt(1 - sqrt(x))
assert check(unrad(eq), (16 * x**2 - 9 * x, []))
assert check(unrad(sqrt(x) + root(x + 1, 3) + 2 * sqrt(y), y),
(2 * sqrt(x) * cbrt(x + 1) + x - 4 * y +
(x + 1)**Rational(2, 3), []))
assert check(unrad(sqrt(x / (1 - x)) + cbrt(x + 1)),
(x**5 - x**4 - x**3 + 2 * x**2 + x - 1, []))
assert check(unrad(sqrt(x / (1 - x)) + 2 * sqrt(y), y),
(4 * x * y + x - 4 * y, []))
assert check(unrad(sqrt(x) * sqrt(1 - x) + 2, x), (x**2 - x + 4, []))
# issue sympy/sympy#8622
assert unrad(
(root(x + 1, 5) - root(x, 3))) == (x**5 - x**3 - 3 * x**2 - 3 * x - 1,
[])
# issue sympy/sympy#8679
assert check(unrad(x + root(x, 3) + root(x, 3)**2 + sqrt(y), x),
(s**3 + s**2 + s + sqrt(y), [s, s**3 - x]))
# for coverage
assert check(unrad(sqrt(x) + root(x, 3) + y),
(s**3 + s**2 + y, [s, s**6 - x]))
# unrad some
e = root(x + 1, 3) + root(x, 3)
assert unrad(e) == (2 * x + 1, [])
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5)
assert check(unrad(eq), (15625 * x**4 + 173000 * x**3 + 355600 * x**2 -
817920 * x + 331776, []))
assert check(unrad(root(x, 4) + root(x, 4)**3 - 1),
(s**3 + s - 1, [s, s**4 - x]))
assert check(unrad(root(x, 2) + root(x, 2)**3 - 1),
(x**3 + 2 * x**2 + x - 1, []))
assert unrad(x**0.5) is None
assert check(unrad(t + root(x + y, 5) + root(x + y, 5)**3),
(s**3 + s + t, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, y),
(s**3 + s + x, [s, s**5 - x - y]))
assert check(unrad(x + root(x + y, 5) + root(x + y, 5)**3, x),
(s**5 + s**3 + s - y, [s, s**5 - x - y]))
assert check(
unrad(root(x - 1, 3) + root(x + 1, 5) + root(2, 5)),
(s**5 + 5 * root(2, 5) * s**4 + s**3 + 10 * 2**Rational(2, 5) * s**3 +
10 * 2**Rational(3, 5) * s**2 + 5 * 2**Rational(4, 5) * s + 4,
[s, s**3 - x + 1]))
pytest.raises(
NotImplementedError, lambda: unrad(
(root(x, 2) + root(x, 3) + root(x, 4)).subs({x: x**5 - x + 1})))
# the simplify flag should be reset to False for unrad results;
# if it's not then this next test will take a long time
eq = (sqrt(x) + sqrt(x + 1) + sqrt(1 - x) - 6 * sqrt(5) / 5)
assert check(unrad(eq),
((5 * x - 4) *
(3125 * x**3 + 37100 * x**2 + 100800 * x - 82944), []))
# duplicate radical handling
assert check(unrad(sqrt(x + root(x + 1, 3)) - root(x + 1, 3) - 2),
(s**3 - s**2 - 3 * s - 5, [s, s**3 - x - 1]))
# cov post-processing
e = root(x**2 + 1, 3) - root(x**2 - 1, 5) - 2
assert check(unrad(e),
(s**5 - 10 * s**4 + 39 * s**3 - 80 * s**2 + 80 * s - 30,
[s, s**3 - x**2 - 1]))
e = sqrt(x + root(x + 1, 2)) - root(x + 1, 3) - 2
assert check(unrad(e), (s**6 - 2 * s**5 - 7 * s**4 - 3 * s**3 + 26 * s**2 +
40 * s + 25, [s, s**3 - x - 1]))
assert check(unrad(e, _reverse=True),
(s**6 - 14 * s**5 + 73 * s**4 - 187 * s**3 + 276 * s**2 -
228 * s + 89, [s, s**2 - x - sqrt(x + 1)]))
# this one needs r0, r1 reversal to work
assert check(unrad(sqrt(x + sqrt(root(x, 3) - 1)) - root(x, 6) - 2),
(s**12 - 2 * s**8 - 8 * s**7 - 8 * s**6 + s**4 + 8 * s**3 +
23 * s**2 + 32 * s + 17, [s, s**6 - x]))
# is this needed?
# assert unrad(root(cosh(x), 3)/x*root(x + 1, 5) - 1) == (
# x**15 - x**3*cosh(x)**5 - 3*x**2*cosh(x)**5 - 3*x*cosh(x)**5 - cosh(x)**5, [])
pytest.raises(
NotImplementedError,
lambda: unrad(sqrt(cosh(x) / x) + root(x + 1, 3) * sqrt(x) - 1))
assert unrad((x + y)**(2 * y / 3) + cbrt(x + y) + 1) is None
assert check(unrad((x + y)**(2 * y / 3) + cbrt(x + y) + 1, x),
(s**(2 * y) + s + 1, [s, s**3 - x - y]))
eq = root(x + 1, 3) - (root(x, 3) + root(x, 5))
assert check(unrad(eq), (3 * s**13 + 3 * s**11 + s**9 - 1, [s, s**15 - x]))
assert check(unrad(eq - 2),
(3 * s**13 + 3 * s**11 + 6 * s**10 + s**9 + 12 * s**8 +
6 * s**6 + 12 * s**5 + 12 * s**3 + 7, [s, s**15 - x]))
assert check(
unrad(root(x, 3) - root(x + 1, 4) / 2 + root(x + 2, 3)),
(4096 * s**13 + 960 * s**12 + 48 * s**11 - s**10 - 1728 * s**4,
[s, s**4 - x - 1])) # orig expr has two real roots: -1, -.389
assert check(
unrad(root(x, 3) + root(x + 1, 4) - root(x + 2, 3) / 2),
(343 * s**13 + 2904 * s**12 + 1344 * s**11 + 512 * s**10 -
1323 * s**9 - 3024 * s**8 - 1728 * s**7 + 1701 * s**5 + 216 * s**4 -
729 * s, [s, s**4 - x - 1])) # orig expr has one real root: -0.048
assert check(
unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3)),
(729 * s**13 - 216 * s**12 + 1728 * s**11 - 512 * s**10 + 1701 * s**9 -
3024 * s**8 + 1344 * s**7 + 1323 * s**5 - 2904 * s**4 + 343 * s,
[s, s**4 - x - 1])) # orig expr has 2 real roots: -0.91, -0.15
# orig expr has 1 real root: 19.53
assert check(unrad(root(x, 3) / 2 - root(x + 1, 4) + root(x + 2, 3) - 2),
(729 * s**13 + 1242 * s**12 + 18496 * s**10 + 129701 * s**9 +
388602 * s**8 + 453312 * s**7 - 612864 * s**6 -
3337173 * s**5 - 6332418 * s**4 - 7134912 * s**3 -
5064768 * s**2 - 2111913 * s - 398034, [s, s**4 - x - 1]))
eq = (-x + (Rational(1, 2) - sqrt(3) * I / 2) *
cbrt(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt(
(-3 * x**3 + x *
(3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45) + 34 /
(3 * (Rational(1, 2) - sqrt(3) * I / 2) *
cbrt(3 * x**3 / 2 - x * (3 * x**2 - 34) / 2 + sqrt(
(-3 * x**3 + x *
(3 * x**2 - 34) + 90)**2 / 4 - Rational(39304, 27)) - 45)))
assert check(unrad(eq),
(s**6 - sqrt(3) * s**6 * I + 102 * cbrt(12) * s**4 +
102 * 2**Rational(2, 3) * 3**Rational(5, 6) * s**4 * I +
1620 * s**3 - 1620 * sqrt(3) * s**3 * I -
13872 * cbrt(18) * s**2 + 471648 - 471648 * sqrt(3) * I, [
s, s**3 - 306 * x -
sqrt(3) * sqrt(31212 * x**2 - 165240 * x + 61484) + 810
]))
