def test_hyper_as_trig():
from sympy.simplify.fu import _osborne, _osbornei
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 _osborne(sinh(x), d) == I * sin(x * d)
assert _osborne(tanh(x), d) == I * tan(x * d)
assert _osborne(coth(x), d) == cot(x * d) / I
assert _osborne(cosh(x), d) == cos(x * d)
assert _osborne(sech(x), d) == sec(x * d)
assert _osborne(csch(x), d) == csc(x * d) / I
for func in (sinh, cosh, tanh, coth, sech, csch):
h = func(pi)
assert _osbornei(_osborne(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 _osbornei(cos(x * y + z), y) == cosh(x + z * I)
assert _osbornei(sin(x * y + z), y) == sinh(x + z * I) / I
assert _osbornei(tan(x * y + z), y) == tanh(x + z * I) / I
assert _osbornei(cot(x * y + z), y) == coth(x + z * I) * I
assert _osbornei(sec(x * y + z), y) == sech(x + z * I)
assert _osbornei(csc(x * y + z), y) == csch(x + z * I) * I
def test_simplifications():
x = Symbol('x')
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_csch_rewrite():
x = Symbol('x')
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)
tanh_half = tanh(S.Half * x)
assert csch(x).rewrite(tanh) == (1 - tanh_half**2) / (2 * tanh_half)
coth_half = coth(S.Half * x)
assert csch(x).rewrite(coth) == (coth_half**2 - 1) / (2 * coth_half)
def test_derivs():
x = Symbol('x')
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)
assert asech(x).diff(x) == -1 / (x * sqrt(1 - x**2))
assert acsch(x).diff(x) == -1 / (x**2 * sqrt(1 + x**(-2)))
def test_sign_assumptions():
p = Symbol('p', positive=True)
n = Symbol('n', negative=True)
assert sinh(n).is_negative is True
assert sinh(p).is_positive is True
assert cosh(n).is_positive is True
assert cosh(p).is_positive is True
assert tanh(n).is_negative is True
assert tanh(p).is_positive is True
assert csch(n).is_negative is True
assert csch(p).is_positive is True
assert sech(n).is_positive is True
assert sech(p).is_positive is True
assert coth(n).is_negative is True
assert coth(p).is_positive is True
def test_manualintegrate_trigonometry():
assert manualintegrate(sin(x), x) == -cos(x)
assert manualintegrate(tan(x), x) == -log(cos(x))
assert manualintegrate(sec(x), x) == log(sec(x) + tan(x))
assert manualintegrate(csc(x), x) == -log(csc(x) + cot(x))
assert manualintegrate(sin(x) * cos(x),
x) in [sin(x)**2 / 2, -cos(x)**2 / 2]
assert manualintegrate(-sec(x) * tan(x), x) == -sec(x)
assert manualintegrate(csc(x) * cot(x), x) == -csc(x)
assert manualintegrate(sec(x)**2, x) == tan(x)
assert manualintegrate(csc(x)**2, x) == -cot(x)
assert manualintegrate(x * sec(x**2), x) == log(tan(x**2) + sec(x**2)) / 2
assert manualintegrate(cos(x) * csc(sin(x)),
x) == -log(cot(sin(x)) + csc(sin(x)))
assert manualintegrate(cos(3 * x) * sec(x), x) == -x + sin(2 * x)
assert manualintegrate(sin(3*x)*sec(x), x) == \
-3*log(cos(x)) + 2*log(cos(x)**2) - 2*cos(x)**2
assert_is_integral_of(sinh(2 * x), cosh(2 * x) / 2)
assert_is_integral_of(x * cosh(x**2), sinh(x**2) / 2)
assert_is_integral_of(tanh(x), log(cosh(x)))
assert_is_integral_of(coth(x), log(sinh(x)))
f, F = sech(x), 2 * atan(tanh(x / 2))
assert manualintegrate(f, x) == F
assert (F.diff(x) -
f).rewrite(exp).simplify() == 0 # todo: equals returns None
f, F = csch(x), log(tanh(x / 2))
assert manualintegrate(f, x) == F
assert (F.diff(x) - f).rewrite(exp).simplify() == 0
def test_real_assumptions():
z = Symbol('z', real=False)
assert sinh(z).is_real is None
assert cosh(z).is_real is None
assert tanh(z).is_real is None
assert sech(z).is_real is None
assert csch(z).is_real is None
assert coth(z).is_real is None
def f(rv):
if not isinstance(rv, TrigonometricFunction):
return rv
const, x = rv.args[0].as_independent(d, as_Add=True)
a = x.xreplace({d: S.One}) + const * I
if isinstance(rv, sin):
return sinh(a) / I
elif isinstance(rv, cos):
return cosh(a)
elif isinstance(rv, tan):
return tanh(a) / I
elif isinstance(rv, cot):
return coth(a) * I
elif isinstance(rv, sec):
return sech(a)
elif isinstance(rv, csc):
return csch(a) * I
else:
raise NotImplementedError('unhandled %s' % rv.func)
def test_complex():
a, b = symbols('a,b', 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_acsch():
x = Symbol('x')
assert unchanged(acsch, x)
assert acsch(-x) == -acsch(x)
# values at fixed points
assert acsch(1) == log(1 + sqrt(2))
assert acsch(-1) == -log(1 + sqrt(2))
assert acsch(0) is zoo
assert acsch(2) == log((1 + sqrt(5)) / 2)
assert acsch(-2) == -log((1 + sqrt(5)) / 2)
assert acsch(I) == -I * pi / 2
assert acsch(-I) == I * pi / 2
assert acsch(-I * (sqrt(6) + sqrt(2))) == I * pi / 12
assert acsch(I * (sqrt(2) + sqrt(6))) == -I * pi / 12
assert acsch(-I * (1 + sqrt(5))) == I * pi / 10
assert acsch(I * (1 + sqrt(5))) == -I * pi / 10
assert acsch(-I * 2 / sqrt(2 - sqrt(2))) == I * pi / 8
assert acsch(I * 2 / sqrt(2 - sqrt(2))) == -I * pi / 8
assert acsch(-I * 2) == I * pi / 6
assert acsch(I * 2) == -I * pi / 6
assert acsch(-I * sqrt(2 + 2 / sqrt(5))) == I * pi / 5
assert acsch(I * sqrt(2 + 2 / sqrt(5))) == -I * pi / 5
assert acsch(-I * sqrt(2)) == I * pi / 4
assert acsch(I * sqrt(2)) == -I * pi / 4
assert acsch(-I * (sqrt(5) - 1)) == 3 * I * pi / 10
assert acsch(I * (sqrt(5) - 1)) == -3 * I * pi / 10
assert acsch(-I * 2 / sqrt(3)) == I * pi / 3
assert acsch(I * 2 / sqrt(3)) == -I * pi / 3
assert acsch(-I * 2 / sqrt(2 + sqrt(2))) == 3 * I * pi / 8
assert acsch(I * 2 / sqrt(2 + sqrt(2))) == -3 * I * pi / 8
assert acsch(-I * sqrt(2 - 2 / sqrt(5))) == 2 * I * pi / 5
assert acsch(I * sqrt(2 - 2 / sqrt(5))) == -2 * I * pi / 5
assert acsch(-I * (sqrt(6) - sqrt(2))) == 5 * I * pi / 12
assert acsch(I * (sqrt(6) - sqrt(2))) == -5 * I * pi / 12
assert acsch(nan) is nan
# properties
# acsch(x) == asinh(1/x)
assert acsch(-I * sqrt(2)) == asinh(I / sqrt(2))
assert acsch(-I * 2 / sqrt(3)) == asinh(I * sqrt(3) / 2)
# acsch(x) == -I*asin(I/x)
assert acsch(-I * sqrt(2)) == -I * asin(-1 / sqrt(2))
assert acsch(-I * 2 / sqrt(3)) == -I * asin(-sqrt(3) / 2)
# csch(acsch(x)) / x == 1
assert expand_mul(
csch(acsch(-I * (sqrt(6) + sqrt(2)))) / (-I *
(sqrt(6) + sqrt(2)))) == 1
assert expand_mul(csch(acsch(I * (1 + sqrt(5)))) / (I *
(1 + sqrt(5)))) == 1
assert (csch(acsch(I * sqrt(2 - 2 / sqrt(5)))) /
(I * sqrt(2 - 2 / sqrt(5)))).simplify() == 1
assert (csch(acsch(-I * sqrt(2 - 2 / sqrt(5)))) /
(-I * sqrt(2 - 2 / sqrt(5)))).simplify() == 1
# numerical evaluation
assert str(acsch(5 * I + 1).n(6)) == '0.0391819 - 0.193363*I'
assert str(acsch(-5 * I + 1).n(6)) == '0.0391819 + 0.193363*I'
def test_csch_fdiff():
x = Symbol('x')
raises(ArgumentIndexError, lambda: csch(x).fdiff(2))
def test_csch_series():
x = Symbol('x')
assert csch(x).series(x, 0, 10) == \
1/ x - x/6 + 7*x**3/360 - 31*x**5/15120 + 127*x**7/604800 \
- 73*x**9/3421440 + O(x**10)
def test_csch():
x, y = symbols('x,y')
k = Symbol('k', integer=True)
n = Symbol('n', positive=True)
assert csch(nan) is nan
assert csch(zoo) is nan
assert csch(oo) == 0
assert csch(-oo) == 0
assert csch(0) is zoo
assert csch(-1) == -csch(1)
assert csch(-x) == -csch(x)
assert csch(-pi) == -csch(pi)
assert csch(-2**1024 * E) == -csch(2**1024 * E)
assert csch(pi * I) is zoo
assert csch(-pi * I) is zoo
assert csch(2 * pi * I) is zoo
assert csch(-2 * pi * I) is zoo
assert csch(-3 * 10**73 * pi * I) is zoo
assert csch(7 * 10**103 * pi * I) is zoo
assert csch(pi * I / 2) == -I
assert csch(-pi * I / 2) == I
assert csch(pi * I * Rational(5, 2)) == -I
assert csch(pi * I * Rational(7, 2)) == I
assert csch(pi * I / 3) == -2 / sqrt(3) * I
assert csch(pi * I * Rational(-2, 3)) == 2 / sqrt(3) * I
assert csch(pi * I / 4) == -sqrt(2) * I
assert csch(-pi * I / 4) == sqrt(2) * I
assert csch(pi * I * Rational(7, 4)) == sqrt(2) * I
assert csch(pi * I * Rational(-3, 4)) == sqrt(2) * I
assert csch(pi * I / 6) == -2 * I
assert csch(-pi * I / 6) == 2 * I
assert csch(pi * I * Rational(7, 6)) == 2 * I
assert csch(pi * I * Rational(-7, 6)) == -2 * I
assert csch(pi * I * Rational(-5, 6)) == 2 * I
assert csch(pi * I / 105) == -1 / sin(pi / 105) * I
assert csch(-pi * I / 105) == 1 / sin(pi / 105) * I
assert csch(x * I) == -1 / sin(x) * I
assert csch(k * pi * I) is zoo
assert csch(17 * k * pi * I) is zoo
assert csch(k * pi * I / 2) == -1 / sin(k * pi / 2) * I
assert csch(n).is_real is True
assert expand_trig(csch(x +
y)) == 1 / (sinh(x) * cosh(y) + cosh(x) * sinh(y))
def test_issue_11254b():
assert not integrate(csch(x), (x, 0, 1)).has(Integral)