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 lstm_recursive(x, *limits): (W, ), (Wh, ), (b, ), (t, ) = limits hc = lstm[W, Wh, b, t - 1](x) xt = x[t] h = Indexed(hc, 0) c = Indexed(hc, 1) d = h.shape[-1] Wi = W[:, :d] Wf = W[:, d:2 * d] Wc = W[:, 2 * d:3 * d] Wo = W[:, -d:] Whi = Wh[:, :d] Whf = Wh[:, d:2 * d] Whc = Wh[:, 2 * d:3 * d] Who = Wh[:, -d:] bi = b[:d] bf = b[d:2 * d] bc = b[2 * d:3 * d] bo = b[-d:] i = sigmoid(xt @ Wi + h @ Whi + bi) f = sigmoid(xt @ Wf + h @ Whf + bf) c = f * c + i * tanh(xt @ Wc + h @ Whc + bc) o = sigmoid(xt @ Wo + h @ Who + bo) return Piecewise((BlockMatrix(o * tanh(c), c), t > 0), (ZeroMatrix(*hc.shape), True))
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_tanh_rewrite(): x = Symbol('x') assert tanh(x).rewrite(exp) == (exp(x) - exp(-x))/(exp(x) + exp(-x)) \ == tanh(x).rewrite('tractable') assert tanh(x).rewrite(sinh) == I * sinh(x) / sinh(I * pi / 2 - x) assert tanh(x).rewrite(cosh) == I * cosh(I * pi / 2 - x) / cosh(x) assert tanh(x).rewrite(coth) == 1 / coth(x)
def test_gruntz_hyperbolic(): assert gruntz(cosh(x), x, oo) == oo assert gruntz(cosh(x), x, -oo) == oo assert gruntz(sinh(x), x, oo) == oo assert gruntz(sinh(x), x, -oo) == -oo assert gruntz(2*cosh(x)*exp(x), x, oo) == oo assert gruntz(2*cosh(x)*exp(x), x, -oo) == 1 assert gruntz(2*sinh(x)*exp(x), x, oo) == oo assert gruntz(2*sinh(x)*exp(x), x, -oo) == -1 assert gruntz(tanh(x), x, oo) == 1 assert gruntz(tanh(x), x, -oo) == -1 assert gruntz(coth(x), x, oo) == 1 assert gruntz(coth(x), x, -oo) == -1
def test_gruntz_hyperbolic(): assert gruntz(cosh(x), x, oo) is oo assert gruntz(cosh(x), x, -oo) is oo assert gruntz(sinh(x), x, oo) is oo assert gruntz(sinh(x), x, -oo) is -oo assert gruntz(2 * cosh(x) * exp(x), x, oo) is oo assert gruntz(2 * cosh(x) * exp(x), x, -oo) == 1 assert gruntz(2 * sinh(x) * exp(x), x, oo) is oo assert gruntz(2 * sinh(x) * exp(x), x, -oo) == -1 assert gruntz(tanh(x), x, oo) == 1 assert gruntz(tanh(x), x, -oo) == -1 assert gruntz(coth(x), x, oo) == 1 assert gruntz(coth(x), x, -oo) == -1
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_heurisch_trigonometric(): assert heurisch(sin(x), x) == -cos(x) assert heurisch(pi * sin(x) + 1, x) == x - pi * cos(x) assert heurisch(cos(x), x) == sin(x) assert heurisch(tan(x), x) in [ log(1 + tan(x)**2) / 2, log(tan(x) + I) + I * x, log(tan(x) - I) - I * x, ] assert heurisch(sin(x) * sin(y), x) == -cos(x) * sin(y) assert heurisch(sin(x) * sin(y), y) == -cos(y) * sin(x) # gives sin(x) in answer when run via setup.py and cos(x) when run via py.test assert heurisch(sin(x) * cos(x), x) in [sin(x)**2 / 2, -cos(x)**2 / 2] assert heurisch(cos(x) / sin(x), x) == log(sin(x)) assert heurisch(x * sin(7 * x), x) == sin(7 * x) / 49 - x * cos(7 * x) / 7 assert heurisch( 1 / pi / 4 * x**2 * cos(x), x) == 1 / pi / 4 * (x**2 * sin(x) - 2 * sin(x) + 2 * x * cos(x)) assert heurisch(acos(x/4) * asin(x/4), x) == 2*x - (sqrt(16 - x**2))*asin(x/4) \ + (sqrt(16 - x**2))*acos(x/4) + x*asin(x/4)*acos(x/4) assert heurisch(sin(x) / (cos(x)**2 + 1), x) == -atan(cos(x)) #fixes issue 13723 assert heurisch(1 / (cos(x) + 2), x) == 2 * sqrt(3) * atan(sqrt(3) * tan(x / 2) / 3) / 3 assert heurisch( 2 * sin(x) * cos(x) / (sin(x)**4 + 1), x) == atan(sqrt(2) * sin(x) - 1) - atan(sqrt(2) * sin(x) + 1) assert heurisch(1 / cosh(x), x) == 2 * atan(tanh(x / 2))
def test_function_series3(): """ Test our easy "tanh" function. This test tests two things: * that the Function interface works as expected and it's easy to use * that the general algorithm for the series expansion works even when the derivative is defined recursively in terms of the original function, since tanh(x).diff(x) == 1-tanh(x)**2 """ class mytanh(Function): def fdiff(self, argindex=1): return 1 - mytanh(self.args[0])**2 @classmethod def eval(cls, arg): arg = sympify(arg) if arg == 0: return sympify(0) e = tanh(x) f = mytanh(x) assert e.series(x, 0, 6) == f.series(x, 0, 6)
def gru_recursive(x, *limits): (Wx, ), (Wh, ), (b, ), (t, ) = limits h = gru[Wx, Wh, b, t - 1](x) d = h.shape[-1] xt = x[t] Wxz = Wx[:, :d] Wxr = Wx[:, d:2 * d] Wxh = Wx[:, -d:] Whz = Wh[:, :d] Whr = Wh[:, d:2 * d] Whh = Wh[:, -d:] bz = b[:d] br = b[d:2 * d] bh = b[-d:] z = sigmoid(xt @ Wxz + h @ Whz + bz) r = sigmoid(xt @ Wxr + h @ Whr + br) gh = tanh(xt @ Wxh + (r * h) @ Whh + bh) return Piecewise(((1 - z) * gh + z * h, t > 0), (ZeroMatrix(*h.shape), True))
def test_unpolarify(): from sympy.functions.elementary.complexes import (polar_lift, principal_branch, unpolarify) from sympy.core.relational import Ne from sympy.functions.elementary.hyperbolic import tanh from sympy.functions.special.error_functions import erf from sympy.functions.special.gamma_functions import (gamma, uppergamma) from sympy.abc import x p = exp_polar(7 * I) + 1 u = exp(7 * I) + 1 assert unpolarify(1) == 1 assert unpolarify(p) == u assert unpolarify(p**2) == u**2 assert unpolarify(p**x) == p**x assert unpolarify(p * x) == u * x assert unpolarify(p + x) == u + x assert unpolarify(sqrt(sin(p))) == sqrt(sin(u)) # Test reduction to principal branch 2*pi. t = principal_branch(x, 2 * pi) assert unpolarify(t) == x assert unpolarify(sqrt(t)) == sqrt(t) # Test exponents_only. assert unpolarify(p**p, exponents_only=True) == p**u assert unpolarify(uppergamma(x, p**p)) == uppergamma(x, p**u) # Test functions. assert unpolarify(sin(p)) == sin(u) assert unpolarify(tanh(p)) == tanh(u) assert unpolarify(gamma(p)) == gamma(u) assert unpolarify(erf(p)) == erf(u) assert unpolarify(uppergamma(x, p)) == uppergamma(x, p) assert unpolarify(uppergamma(sin(p), sin(p + exp_polar(0)))) == \ uppergamma(sin(u), sin(u + 1)) assert unpolarify(uppergamma(polar_lift(0), 2*exp_polar(0))) == \ uppergamma(0, 2) assert unpolarify(Eq(p, 0)) == Eq(u, 0) assert unpolarify(Ne(p, 0)) == Ne(u, 0) assert unpolarify(polar_lift(x) > 0) == (x > 0) # Test bools assert unpolarify(True) is True
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 test_issue_6999(): s = tanh(x).lseries(x, 1) assert next(s) == tanh(1) assert next(s) == x - (x - 1) * tanh(1)**2 - 1 assert next(s) == -(x - 1)**2 * tanh(1) + (x - 1)**2 * tanh(1)**3 assert next(s) == -(x - 1)**3*tanh(1)**4 - (x - 1)**3/3 + \ 4*(x - 1)**3*tanh(1)**2/3
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_sech_rewrite(): x = Symbol('x') assert sech(x).rewrite(exp) == 1 / (exp(x)/2 + exp(-x)/2) \ == sech(x).rewrite('tractable') assert sech(x).rewrite(sinh) == I / sinh(x + I * pi / 2) tanh_half = tanh(S.Half * x)**2 assert sech(x).rewrite(tanh) == (1 - tanh_half) / (1 + tanh_half) coth_half = coth(S.Half * x)**2 assert sech(x).rewrite(coth) == (coth_half - 1) / (coth_half + 1)
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_cosh_rewrite(): x = Symbol('x') 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) tanh_half = tanh(S.Half * x)**2 assert cosh(x).rewrite(tanh) == (1 + tanh_half) / (1 - tanh_half) coth_half = coth(S.Half * x)**2 assert cosh(x).rewrite(coth) == (coth_half + 1) / (coth_half - 1)
def test_sinh_rewrite(): x = Symbol('x') 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) tanh_half = tanh(S.Half * x) assert sinh(x).rewrite(tanh) == 2 * tanh_half / (1 - tanh_half**2) coth_half = coth(S.Half * x) assert sinh(x).rewrite(coth) == 2 * coth_half / (coth_half**2 - 1)
def test_issue_21177(): r = -sqrt(3) * tanh(sqrt(3) * pi / 2) / 3 a = residue( cot(pi * x) / ((x - 1) * (x - 2) + 1), x, S(3) / 2 - sqrt(3) * I / 2) b = residue( cot(pi * x) / (x**2 - 3 * x + 3), x, S(3) / 2 - sqrt(3) * I / 2) assert a == r assert (b - a).cancel() == 0
def test_exptrigsimp(): def valid(a, b): from sympy.core.random import verify_numerically as tn 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) assert exptrigsimp( (2 * exp(x) - 2 * exp(-x)) / (exp(x) + exp(-x))) == 2 * tanh(x) assert exptrigsimp((2 * exp(2 * x) - 2) / (exp(2 * x) + 1)) == 2 * tanh(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) res.append(simplify(eq)) res.append(simplify(1 / eq)) 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_inverses(): x = Symbol('x') assert sinh(x).inverse() == asinh 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 assert asech(x).inverse() == sech assert acsch(x).inverse() == csch
def test_hyperbolic(): assert sinh(x).nseries(x, n=6) == x + x**3 / 6 + x**5 / 120 + O(x**6) assert cosh(x).nseries(x, n=5) == 1 + x**2 / 2 + x**4 / 24 + O(x**5) assert tanh(x).nseries(x, n=6) == x - x**3 / 3 + 2 * x**5 / 15 + O(x**6) assert coth(x).nseries(x, n=6) == \ 1/x - x**3/45 + x/3 + 2*x**5/945 + O(x**6) assert asinh(x).nseries(x, n=6) == x - x**3 / 6 + 3 * x**5 / 40 + O(x**6) assert acosh(x).nseries(x, n=6) == \ pi*I/2 - I*x - 3*I*x**5/40 - I*x**3/6 + O(x**6) assert atanh(x).nseries(x, n=6) == x + x**3 / 3 + x**5 / 5 + O(x**6) assert acoth(x).nseries( x, n=6) == x + x**3 / 3 + x**5 / 5 + pi * I / 2 + O(x**6)
def test_trigsimp1(): x, y = symbols('x,y') 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_trigsimp_groebner(): from sympy.simplify.trigsimp import trigsimp_groebner c = cos(x) s = sin(x) ex = (4 * s * c + 12 * s + 5 * c**3 + 21 * c**2 + 23 * c + 15) / ( -s * c**2 + 2 * s * c + 15 * s + 7 * c**3 + 31 * c**2 + 37 * c + 21) resnum = (5 * s - 5 * c + 1) resdenom = (8 * s - 6 * c) results = [resnum / resdenom, (-resnum) / (-resdenom)] assert trigsimp_groebner(ex) in results assert trigsimp_groebner(s / c, hints=[tan]) == tan(x) assert trigsimp_groebner(c * s) == c * s assert trigsimp((-s + 1) / c + c / (-s + 1), method='groebner') == 2 / c assert trigsimp((-s + 1) / c + c / (-s + 1), method='groebner', polynomial=True) == 2 / c # Test quick=False works assert trigsimp_groebner(ex, hints=[2]) in results assert trigsimp_groebner(ex, hints=[int(2)]) in results # test "I" assert trigsimp_groebner(sin(I * x) / cos(I * x), hints=[tanh]) == I * tanh(x) # test hyperbolic / sums assert trigsimp_groebner((tanh(x) + tanh(y)) / (1 + tanh(x) * tanh(y)), hints=[(tanh, x, y)]) == tanh(x + y)
def test_evalc(): x = Symbol("x", real=True) y = Symbol("y", 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", real=True) b = Symbol("b", 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_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_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(1).rewrite(sin) == sinh(1) + cosh(1) assert exp(x).rewrite(tanh) == (1 + tanh(x / 2)) / (1 - tanh(x / 2)) assert exp(pi * I / 4).rewrite(sqrt) == sqrt(2) / 2 + sqrt(2) * I / 2 assert exp(pi * I / 3).rewrite(sqrt) == S.Half + sqrt(3) * I / 2 if not global_parameters.exp_is_pow: assert exp(x * log(y)).rewrite(Pow) == y**x assert exp(log(x) * log(y)).rewrite(Pow) in [x**log(y), y**log(x)] assert exp(log(log(x)) * y).rewrite(Pow) == log(x)**y n = Symbol('n', integer=True) assert Sum((exp(pi * I / 2) / 2)**n, (n, 0, oo)).rewrite(sqrt).doit() == Rational(4, 5) + I * 2 / 5 assert Sum( (exp(pi * I / 4) / 2)**n, (n, 0, oo)).rewrite(sqrt).doit() == 1 / (1 - sqrt(2) * (1 + I) / 4) assert (Sum( (exp(pi * I / 3) / 2)**n, (n, 0, oo)).rewrite(sqrt).doit().cancel() == 4 * I / (sqrt(3) + 3 * I))
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_sympy__functions__elementary__hyperbolic__tanh(): from sympy.functions.elementary.hyperbolic import tanh assert _test_args(tanh(2))