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_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 f(rv): if not rv.is_Mul: return rv args = {tan: [], cot: [], None: []} for a in ordered(Mul.make_args(rv)): if a.func in (tan, cot): args[a.func].append(a.args[0]) else: args[None].append(a) t = args[tan] c = args[cot] if len(t) < 2 and len(c) < 2: return rv args = args[None] while len(t) > 1: t1 = t.pop() t2 = t.pop() args.append(1 - (tan(t1) / tan(t1 + t2) + tan(t2) / tan(t1 + t2))) if t: args.append(tan(t.pop())) while len(c) > 1: t1 = c.pop() t2 = c.pop() args.append(1 + cot(t1) * cot(t1 + t2) + cot(t2) * cot(t1 + t2)) if c: args.append(cot(c.pop())) return Mul(*args)
def test_hyperbolic_simp(): x, y = symbols('x,y') 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) for a in (pi / 6 * I, pi / 4 * I, pi / 3 * I): assert trigsimp(sinh(a) * cosh(x) + cosh(a) * sinh(x)) == sinh(x + a) assert trigsimp(-sinh(a) * cosh(x) + cosh(a) * sinh(x)) == sinh(x - a) e = 2 * cosh(x)**2 - 2 * sinh(x)**2 assert trigsimp(log(e)) == log(2) # issue 19535: assert trigsimp(sqrt(cosh(x)**2 - 1)) == sqrt(sinh(x)**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_has(): assert cot(x).has(x) assert cot(x).has(cot) assert not cot(x).has(sin) assert sin(x).has(x) assert sin(x).has(sin) assert not sin(x).has(cot) assert exp(x).has(exp)
def test_find_substitutions(): assert find_substitutions((cot(x)**2 + 1)**2*csc(x)**2*cot(x)**2, x, u) == \ [(cot(x), 1, -u**6 - 2*u**4 - u**2)] assert find_substitutions( (sec(x)**2 + tan(x) * sec(x)) / (sec(x) + tan(x)), x, u) == [(sec(x) + tan(x), 1, 1 / u)] assert (-x**2, Rational(-1, 2), exp(u)) in find_substitutions(x * exp(-x**2), x, u)
def test_issues_14525(): assert limit(sin(x)**2 - cos(x) + tan(x)*csc(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity) assert limit(sin(x)**2 - cos(x) + sin(x)*cot(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity) assert limit(cot(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity) assert limit(cos(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One) assert limit(sin(x) - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One) assert limit(cos(x)**2 - tan(x)**2, x, oo) == AccumBounds(S.NegativeInfinity, S.One) assert limit(tan(x)**2 + sin(x)**2 - cos(x), x, oo) == AccumBounds(-S.One, S.Infinity)
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_TR13(): assert TR13(tan(3) * tan(2)) == -tan(2) / tan(5) - tan(3) / tan(5) + 1 assert TR13(cot(3) * cot(2)) == 1 + cot(3) * cot(5) + cot(2) * cot(5) assert TR13(tan(1)*tan(2)*tan(3)) == \ (-tan(2)/tan(5) - tan(3)/tan(5) + 1)*tan(1) assert TR13(tan(1)*tan(2)*cot(3)) == \ (-tan(2)/tan(3) + 1 - tan(1)/tan(3))*cot(3)
def test_manualintegrate_trigpowers(): assert manualintegrate(sin(x)**2 * cos(x), x) == sin(x)**3 / 3 assert manualintegrate(sin(x)**2 * cos(x) **2, x) == \ x / 8 - sin(4*x) / 32 assert manualintegrate(sin(x) * cos(x)**3, x) == -cos(x)**4 / 4 assert manualintegrate(sin(x)**3 * cos(x)**2, x) == \ cos(x)**5 / 5 - cos(x)**3 / 3 assert manualintegrate(tan(x)**3 * sec(x), x) == sec(x)**3 / 3 - sec(x) assert manualintegrate(tan(x) * sec(x)**2, x) == sec(x)**2 / 2 assert manualintegrate(cot(x)**5 * csc(x), x) == \ -csc(x)**5/5 + 2*csc(x)**3/3 - csc(x) assert manualintegrate(cot(x)**2 * csc(x)**6, x) == \ -cot(x)**7/7 - 2*cot(x)**5/5 - cot(x)**3/3
def _eval_expand_func(self, **hints): from sympy import Sum n = self.args[0] m = self.args[1] if len(self.args) == 2 else 1 if m == S.One: if n.is_Add: off = n.args[0] nnew = n - off if off.is_Integer and off.is_positive: result = [S.One/(nnew + i) for i in range(off, 0, -1)] + [harmonic(nnew)] return Add(*result) elif off.is_Integer and off.is_negative: result = [-S.One/(nnew + i) for i in range(0, off, -1)] + [harmonic(nnew)] return Add(*result) if n.is_Rational: # Expansions for harmonic numbers at general rational arguments (u + p/q) # Split n as u + p/q with p < q p, q = n.as_numer_denom() u = p // q p = p - u * q if u.is_nonnegative and p.is_positive and q.is_positive and p < q: k = Dummy("k") t1 = q * Sum(1 / (q * k + p), (k, 0, u)) t2 = 2 * Sum(cos((2 * pi * p * k) / S(q)) * log(sin((pi * k) / S(q))), (k, 1, floor((q - 1) / S(2)))) t3 = (pi / 2) * cot((pi * p) / q) + log(2 * q) return t1 + t2 - t3 return self
def test_trigsimp_old(): x, y = symbols('x,y') assert trigsimp(1 - sin(x)**2, old=True) == cos(x)**2 assert trigsimp(1 - cos(x)**2, old=True) == sin(x)**2 assert trigsimp(sin(x)**2 + cos(x)**2, old=True) == 1 assert trigsimp(1 + tan(x)**2, old=True) == 1 / cos(x)**2 assert trigsimp(1 / cos(x)**2 - 1, old=True) == tan(x)**2 assert trigsimp(1 / cos(x)**2 - tan(x)**2, old=True) == 1 assert trigsimp(1 + cot(x)**2, old=True) == 1 / sin(x)**2 assert trigsimp(1 / sin(x)**2 - cot(x)**2, old=True) == 1 assert trigsimp(5 * cos(x)**2 + 5 * sin(x)**2, old=True) == 5 assert trigsimp(sin(x) / cos(x), old=True) == tan(x) assert trigsimp(2 * tan(x) * cos(x), old=True) == 2 * sin(x) assert trigsimp(cot(x)**3 * sin(x)**3, old=True) == cos(x)**3 assert trigsimp(y * tan(x)**2 / sin(x)**2, old=True) == y / cos(x)**2 assert trigsimp(cot(x) / cos(x), old=True) == 1 / sin(x) assert trigsimp(sin(x + y) + sin(x - y), old=True) == 2 * sin(x) * cos(y) assert trigsimp(sin(x + y) - sin(x - y), old=True) == 2 * sin(y) * cos(x) assert trigsimp(cos(x + y) + cos(x - y), old=True) == 2 * cos(x) * cos(y) assert trigsimp(cos(x + y) - cos(x - y), old=True) == -2 * sin(x) * sin(y) assert trigsimp(sinh(x + y) + sinh(x - y), old=True) == 2 * sinh(x) * cosh(y) assert trigsimp(sinh(x + y) - sinh(x - y), old=True) == 2 * sinh(y) * cosh(x) assert trigsimp(cosh(x + y) + cosh(x - y), old=True) == 2 * cosh(x) * cosh(y) assert trigsimp(cosh(x + y) - cosh(x - y), old=True) == 2 * sinh(x) * sinh(y) assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2, old=True) == 1 assert trigsimp(sin(x) / cos(x), old=True, method='combined') == tan(x) assert trigsimp(sin(x) / cos(x), old=True, method='groebner') == sin(x) / cos(x) assert trigsimp(sin(x) / cos(x), old=True, method='groebner', hints=[tan]) == tan(x) assert trigsimp(1 - sin(sin(x)**2 + cos(x)**2)**2, old=True, deep=True) == cos(1)**2
def test_trigsimp_issues(): a, x, y = symbols('a x y') # issue 4625 - factor_terms works, too assert trigsimp(sin(x)**3 + cos(x)**2 * sin(x)) == sin(x) # issue 5948 assert trigsimp(diff(integrate(cos(x)/sin(x)**3, x), x)) == \ cos(x)/sin(x)**3 assert trigsimp(diff(integrate(sin(x)/cos(x)**3, x), x)) == \ sin(x)/cos(x)**3 # check integer exponents e = sin(x)**y / cos(x)**y assert trigsimp(e) == e assert trigsimp(e.subs(y, 2)) == tan(x)**2 assert trigsimp(e.subs(x, 1)) == tan(1)**y # check for multiple patterns assert (cos(x)**2/sin(x)**2*cos(y)**2/sin(y)**2).trigsimp() == \ 1/tan(x)**2/tan(y)**2 assert trigsimp(cos(x)/sin(x)*cos(x+y)/sin(x+y)) == \ 1/(tan(x)*tan(x + y)) eq = cos(2) * (cos(3) + 1)**2 / (cos(3) - 1)**2 assert trigsimp(eq) == eq.factor() # factor makes denom (-1 + cos(3))**2 assert trigsimp(cos(2)*(cos(3) + 1)**2*(cos(3) - 1)**2) == \ cos(2)*sin(3)**4 # issue 6789; this generates an expression that formerly caused # trigsimp to hang assert cot(x).equals(tan(x)) is False # nan or the unchanged expression is ok, but not sin(1) z = cos(x)**2 + sin(x)**2 - 1 z1 = tan(x)**2 - 1 / cot(x)**2 n = (1 + z1 / z) assert trigsimp(sin(n)) != sin(1) eq = x * (n - 1) - x * n assert trigsimp(eq) is S.NaN assert trigsimp(eq, recursive=True) is S.NaN assert trigsimp(1).is_Integer assert trigsimp(-sin(x)**4 - 2 * sin(x)**2 * cos(x)**2 - cos(x)**4) == -1
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
def _eval_expand_func(self, **hints): n, z = self.args if n.is_Integer and n.is_nonnegative: if z.is_Add: coeff = z.args[0] if coeff.is_Integer: e = -(n + 1) if coeff > 0: tail = Add(*[Pow(z - i, e) for i in range(1, int(coeff) + 1)]) else: tail = -Add(*[Pow(z + i, e) for i in range(0, int(-coeff))]) return polygamma(n, z - coeff) + (-1) ** n * factorial(n) * tail elif z.is_Mul: coeff, z = z.as_two_terms() if coeff.is_Integer and coeff.is_positive: tail = [ polygamma(n, z + Rational(i, coeff)) for i in range(0, int(coeff)) ] if n == 0: return Add(*tail) / coeff + log(coeff) else: return Add(*tail) / coeff ** (n + 1) z *= coeff if n == 0 and z.is_Rational: p, q = z.as_numer_denom() # Reference: # Values of the polygamma functions at rational arguments, J. Choi, 2007 part_1 = ( -S.EulerGamma - pi * cot(p * pi / q) / 2 - log(q) + Add( *[ cos(2 * k * pi * p / q) * log(2 * sin(k * pi / q)) for k in range(1, q) ] ) ) if z > 0: n = floor(z) z0 = z - n return part_1 + Add(*[1 / (z0 + k) for k in range(n)]) elif z < 0: n = floor(1 - z) z0 = z + n return part_1 - Add(*[1 / (z0 - 1 - k) for k in range(n)]) return polygamma(n, z)
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_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 f(rv): if not (isinstance(rv, Pow) and (rv.base.is_positive or rv.exp.is_integer and rv.exp.is_negative)): return rv if isinstance(rv.base, tan): return cot(rv.base.args[0])**-rv.exp elif isinstance(rv.base, sin): return csc(rv.base.args[0])**-rv.exp elif isinstance(rv.base, cos): return sec(rv.base.args[0])**-rv.exp return rv
def test_trigsimp_noncommutative(): x, y = symbols('x,y') 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_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_trigonometric(): n3 = Rational(3) e = (sin(x)**2).diff(x) assert e == 2 * sin(x) * cos(x) e = e.subs(x, n3) assert e == 2 * cos(n3) * sin(n3) e = (sin(x)**2).diff(x) assert e == 2 * sin(x) * cos(x) e = e.subs(sin(x), cos(x)) assert e == 2 * cos(x)**2 assert exp(pi).subs(exp, sin) == 0 assert cos(exp(pi)).subs(exp, sin) == 1 i = Symbol('i', integer=True) zoo = S.ComplexInfinity assert tan(x).subs(x, pi / 2) is zoo assert cot(x).subs(x, pi) is zoo assert cot(i * x).subs(x, pi) is zoo assert tan(i * x).subs(x, pi / 2) == tan(i * pi / 2) assert tan(i * x).subs(x, pi / 2).subs(i, 1) is zoo o = Symbol('o', odd=True) assert tan(o * x).subs(x, pi / 2) == tan(o * pi / 2)
def _eval_expand_func(self, **hints): n, z = self.args if n.is_Integer and n.is_nonnegative: if z.is_Add: coeff = z.args[0] if coeff.is_Integer: e = -(n + 1) if coeff > 0: tail = Add(*[Pow( z - i, e) for i in range(1, int(coeff) + 1)]) else: tail = -Add(*[Pow( z + i, e) for i in range(0, int(-coeff))]) return polygamma(n, z - coeff) + (-1)**n*factorial(n)*tail elif z.is_Mul: coeff, z = z.as_two_terms() if coeff.is_Integer and coeff.is_positive: tail = [ polygamma(n, z + Rational( i, coeff)) for i in range(0, int(coeff)) ] if n == 0: return Add(*tail)/coeff + log(coeff) else: return Add(*tail)/coeff**(n + 1) z *= coeff if n == 0 and z.is_Rational: p, q = z.as_numer_denom() # Reference: # Values of the polygamma functions at rational arguments, J. Choi, 2007 part_1 = -S.EulerGamma - pi * cot(p * pi / q) / 2 - log(q) + Add( *[cos(2 * k * pi * p / q) * log(2 * sin(k * pi / q)) for k in range(1, q)]) if z > 0: n = floor(z) z0 = z - n return part_1 + Add(*[1 / (z0 + k) for k in range(n)]) elif z < 0: n = floor(1 - z) z0 = z + n return part_1 - Add(*[1 / (z0 - 1 - k) for k in range(n)]) return polygamma(n, z)
def fdiff(self, argindex=4): if argindex == 1: # Diff wrt n raise ArgumentIndexError(self, argindex) elif argindex == 2: # Diff wrt m raise ArgumentIndexError(self, argindex) elif argindex == 3: # Diff wrt theta n, m, theta, phi = self.args return (m * cot(theta) * Ynm(n, m, theta, phi) + sqrt((n - m)*(n + m + 1)) * exp(-I*phi) * Ynm(n, m + 1, theta, phi)) elif argindex == 4: # Diff wrt phi n, m, theta, phi = self.args return I * m * Ynm(n, m, theta, phi) else: raise ArgumentIndexError(self, argindex)
def test_diff3(): p = Rational(5) e = a*b + sin(b**p) assert e == a*b + sin(b**5) assert e.diff(a) == b assert e.diff(b) == a + 5*b**4*cos(b**5) e = tan(c) assert e == tan(c) assert e.diff(c) in [cos(c)**(-2), 1 + sin(c)**2/cos(c)**2, 1 + tan(c)**2] e = c*log(c) - c assert e == -c + c*log(c) assert e.diff(c) == log(c) e = log(sin(c)) assert e == log(sin(c)) assert e.diff(c) in [sin(c)**(-1)*cos(c), cot(c)] e = (Rational(2)**a/log(Rational(2))) assert e == 2**a*log(Rational(2))**(-1) assert e.diff(a) == 2**a
def f(rv): if not isinstance(rv, HyperbolicFunction): return rv a = rv.args[0] a = a * d if not a.is_Add else Add._from_args([i * d for i in a.args]) if isinstance(rv, sinh): return I * sin(a) elif isinstance(rv, cosh): return cos(a) elif isinstance(rv, tanh): return I * tan(a) elif isinstance(rv, coth): return cot(a) / I elif isinstance(rv, sech): return sec(a) elif isinstance(rv, csch): return csc(a) / I else: raise NotImplementedError('unhandled %s' % rv.func)
def test_Ynm(): # https://en.wikipedia.org/wiki/Spherical_harmonics th, ph = Symbol("theta", real=True), Symbol("phi", real=True) from sympy.abc import n, m assert Ynm(0, 0, th, ph).expand(func=True) == 1 / (2 * sqrt(pi)) assert Ynm(1, -1, th, ph) == -exp(-2 * I * ph) * Ynm(1, 1, th, ph) assert Ynm(1, -1, th, ph).expand( func=True) == sqrt(6) * sin(th) * exp(-I * ph) / (4 * sqrt(pi)) assert Ynm(1, 0, th, ph).expand(func=True) == sqrt(3) * cos(th) / (2 * sqrt(pi)) assert Ynm(1, 1, th, ph).expand( func=True) == -sqrt(6) * sin(th) * exp(I * ph) / (4 * sqrt(pi)) assert Ynm(2, 0, th, ph).expand( func=True ) == 3 * sqrt(5) * cos(th)**2 / (4 * sqrt(pi)) - sqrt(5) / (4 * sqrt(pi)) assert Ynm(2, 1, th, ph).expand(func=True) == -sqrt(30) * sin(th) * exp( I * ph) * cos(th) / (4 * sqrt(pi)) assert Ynm( 2, -2, th, ph).expand(func=True) == (-sqrt(30) * exp(-2 * I * ph) * cos(th)**2 / (8 * sqrt(pi)) + sqrt(30) * exp(-2 * I * ph) / (8 * sqrt(pi))) assert Ynm( 2, 2, th, ph).expand(func=True) == (-sqrt(30) * exp(2 * I * ph) * cos(th)**2 / (8 * sqrt(pi)) + sqrt(30) * exp(2 * I * ph) / (8 * sqrt(pi))) assert diff(Ynm( n, m, th, ph), th) == (m * cot(th) * Ynm(n, m, th, ph) + sqrt( (-m + n) * (m + n + 1)) * exp(-I * ph) * Ynm(n, m + 1, th, ph)) assert diff(Ynm(n, m, th, ph), ph) == I * m * Ynm(n, m, th, ph) assert conjugate( Ynm(n, m, th, ph)) == (-1)**(2 * m) * exp(-2 * I * m * ph) * Ynm(n, m, th, ph) assert Ynm(n, m, -th, ph) == Ynm(n, m, th, ph) assert Ynm(n, m, th, -ph) == exp(-2 * I * m * ph) * Ynm(n, m, th, ph) assert Ynm(n, -m, th, ph) == (-1)**m * exp(-2 * I * m * ph) * Ynm(n, m, th, ph)
def test_TR15_16_17(): assert TR15(1 - 1 / sin(x)**2) == -cot(x)**2 assert TR16(1 - 1 / cos(x)**2) == -tan(x)**2 assert TR111(1 - 1 / tan(x)**2) == 1 - cot(x)**2
def test_TR2(): assert TR2(tan(x)) == sin(x) / cos(x) assert TR2(cot(x)) == cos(x) / sin(x) assert TR2(tan(tan(x) - sin(x) / cos(x))) == 0
def test_issue_21176(): f = x**2*cot(pi*x)/(x**4 + 1) assert residue(f, x, -sqrt(2)/2 - sqrt(2)*I/2).cancel().together(deep=True)\ == sqrt(2)*(1 - I)/(8*tan(sqrt(2)*pi*(1 + I)/2))
def test_sympy__functions__elementary__trigonometric__cot(): from sympy.functions.elementary.trigonometric import cot assert _test_args(cot(2))
def _eval_rewrite_as_bessely(self, nu, z, **kwargs): if nu.is_integer == False: return csc(pi * nu) * bessely(-nu, z) - cot(pi * nu) * bessely( nu, z)
def _eval_rewrite_as_bessely(self, nu, z): if nu.is_integer is False: return csc(pi * nu) * bessely(-nu, z) - cot(pi * nu) * bessely(nu, z)