Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/19.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65325841ace746095a42cb0973ae0886fbdf232b11b0430dcaf6f4253e024b75
+size 33555612

ckpts/universal/global_step80/zero/19.mlp.dense_h_to_4h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b47a1ddf85d80386dfa5be84824e9cdfd04a71431ff8e9e92648b269590005dd
+size 33555627

ckpts/universal/global_step80/zero/19.mlp.dense_h_to_4h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:723945f54943cf3bfdaa9d28eac61b9d93d852a8ada701cba480b944a03edf0c
+size 33555533

ckpts/universal/global_step80/zero/20.attention.query_key_value.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c271831d89c4e9a0919352e8eebc2f9a08f79494c64bc5270ebb78afaf6d2e8c
+size 50332843

ckpts/universal/global_step80/zero/20.attention.query_key_value.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3738898faac1afab19d8c6bbe4ef7585910bd9cf1bf8dce7d925d7e26e7ac25f
+size 50332749

venv/lib/python3.10/site-packages/sympy/functions/__init__.py

@@ -0,0 +1,111 @@
+"""A functions module, includes all the standard functions.
+
+Combinatorial - factorial, fibonacci, harmonic, bernoulli...
+Elementary - hyperbolic, trigonometric, exponential, floor and ceiling, sqrt...
+Special - gamma, zeta,spherical harmonics...
+"""
+
+from sympy.functions.combinatorial.factorials import (factorial, factorial2,
+        rf, ff, binomial, RisingFactorial, FallingFactorial, subfactorial)
+from sympy.functions.combinatorial.numbers import (carmichael, fibonacci, lucas, tribonacci,
+        harmonic, bernoulli, bell, euler, catalan, genocchi, andre, partition, motzkin)
+from sympy.functions.elementary.miscellaneous import (sqrt, root, Min, Max,
+        Id, real_root, cbrt, Rem)
+from sympy.functions.elementary.complexes import (re, im, sign, Abs,
+        conjugate, arg, polar_lift, periodic_argument, unbranched_argument,
+        principal_branch, transpose, adjoint, polarify, unpolarify)
+from sympy.functions.elementary.trigonometric import (sin, cos, tan,
+        sec, csc, cot, sinc, asin, acos, atan, asec, acsc, acot, atan2)
+from sympy.functions.elementary.exponential import (exp_polar, exp, log,
+        LambertW)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+        sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.functions.elementary.integers import floor, ceiling, frac
+from sympy.functions.elementary.piecewise import (Piecewise, piecewise_fold,
+                                                  piecewise_exclusive)
+from sympy.functions.special.error_functions import (erf, erfc, erfi, erf2,
+        erfinv, erfcinv, erf2inv, Ei, expint, E1, li, Li, Si, Ci, Shi, Chi,
+        fresnels, fresnelc)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma,
+        uppergamma, polygamma, loggamma, digamma, trigamma, multigamma)
+from sympy.functions.special.zeta_functions import (dirichlet_eta, zeta,
+        lerchphi, polylog, stieltjes, riemann_xi)
+from sympy.functions.special.tensor_functions import (Eijk, LeviCivita,
+        KroneckerDelta)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.functions.special.delta_functions import DiracDelta, Heaviside
+from sympy.functions.special.bsplines import bspline_basis, bspline_basis_set, interpolating_spline
+from sympy.functions.special.bessel import (besselj, bessely, besseli, besselk,
+        hankel1, hankel2, jn, yn, jn_zeros, hn1, hn2, airyai, airybi, airyaiprime, airybiprime, marcumq)
+from sympy.functions.special.hyper import hyper, meijerg, appellf1
+from sympy.functions.special.polynomials import (legendre, assoc_legendre,
+        hermite, hermite_prob, chebyshevt, chebyshevu, chebyshevu_root,
+        chebyshevt_root, laguerre, assoc_laguerre, gegenbauer, jacobi, jacobi_normalized)
+from sympy.functions.special.spherical_harmonics import Ynm, Ynm_c, Znm
+from sympy.functions.special.elliptic_integrals import (elliptic_k,
+        elliptic_f, elliptic_e, elliptic_pi)
+from sympy.functions.special.beta_functions import beta, betainc, betainc_regularized
+from sympy.functions.special.mathieu_functions import (mathieus, mathieuc,
+        mathieusprime, mathieucprime)
+ln = log
+
+__all__ = [
+    'factorial', 'factorial2', 'rf', 'ff', 'binomial', 'RisingFactorial',
+    'FallingFactorial', 'subfactorial',
+
+    'carmichael', 'fibonacci', 'lucas', 'motzkin', 'tribonacci', 'harmonic',
+    'bernoulli', 'bell', 'euler', 'catalan', 'genocchi', 'andre', 'partition',
+
+    'sqrt', 'root', 'Min', 'Max', 'Id', 'real_root', 'cbrt', 'Rem',
+
+    're', 'im', 'sign', 'Abs', 'conjugate', 'arg', 'polar_lift',
+    'periodic_argument', 'unbranched_argument', 'principal_branch',
+    'transpose', 'adjoint', 'polarify', 'unpolarify',
+
+    'sin', 'cos', 'tan', 'sec', 'csc', 'cot', 'sinc', 'asin', 'acos', 'atan',
+    'asec', 'acsc', 'acot', 'atan2',
+
+    'exp_polar', 'exp', 'ln', 'log', 'LambertW',
+
+    'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch', 'asinh', 'acosh', 'atanh',
+    'acoth', 'asech', 'acsch',
+
+    'floor', 'ceiling', 'frac',
+
+    'Piecewise', 'piecewise_fold', 'piecewise_exclusive',
+
+    'erf', 'erfc', 'erfi', 'erf2', 'erfinv', 'erfcinv', 'erf2inv', 'Ei',
+    'expint', 'E1', 'li', 'Li', 'Si', 'Ci', 'Shi', 'Chi', 'fresnels',
+    'fresnelc',
+
+    'gamma', 'lowergamma', 'uppergamma', 'polygamma', 'loggamma', 'digamma',
+    'trigamma', 'multigamma',
+
+    'dirichlet_eta', 'zeta', 'lerchphi', 'polylog', 'stieltjes', 'riemann_xi',
+
+    'Eijk', 'LeviCivita', 'KroneckerDelta',
+
+    'SingularityFunction',
+
+    'DiracDelta', 'Heaviside',
+
+    'bspline_basis', 'bspline_basis_set', 'interpolating_spline',
+
+    'besselj', 'bessely', 'besseli', 'besselk', 'hankel1', 'hankel2', 'jn',
+    'yn', 'jn_zeros', 'hn1', 'hn2', 'airyai', 'airybi', 'airyaiprime',
+    'airybiprime', 'marcumq',
+
+    'hyper', 'meijerg', 'appellf1',
+
+    'legendre', 'assoc_legendre', 'hermite', 'hermite_prob', 'chebyshevt',
+    'chebyshevu', 'chebyshevu_root', 'chebyshevt_root', 'laguerre',
+    'assoc_laguerre', 'gegenbauer', 'jacobi', 'jacobi_normalized',
+
+    'Ynm', 'Ynm_c', 'Znm',
+
+    'elliptic_k', 'elliptic_f', 'elliptic_e', 'elliptic_pi',
+
+    'beta', 'betainc', 'betainc_regularized',
+
+    'mathieus', 'mathieuc', 'mathieusprime', 'mathieucprime',
+]

venv/lib/python3.10/site-packages/sympy/functions/combinatorial/__init__.py

@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.combinatorial

venv/lib/python3.10/site-packages/sympy/functions/combinatorial/factorials.py

@@ -0,0 +1,1102 @@
+from __future__ import annotations
+from functools import reduce
+
+from sympy.core import S, sympify, Dummy, Mod
+from sympy.core.cache import cacheit
+from sympy.core.function import Function, ArgumentIndexError, PoleError
+from sympy.core.logic import fuzzy_and
+from sympy.core.numbers import Integer, pi, I
+from sympy.core.relational import Eq
+from sympy.external.gmpy import HAS_GMPY, gmpy
+from sympy.ntheory import sieve
+from sympy.polys.polytools import Poly
+
+from math import factorial as _factorial, prod, sqrt as _sqrt
+
+class CombinatorialFunction(Function):
+    """Base class for combinatorial functions. """
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.combsimp import combsimp
+        # combinatorial function with non-integer arguments is
+        # automatically passed to gammasimp
+        expr = combsimp(self)
+        measure = kwargs['measure']
+        if measure(expr) <= kwargs['ratio']*measure(self):
+            return expr
+        return self
+
+
+###############################################################################
+######################## FACTORIAL and MULTI-FACTORIAL ########################
+###############################################################################
+
+
+class factorial(CombinatorialFunction):
+    r"""Implementation of factorial function over nonnegative integers.
+       By convention (consistent with the gamma function and the binomial
+       coefficients), factorial of a negative integer is complex infinity.
+
+       The factorial is very important in combinatorics where it gives
+       the number of ways in which `n` objects can be permuted. It also
+       arises in calculus, probability, number theory, etc.
+
+       There is strict relation of factorial with gamma function. In
+       fact `n! = gamma(n+1)` for nonnegative integers. Rewrite of this
+       kind is very useful in case of combinatorial simplification.
+
+       Computation of the factorial is done using two algorithms. For
+       small arguments a precomputed look up table is used. However for bigger
+       input algorithm Prime-Swing is used. It is the fastest algorithm
+       known and computes `n!` via prime factorization of special class
+       of numbers, called here the 'Swing Numbers'.
+
+       Examples
+       ========
+
+       >>> from sympy import Symbol, factorial, S
+       >>> n = Symbol('n', integer=True)
+
+       >>> factorial(0)
+       1
+
+       >>> factorial(7)
+       5040
+
+       >>> factorial(-2)
+       zoo
+
+       >>> factorial(n)
+       factorial(n)
+
+       >>> factorial(2*n)
+       factorial(2*n)
+
+       >>> factorial(S(1)/2)
+       factorial(1/2)
+
+       See Also
+       ========
+
+       factorial2, RisingFactorial, FallingFactorial
+    """
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.gamma_functions import (gamma, polygamma)
+        if argindex == 1:
+            return gamma(self.args[0] + 1)*polygamma(0, self.args[0] + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    _small_swing = [
+        1, 1, 1, 3, 3, 15, 5, 35, 35, 315, 63, 693, 231, 3003, 429, 6435, 6435, 109395,
+        12155, 230945, 46189, 969969, 88179, 2028117, 676039, 16900975, 1300075,
+        35102025, 5014575, 145422675, 9694845, 300540195, 300540195
+    ]
+
+    _small_factorials: list[int] = []
+
+    @classmethod
+    def _swing(cls, n):
+        if n < 33:
+            return cls._small_swing[n]
+        else:
+            N, primes = int(_sqrt(n)), []
+
+            for prime in sieve.primerange(3, N + 1):
+                p, q = 1, n
+
+                while True:
+                    q //= prime
+
+                    if q > 0:
+                        if q & 1 == 1:
+                            p *= prime
+                    else:
+                        break
+
+                if p > 1:
+                    primes.append(p)
+
+            for prime in sieve.primerange(N + 1, n//3 + 1):
+                if (n // prime) & 1 == 1:
+                    primes.append(prime)
+
+            L_product = prod(sieve.primerange(n//2 + 1, n + 1))
+            R_product = prod(primes)
+
+            return L_product*R_product
+
+    @classmethod
+    def _recursive(cls, n):
+        if n < 2:
+            return 1
+        else:
+            return (cls._recursive(n//2)**2)*cls._swing(n)
+
+    @classmethod
+    def eval(cls, n):
+        n = sympify(n)
+
+        if n.is_Number:
+            if n.is_zero:
+                return S.One
+            elif n is S.Infinity:
+                return S.Infinity
+            elif n.is_Integer:
+                if n.is_negative:
+                    return S.ComplexInfinity
+                else:
+                    n = n.p
+
+                    if n < 20:
+                        if not cls._small_factorials:
+                            result = 1
+                            for i in range(1, 20):
+                                result *= i
+                                cls._small_factorials.append(result)
+                        result = cls._small_factorials[n-1]
+
+                    # GMPY factorial is faster, use it when available
+                    elif HAS_GMPY:
+                        result = gmpy.fac(n)
+
+                    else:
+                        bits = bin(n).count('1')
+                        result = cls._recursive(n)*2**(n - bits)
+
+                    return Integer(result)
+
+    def _facmod(self, n, q):
+        res, N = 1, int(_sqrt(n))
+
+        # Exponent of prime p in n! is e_p(n) = [n/p] + [n/p**2] + ...
+        # for p > sqrt(n), e_p(n) < sqrt(n), the primes with [n/p] = m,
+        # occur consecutively and are grouped together in pw[m] for
+        # simultaneous exponentiation at a later stage
+        pw = [1]*N
+
+        m = 2 # to initialize the if condition below
+        for prime in sieve.primerange(2, n + 1):
+            if m > 1:
+                m, y = 0, n // prime
+                while y:
+                    m += y
+                    y //= prime
+            if m < N:
+                pw[m] = pw[m]*prime % q
+            else:
+                res = res*pow(prime, m, q) % q
+
+        for ex, bs in enumerate(pw):
+            if ex == 0 or bs == 1:
+                continue
+            if bs == 0:
+                return 0
+            res = res*pow(bs, ex, q) % q
+
+        return res
+
+    def _eval_Mod(self, q):
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative and q.is_integer:
+            aq = abs(q)
+            d = aq - n
+            if d.is_nonpositive:
+                return S.Zero
+            else:
+                isprime = aq.is_prime
+                if d == 1:
+                    # Apply Wilson's theorem (if a natural number n > 1
+                    # is a prime number, then (n-1)! = -1 mod n) and
+                    # its inverse (if n > 4 is a composite number, then
+                    # (n-1)! = 0 mod n)
+                    if isprime:
+                        return -1 % q
+                    elif isprime is False and (aq - 6).is_nonnegative:
+                        return S.Zero
+                elif n.is_Integer and q.is_Integer:
+                    n, d, aq = map(int, (n, d, aq))
+                    if isprime and (d - 1 < n):
+                        fc = self._facmod(d - 1, aq)
+                        fc = pow(fc, aq - 2, aq)
+                        if d%2:
+                            fc = -fc
+                    else:
+                        fc = self._facmod(n, aq)
+
+                    return fc % q
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return gamma(n + 1)
+
+    def _eval_rewrite_as_Product(self, n, **kwargs):
+        from sympy.concrete.products import Product
+        if n.is_nonnegative and n.is_integer:
+            i = Dummy('i', integer=True)
+            return Product(i, (i, 1, n))
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_even(self):
+        x = self.args[0]
+        if x.is_integer and x.is_nonnegative:
+            return (x - 2).is_nonnegative
+
+    def _eval_is_composite(self):
+        x = self.args[0]
+        if x.is_integer and x.is_nonnegative:
+            return (x - 3).is_nonnegative
+
+    def _eval_is_real(self):
+        x = self.args[0]
+        if x.is_nonnegative or x.is_noninteger:
+            return True
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        arg = self.args[0].as_leading_term(x)
+        arg0 = arg.subs(x, 0)
+        if arg0.is_zero:
+            return S.One
+        elif not arg0.is_infinite:
+            return self.func(arg)
+        raise PoleError("Cannot expand %s around 0" % (self))
+
+class MultiFactorial(CombinatorialFunction):
+    pass
+
+
+class subfactorial(CombinatorialFunction):
+    r"""The subfactorial counts the derangements of $n$ items and is
+    defined for non-negative integers as:
+
+    .. math:: !n = \begin{cases} 1 & n = 0 \\ 0 & n = 1 \\
+                    (n-1)(!(n-1) + !(n-2)) & n > 1 \end{cases}
+
+    It can also be written as ``int(round(n!/exp(1)))`` but the
+    recursive definition with caching is implemented for this function.
+
+    An interesting analytic expression is the following [2]_
+
+    .. math:: !x = \Gamma(x + 1, -1)/e
+
+    which is valid for non-negative integers `x`. The above formula
+    is not very useful in case of non-integers. `\Gamma(x + 1, -1)` is
+    single-valued only for integral arguments `x`, elsewhere on the positive
+    real axis it has an infinite number of branches none of which are real.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Subfactorial
+    .. [2] https://mathworld.wolfram.com/Subfactorial.html
+
+    Examples
+    ========
+
+    >>> from sympy import subfactorial
+    >>> from sympy.abc import n
+    >>> subfactorial(n + 1)
+    subfactorial(n + 1)
+    >>> subfactorial(5)
+    44
+
+    See Also
+    ========
+
+    factorial, uppergamma,
+    sympy.utilities.iterables.generate_derangements
+    """
+
+    @classmethod
+    @cacheit
+    def _eval(self, n):
+        if not n:
+            return S.One
+        elif n == 1:
+            return S.Zero
+        else:
+            z1, z2 = 1, 0
+            for i in range(2, n + 1):
+                z1, z2 = z2, (i - 1)*(z2 + z1)
+            return z2
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg.is_Integer and arg.is_nonnegative:
+                return cls._eval(arg)
+            elif arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+
+    def _eval_is_even(self):
+        if self.args[0].is_odd and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_rewrite_as_factorial(self, arg, **kwargs):
+        from sympy.concrete.summations import summation
+        i = Dummy('i')
+        f = S.NegativeOne**i / factorial(i)
+        return factorial(arg) * summation(f, (i, 0, arg))
+
+    def _eval_rewrite_as_gamma(self, arg, piecewise=True, **kwargs):
+        from sympy.functions.elementary.exponential import exp
+        from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+        return (S.NegativeOne**(arg + 1)*exp(-I*pi*arg)*lowergamma(arg + 1, -1)
+                + gamma(arg + 1))*exp(-1)
+
+    def _eval_rewrite_as_uppergamma(self, arg, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return uppergamma(arg + 1, -1)/S.Exp1
+
+    def _eval_is_nonnegative(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_odd(self):
+        if self.args[0].is_even and self.args[0].is_nonnegative:
+            return True
+
+
+class factorial2(CombinatorialFunction):
+    r"""The double factorial `n!!`, not to be confused with `(n!)!`
+
+    The double factorial is defined for nonnegative integers and for odd
+    negative integers as:
+
+    .. math:: n!! = \begin{cases} 1 & n = 0 \\
+                    n(n-2)(n-4) \cdots 1 & n\ \text{positive odd} \\
+                    n(n-2)(n-4) \cdots 2 & n\ \text{positive even} \\
+                    (n+2)!!/(n+2) & n\ \text{negative odd} \end{cases}
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Double_factorial
+
+    Examples
+    ========
+
+    >>> from sympy import factorial2, var
+    >>> n = var('n')
+    >>> n
+    n
+    >>> factorial2(n + 1)
+    factorial2(n + 1)
+    >>> factorial2(5)
+    15
+    >>> factorial2(-1)
+    1
+    >>> factorial2(-5)
+    1/3
+
+    See Also
+    ========
+
+    factorial, RisingFactorial, FallingFactorial
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        # TODO: extend this to complex numbers?
+
+        if arg.is_Number:
+            if not arg.is_Integer:
+                raise ValueError("argument must be nonnegative integer "
+                                    "or negative odd integer")
+
+            # This implementation is faster than the recursive one
+            # It also avoids "maximum recursion depth exceeded" runtime error
+            if arg.is_nonnegative:
+                if arg.is_even:
+                    k = arg / 2
+                    return 2**k * factorial(k)
+                return factorial(arg) / factorial2(arg - 1)
+
+
+            if arg.is_odd:
+                return arg*(S.NegativeOne)**((1 - arg)/2) / factorial2(-arg)
+            raise ValueError("argument must be nonnegative integer "
+                                "or negative odd integer")
+
+
+    def _eval_is_even(self):
+        # Double factorial is even for every positive even input
+        n = self.args[0]
+        if n.is_integer:
+            if n.is_odd:
+                return False
+            if n.is_even:
+                if n.is_positive:
+                    return True
+                if n.is_zero:
+                    return False
+
+    def _eval_is_integer(self):
+        # Double factorial is an integer for every nonnegative input, and for
+        # -1 and -3
+        n = self.args[0]
+        if n.is_integer:
+            if (n + 1).is_nonnegative:
+                return True
+            if n.is_odd:
+                return (n + 3).is_nonnegative
+
+    def _eval_is_odd(self):
+        # Double factorial is odd for every odd input not smaller than -3, and
+        # for 0
+        n = self.args[0]
+        if n.is_odd:
+            return (n + 3).is_nonnegative
+        if n.is_even:
+            if n.is_positive:
+                return False
+            if n.is_zero:
+                return True
+
+    def _eval_is_positive(self):
+        # Double factorial is positive for every nonnegative input, and for
+        # every odd negative input which is of the form -1-4k for an
+        # nonnegative integer k
+        n = self.args[0]
+        if n.is_integer:
+            if (n + 1).is_nonnegative:
+                return True
+            if n.is_odd:
+                return ((n + 1) / 2).is_even
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.elementary.miscellaneous import sqrt
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        return 2**(n/2)*gamma(n/2 + 1) * Piecewise((1, Eq(Mod(n, 2), 0)),
+                (sqrt(2/pi), Eq(Mod(n, 2), 1)))
+
+
+###############################################################################
+######################## RISING and FALLING FACTORIALS ########################
+###############################################################################
+
+
+class RisingFactorial(CombinatorialFunction):
+    r"""
+    Rising factorial (also called Pochhammer symbol [1]_) is a double valued
+    function arising in concrete mathematics, hypergeometric functions
+    and series expansions. It is defined by:
+
+    .. math:: \texttt{rf(y, k)} = (x)^k = x \cdot (x+1) \cdots (x+k-1)
+
+    where `x` can be arbitrary expression and `k` is an integer. For
+    more information check "Concrete mathematics" by Graham, pp. 66
+    or visit https://mathworld.wolfram.com/RisingFactorial.html page.
+
+    When `x` is a `~.Poly` instance of degree $\ge 1$ with a single variable,
+    `(x)^k = x(y) \cdot x(y+1) \cdots x(y+k-1)`, where `y` is the
+    variable of `x`. This is as described in [2]_.
+
+    Examples
+    ========
+
+    >>> from sympy import rf, Poly
+    >>> from sympy.abc import x
+    >>> rf(x, 0)
+    1
+    >>> rf(1, 5)
+    120
+    >>> rf(x, 5) == x*(1 + x)*(2 + x)*(3 + x)*(4 + x)
+    True
+    >>> rf(Poly(x**3, x), 2)
+    Poly(x**6 + 3*x**5 + 3*x**4 + x**3, x, domain='ZZ')
+
+    Rewriting is complicated unless the relationship between
+    the arguments is known, but rising factorial can
+    be rewritten in terms of gamma, factorial, binomial,
+    and falling factorial.
+
+    >>> from sympy import Symbol, factorial, ff, binomial, gamma
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> R = rf(n, n + 2)
+    >>> for i in (rf, ff, factorial, binomial, gamma):
+    ...  R.rewrite(i)
+    ...
+    RisingFactorial(n, n + 2)
+    FallingFactorial(2*n + 1, n + 2)
+    factorial(2*n + 1)/factorial(n - 1)
+    binomial(2*n + 1, n + 2)*factorial(n + 2)
+    gamma(2*n + 2)/gamma(n)
+
+    See Also
+    ========
+
+    factorial, factorial2, FallingFactorial
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Pochhammer_symbol
+    .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic
+           Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268,
+           1995.
+
+    """
+
+    @classmethod
+    def eval(cls, x, k):
+        x = sympify(x)
+        k = sympify(k)
+
+        if x is S.NaN or k is S.NaN:
+            return S.NaN
+        elif x is S.One:
+            return factorial(k)
+        elif k.is_Integer:
+            if k.is_zero:
+                return S.One
+            else:
+                if k.is_positive:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        if k.is_odd:
+                            return S.NegativeInfinity
+                        else:
+                            return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return reduce(lambda r, i:
+                                              r*(x.shift(i)),
+                                              range(int(k)), 1)
+                        else:
+                            return reduce(lambda r, i: r*(x + i),
+                                          range(int(k)), 1)
+
+                else:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return 1/reduce(lambda r, i:
+                                                r*(x.shift(-i)),
+                                                range(1, abs(int(k)) + 1), 1)
+                        else:
+                            return 1/reduce(lambda r, i:
+                                            r*(x - i),
+                                            range(1, abs(int(k)) + 1), 1)
+
+        if k.is_integer == False:
+            if x.is_integer and x.is_negative:
+                return S.Zero
+
+    def _eval_rewrite_as_gamma(self, x, k, piecewise=True, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        if not piecewise:
+            if (x <= 0) == True:
+                return S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1)
+            return gamma(x + k) / gamma(x)
+        return Piecewise(
+            (gamma(x + k) / gamma(x), x > 0),
+            (S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1), True))
+
+    def _eval_rewrite_as_FallingFactorial(self, x, k, **kwargs):
+        return FallingFactorial(x + k - 1, k)
+
+    def _eval_rewrite_as_factorial(self, x, k, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        if x.is_integer and k.is_integer:
+            return Piecewise(
+                (factorial(k + x - 1)/factorial(x - 1), x > 0),
+                (S.NegativeOne**k*factorial(-x)/factorial(-k - x), True))
+
+    def _eval_rewrite_as_binomial(self, x, k, **kwargs):
+        if k.is_integer:
+            return factorial(k) * binomial(x + k - 1, k)
+
+    def _eval_rewrite_as_tractable(self, x, k, limitvar=None, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        if limitvar:
+            k_lim = k.subs(limitvar, S.Infinity)
+            if k_lim is S.Infinity:
+                return (gamma(x + k).rewrite('tractable', deep=True) / gamma(x))
+            elif k_lim is S.NegativeInfinity:
+                return (S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1).rewrite('tractable', deep=True))
+        return self.rewrite(gamma).rewrite('tractable', deep=True)
+
+    def _eval_is_integer(self):
+        return fuzzy_and((self.args[0].is_integer, self.args[1].is_integer,
+                          self.args[1].is_nonnegative))
+
+
+class FallingFactorial(CombinatorialFunction):
+    r"""
+    Falling factorial (related to rising factorial) is a double valued
+    function arising in concrete mathematics, hypergeometric functions
+    and series expansions. It is defined by
+
+    .. math:: \texttt{ff(x, k)} = (x)_k = x \cdot (x-1) \cdots (x-k+1)
+
+    where `x` can be arbitrary expression and `k` is an integer. For
+    more information check "Concrete mathematics" by Graham, pp. 66
+    or [1]_.
+
+    When `x` is a `~.Poly` instance of degree $\ge 1$ with single variable,
+    `(x)_k = x(y) \cdot x(y-1) \cdots x(y-k+1)`, where `y` is the
+    variable of `x`. This is as described in
+
+    >>> from sympy import ff, Poly, Symbol
+    >>> from sympy.abc import x
+    >>> n = Symbol('n', integer=True)
+
+    >>> ff(x, 0)
+    1
+    >>> ff(5, 5)
+    120
+    >>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
+    True
+    >>> ff(Poly(x**2, x), 2)
+    Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ')
+    >>> ff(n, n)
+    factorial(n)
+
+    Rewriting is complicated unless the relationship between
+    the arguments is known, but falling factorial can
+    be rewritten in terms of gamma, factorial and binomial
+    and rising factorial.
+
+    >>> from sympy import factorial, rf, gamma, binomial, Symbol
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> F = ff(n, n - 2)
+    >>> for i in (rf, ff, factorial, binomial, gamma):
+    ...  F.rewrite(i)
+    ...
+    RisingFactorial(3, n - 2)
+    FallingFactorial(n, n - 2)
+    factorial(n)/2
+    binomial(n, n - 2)*factorial(n - 2)
+    gamma(n + 1)/2
+
+    See Also
+    ========
+
+    factorial, factorial2, RisingFactorial
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/FallingFactorial.html
+    .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic
+           Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268,
+           1995.
+
+    """
+
+    @classmethod
+    def eval(cls, x, k):
+        x = sympify(x)
+        k = sympify(k)
+
+        if x is S.NaN or k is S.NaN:
+            return S.NaN
+        elif k.is_integer and x == k:
+            return factorial(x)
+        elif k.is_Integer:
+            if k.is_zero:
+                return S.One
+            else:
+                if k.is_positive:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        if k.is_odd:
+                            return S.NegativeInfinity
+                        else:
+                            return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("ff only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return reduce(lambda r, i:
+                                              r*(x.shift(-i)),
+                                              range(int(k)), 1)
+                        else:
+                            return reduce(lambda r, i: r*(x - i),
+                                          range(int(k)), 1)
+                else:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return 1/reduce(lambda r, i:
+                                                r*(x.shift(i)),
+                                                range(1, abs(int(k)) + 1), 1)
+                        else:
+                            return 1/reduce(lambda r, i: r*(x + i),
+                                            range(1, abs(int(k)) + 1), 1)
+
+    def _eval_rewrite_as_gamma(self, x, k, piecewise=True, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        if not piecewise:
+            if (x < 0) == True:
+                return S.NegativeOne**k*gamma(k - x) / gamma(-x)
+            return gamma(x + 1) / gamma(x - k + 1)
+        return Piecewise(
+            (gamma(x + 1) / gamma(x - k + 1), x >= 0),
+            (S.NegativeOne**k*gamma(k - x) / gamma(-x), True))
+
+    def _eval_rewrite_as_RisingFactorial(self, x, k, **kwargs):
+        return rf(x - k + 1, k)
+
+    def _eval_rewrite_as_binomial(self, x, k, **kwargs):
+        if k.is_integer:
+            return factorial(k) * binomial(x, k)
+
+    def _eval_rewrite_as_factorial(self, x, k, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        if x.is_integer and k.is_integer:
+            return Piecewise(
+                (factorial(x)/factorial(-k + x), x >= 0),
+                (S.NegativeOne**k*factorial(k - x - 1)/factorial(-x - 1), True))
+
+    def _eval_rewrite_as_tractable(self, x, k, limitvar=None, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        if limitvar:
+            k_lim = k.subs(limitvar, S.Infinity)
+            if k_lim is S.Infinity:
+                return (S.NegativeOne**k*gamma(k - x).rewrite('tractable', deep=True) / gamma(-x))
+            elif k_lim is S.NegativeInfinity:
+                return (gamma(x + 1) / gamma(x - k + 1).rewrite('tractable', deep=True))
+        return self.rewrite(gamma).rewrite('tractable', deep=True)
+
+    def _eval_is_integer(self):
+        return fuzzy_and((self.args[0].is_integer, self.args[1].is_integer,
+                          self.args[1].is_nonnegative))
+
+
+rf = RisingFactorial
+ff = FallingFactorial
+
+###############################################################################
+########################### BINOMIAL COEFFICIENTS #############################
+###############################################################################
+
+
+class binomial(CombinatorialFunction):
+    r"""Implementation of the binomial coefficient. It can be defined
+    in two ways depending on its desired interpretation:
+
+    .. math:: \binom{n}{k} = \frac{n!}{k!(n-k)!}\ \text{or}\
+                \binom{n}{k} = \frac{(n)_k}{k!}
+
+    First, in a strict combinatorial sense it defines the
+    number of ways we can choose `k` elements from a set of
+    `n` elements. In this case both arguments are nonnegative
+    integers and binomial is computed using an efficient
+    algorithm based on prime factorization.
+
+    The other definition is generalization for arbitrary `n`,
+    however `k` must also be nonnegative. This case is very
+    useful when evaluating summations.
+
+    For the sake of convenience, for negative integer `k` this function
+    will return zero no matter the other argument.
+
+    To expand the binomial when `n` is a symbol, use either
+    ``expand_func()`` or ``expand(func=True)``. The former will keep
+    the polynomial in factored form while the latter will expand the
+    polynomial itself. See examples for details.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Rational, binomial, expand_func
+    >>> n = Symbol('n', integer=True, positive=True)
+
+    >>> binomial(15, 8)
+    6435
+
+    >>> binomial(n, -1)
+    0
+
+    Rows of Pascal's triangle can be generated with the binomial function:
+
+    >>> for N in range(8):
+    ...     print([binomial(N, i) for i in range(N + 1)])
+    ...
+    [1]
+    [1, 1]
+    [1, 2, 1]
+    [1, 3, 3, 1]
+    [1, 4, 6, 4, 1]
+    [1, 5, 10, 10, 5, 1]
+    [1, 6, 15, 20, 15, 6, 1]
+    [1, 7, 21, 35, 35, 21, 7, 1]
+
+    As can a given diagonal, e.g. the 4th diagonal:
+
+    >>> N = -4
+    >>> [binomial(N, i) for i in range(1 - N)]
+    [1, -4, 10, -20, 35]
+
+    >>> binomial(Rational(5, 4), 3)
+    -5/128
+    >>> binomial(Rational(-5, 4), 3)
+    -195/128
+
+    >>> binomial(n, 3)
+    binomial(n, 3)
+
+    >>> binomial(n, 3).expand(func=True)
+    n**3/6 - n**2/2 + n/3
+
+    >>> expand_func(binomial(n, 3))
+    n*(n - 2)*(n - 1)/6
+
+    References
+    ==========
+
+    .. [1] https://www.johndcook.com/blog/binomial_coefficients/
+
+    """
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.gamma_functions import polygamma
+        if argindex == 1:
+            # https://functions.wolfram.com/GammaBetaErf/Binomial/20/01/01/
+            n, k = self.args
+            return binomial(n, k)*(polygamma(0, n + 1) - \
+                polygamma(0, n - k + 1))
+        elif argindex == 2:
+            # https://functions.wolfram.com/GammaBetaErf/Binomial/20/01/02/
+            n, k = self.args
+            return binomial(n, k)*(polygamma(0, n - k + 1) - \
+                polygamma(0, k + 1))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def _eval(self, n, k):
+        # n.is_Number and k.is_Integer and k != 1 and n != k
+
+        if k.is_Integer:
+            if n.is_Integer and n >= 0:
+                n, k = int(n), int(k)
+
+                if k > n:
+                    return S.Zero
+                elif k > n // 2:
+                    k = n - k
+
+                if HAS_GMPY:
+                    return Integer(gmpy.bincoef(n, k))
+
+                d, result = n - k, 1
+                for i in range(1, k + 1):
+                    d += 1
+                    result = result * d // i
+                return Integer(result)
+            else:
+                d, result = n - k, 1
+                for i in range(1, k + 1):
+                    d += 1
+                    result *= d
+                return result / _factorial(k)
+
+    @classmethod
+    def eval(cls, n, k):
+        n, k = map(sympify, (n, k))
+        d = n - k
+        n_nonneg, n_isint = n.is_nonnegative, n.is_integer
+        if k.is_zero or ((n_nonneg or n_isint is False)
+                and d.is_zero):
+            return S.One
+        if (k - 1).is_zero or ((n_nonneg or n_isint is False)
+                and (d - 1).is_zero):
+            return n
+        if k.is_integer:
+            if k.is_negative or (n_nonneg and n_isint and d.is_negative):
+                return S.Zero
+            elif n.is_number:
+                res = cls._eval(n, k)
+                return res.expand(basic=True) if res else res
+        elif n_nonneg is False and n_isint:
+            # a special case when binomial evaluates to complex infinity
+            return S.ComplexInfinity
+        elif k.is_number:
+            from sympy.functions.special.gamma_functions import gamma
+            return gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+
+    def _eval_Mod(self, q):
+        n, k = self.args
+
+        if any(x.is_integer is False for x in (n, k, q)):
+            raise ValueError("Integers expected for binomial Mod")
+
+        if all(x.is_Integer for x in (n, k, q)):
+            n, k = map(int, (n, k))
+            aq, res = abs(q), 1
+
+            # handle negative integers k or n
+            if k < 0:
+                return S.Zero
+            if n < 0:
+                n = -n + k - 1
+                res = -1 if k%2 else 1
+
+            # non negative integers k and n
+            if k > n:
+                return S.Zero
+
+            isprime = aq.is_prime
+            aq = int(aq)
+            if isprime:
+                if aq < n:
+                    # use Lucas Theorem
+                    N, K = n, k
+                    while N or K:
+                        res = res*binomial(N % aq, K % aq) % aq
+                        N, K = N // aq, K // aq
+
+                else:
+                    # use Factorial Modulo
+                    d = n - k
+                    if k > d:
+                        k, d = d, k
+                    kf = 1
+                    for i in range(2, k + 1):
+                        kf = kf*i % aq
+                    df = kf
+                    for i in range(k + 1, d + 1):
+                        df = df*i % aq
+                    res *= df
+                    for i in range(d + 1, n + 1):
+                        res = res*i % aq
+
+                    res *= pow(kf*df % aq, aq - 2, aq)
+                    res %= aq
+
+            else:
+                # Binomial Factorization is performed by calculating the
+                # exponents of primes <= n in `n! /(k! (n - k)!)`,
+                # for non-negative integers n and k. As the exponent of
+                # prime in n! is e_p(n) = [n/p] + [n/p**2] + ...
+                # the exponent of prime in binomial(n, k) would be
+                # e_p(n) - e_p(k) - e_p(n - k)
+                M = int(_sqrt(n))
+                for prime in sieve.primerange(2, n + 1):
+                    if prime > n - k:
+                        res = res*prime % aq
+                    elif prime > n // 2:
+                        continue
+                    elif prime > M:
+                        if n % prime < k % prime:
+                            res = res*prime % aq
+                    else:
+                        N, K = n, k
+                        exp = a = 0
+
+                        while N > 0:
+                            a = int((N % prime) < (K % prime + a))
+                            N, K = N // prime, K // prime
+                            exp += a
+
+                        if exp > 0:
+                            res *= pow(prime, exp, aq)
+                            res %= aq
+
+            return S(res % q)
+
+    def _eval_expand_func(self, **hints):
+        """
+        Function to expand binomial(n, k) when m is positive integer
+        Also,
+        n is self.args[0] and k is self.args[1] while using binomial(n, k)
+        """
+        n = self.args[0]
+        if n.is_Number:
+            return binomial(*self.args)
+
+        k = self.args[1]
+        if (n-k).is_Integer:
+            k = n - k
+
+        if k.is_Integer:
+            if k.is_zero:
+                return S.One
+            elif k.is_negative:
+                return S.Zero
+            else:
+                n, result = self.args[0], 1
+                for i in range(1, k + 1):
+                    result *= n - k + i
+                return result / _factorial(k)
+        else:
+            return binomial(*self.args)
+
+    def _eval_rewrite_as_factorial(self, n, k, **kwargs):
+        return factorial(n)/(factorial(k)*factorial(n - k))
+
+    def _eval_rewrite_as_gamma(self, n, k, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+
+    def _eval_rewrite_as_tractable(self, n, k, limitvar=None, **kwargs):
+        return self._eval_rewrite_as_gamma(n, k).rewrite('tractable')
+
+    def _eval_rewrite_as_FallingFactorial(self, n, k, **kwargs):
+        if k.is_integer:
+            return ff(n, k) / factorial(k)
+
+    def _eval_is_integer(self):
+        n, k = self.args
+        if n.is_integer and k.is_integer:
+            return True
+        elif k.is_integer is False:
+            return False
+
+    def _eval_is_nonnegative(self):
+        n, k = self.args
+        if n.is_integer and k.is_integer:
+            if n.is_nonnegative or k.is_negative or k.is_even:
+                return True
+            elif k.is_even is False:
+                return  False
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.functions.special.gamma_functions import gamma
+        return self.rewrite(gamma)._eval_as_leading_term(x, logx=logx, cdir=cdir)

venv/lib/python3.10/site-packages/sympy/functions/combinatorial/numbers.py

@@ -0,0 +1,2563 @@
+"""
+This module implements some special functions that commonly appear in
+combinatorial contexts (e.g. in power series); in particular,
+sequences of rational numbers such as Bernoulli and Fibonacci numbers.
+
+Factorials, binomial coefficients and related functions are located in
+the separate 'factorials' module.
+"""
+from math import prod
+from collections import defaultdict
+from typing import Tuple as tTuple
+
+from sympy.core import S, Symbol, Add, Dummy
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import ArgumentIndexError, Function, expand_mul
+from sympy.core.logic import fuzzy_not
+from sympy.core.mul import Mul
+from sympy.core.numbers import E, I, pi, oo, Rational, Integer
+from sympy.core.relational import Eq, is_le, is_gt
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.functions.combinatorial.factorials import (binomial,
+    factorial, subfactorial)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.ntheory.primetest import isprime, is_square
+from sympy.polys.appellseqs import bernoulli_poly, euler_poly, genocchi_poly
+from sympy.utilities.enumerative import MultisetPartitionTraverser
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import multiset, multiset_derangements, iterable
+from sympy.utilities.memoization import recurrence_memo
+from sympy.utilities.misc import as_int
+
+from mpmath import mp, workprec
+from mpmath.libmp import ifib as _ifib
+
+
+def _product(a, b):
+    return prod(range(a, b + 1))
+
+
+# Dummy symbol used for computing polynomial sequences
+_sym = Symbol('x')
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Carmichael numbers                               #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _divides(p, n):
+    return n % p == 0
+
+class carmichael(Function):
+    r"""
+    Carmichael Numbers:
+
+    Certain cryptographic algorithms make use of big prime numbers.
+    However, checking whether a big number is prime is not so easy.
+    Randomized prime number checking tests exist that offer a high degree of
+    confidence of accurate determination at low cost, such as the Fermat test.
+
+    Let 'a' be a random number between $2$ and $n - 1$, where $n$ is the
+    number whose primality we are testing. Then, $n$ is probably prime if it
+    satisfies the modular arithmetic congruence relation:
+
+    .. math :: a^{n-1} = 1 \pmod{n}
+
+    (where mod refers to the modulo operation)
+
+    If a number passes the Fermat test several times, then it is prime with a
+    high probability.
+
+    Unfortunately, certain composite numbers (non-primes) still pass the Fermat
+    test with every number smaller than themselves.
+    These numbers are called Carmichael numbers.
+
+    A Carmichael number will pass a Fermat primality test to every base $b$
+    relatively prime to the number, even though it is not actually prime.
+    This makes tests based on Fermat's Little Theorem less effective than
+    strong probable prime tests such as the Baillie-PSW primality test and
+    the Miller-Rabin primality test.
+
+    Examples
+    ========
+
+    >>> from sympy import carmichael
+    >>> carmichael.find_first_n_carmichaels(5)
+    [561, 1105, 1729, 2465, 2821]
+    >>> carmichael.find_carmichael_numbers_in_range(0, 562)
+    [561]
+    >>> carmichael.find_carmichael_numbers_in_range(0,1000)
+    [561]
+    >>> carmichael.find_carmichael_numbers_in_range(0,2000)
+    [561, 1105, 1729]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Carmichael_number
+    .. [2] https://en.wikipedia.org/wiki/Fermat_primality_test
+    .. [3] https://www.jstor.org/stable/23248683?seq=1#metadata_info_tab_contents
+    """
+
+    @staticmethod
+    def is_perfect_square(n):
+        sympy_deprecation_warning(
+        """
+is_perfect_square is just a wrapper around sympy.ntheory.primetest.is_square
+so use that directly instead.
+        """,
+        deprecated_since_version="1.11",
+        active_deprecations_target='deprecated-carmichael-static-methods',
+        )
+        return is_square(n)
+
+    @staticmethod
+    def divides(p, n):
+        sympy_deprecation_warning(
+        """
+        divides can be replaced by directly testing n % p == 0.
+        """,
+        deprecated_since_version="1.11",
+        active_deprecations_target='deprecated-carmichael-static-methods',
+        )
+        return n % p == 0
+
+    @staticmethod
+    def is_prime(n):
+        sympy_deprecation_warning(
+        """
+is_prime is just a wrapper around sympy.ntheory.primetest.isprime so use that
+directly instead.
+        """,
+        deprecated_since_version="1.11",
+        active_deprecations_target='deprecated-carmichael-static-methods',
+        )
+        return isprime(n)
+
+    @staticmethod
+    def is_carmichael(n):
+        if n >= 0:
+            if (n == 1) or isprime(n) or (n % 2 == 0):
+                return False
+
+            divisors = [1, n]
+
+            # get divisors
+            divisors.extend([i for i in range(3, n // 2 + 1, 2) if n % i == 0])
+
+            for i in divisors:
+                if is_square(i) and i != 1:
+                    return False
+                if isprime(i):
+                    if not _divides(i - 1, n - 1):
+                        return False
+
+            return True
+
+        else:
+            raise ValueError('The provided number must be greater than or equal to 0')
+
+    @staticmethod
+    def find_carmichael_numbers_in_range(x, y):
+        if 0 <= x <= y:
+            if x % 2 == 0:
+                return [i for i in range(x + 1, y, 2) if carmichael.is_carmichael(i)]
+            else:
+                return [i for i in range(x, y, 2) if carmichael.is_carmichael(i)]
+
+        else:
+            raise ValueError('The provided range is not valid. x and y must be non-negative integers and x <= y')
+
+    @staticmethod
+    def find_first_n_carmichaels(n):
+        i = 1
+        carmichaels = []
+
+        while len(carmichaels) < n:
+            if carmichael.is_carmichael(i):
+                carmichaels.append(i)
+            i += 2
+
+        return carmichaels
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Fibonacci numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class fibonacci(Function):
+    r"""
+    Fibonacci numbers / Fibonacci polynomials
+
+    The Fibonacci numbers are the integer sequence defined by the
+    initial terms `F_0 = 0`, `F_1 = 1` and the two-term recurrence
+    relation `F_n = F_{n-1} + F_{n-2}`.  This definition
+    extended to arbitrary real and complex arguments using
+    the formula
+
+    .. math :: F_z = \frac{\phi^z - \cos(\pi z) \phi^{-z}}{\sqrt 5}
+
+    The Fibonacci polynomials are defined by `F_1(x) = 1`,
+    `F_2(x) = x`, and `F_n(x) = x*F_{n-1}(x) + F_{n-2}(x)` for `n > 2`.
+    For all positive integers `n`, `F_n(1) = F_n`.
+
+    * ``fibonacci(n)`` gives the `n^{th}` Fibonacci number, `F_n`
+    * ``fibonacci(n, x)`` gives the `n^{th}` Fibonacci polynomial in `x`, `F_n(x)`
+
+    Examples
+    ========
+
+    >>> from sympy import fibonacci, Symbol
+
+    >>> [fibonacci(x) for x in range(11)]
+    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+    >>> fibonacci(5, Symbol('t'))
+    t**4 + 3*t**2 + 1
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, harmonic, lucas, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fibonacci_number
+    .. [2] https://mathworld.wolfram.com/FibonacciNumber.html
+
+    """
+
+    @staticmethod
+    def _fib(n):
+        return _ifib(n)
+
+    @staticmethod
+    @recurrence_memo([None, S.One, _sym])
+    def _fibpoly(n, prev):
+        return (prev[-2] + _sym*prev[-1]).expand()
+
+    @classmethod
+    def eval(cls, n, sym=None):
+        if n is S.Infinity:
+            return S.Infinity
+
+        if n.is_Integer:
+            if sym is None:
+                n = int(n)
+                if n < 0:
+                    return S.NegativeOne**(n + 1) * fibonacci(-n)
+                else:
+                    return Integer(cls._fib(n))
+            else:
+                if n < 1:
+                    raise ValueError("Fibonacci polynomials are defined "
+                       "only for positive integer indices.")
+                return cls._fibpoly(n).subs(_sym, sym)
+
+    def _eval_rewrite_as_sqrt(self, n, **kwargs):
+        from sympy.functions.elementary.miscellaneous import sqrt
+        return 2**(-n)*sqrt(5)*((1 + sqrt(5))**n - (-sqrt(5) + 1)**n) / 5
+
+    def _eval_rewrite_as_GoldenRatio(self,n, **kwargs):
+        return (S.GoldenRatio**n - 1/(-S.GoldenRatio)**n)/(2*S.GoldenRatio-1)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                               Lucas numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class lucas(Function):
+    """
+    Lucas numbers
+
+    Lucas numbers satisfy a recurrence relation similar to that of
+    the Fibonacci sequence, in which each term is the sum of the
+    preceding two. They are generated by choosing the initial
+    values `L_0 = 2` and `L_1 = 1`.
+
+    * ``lucas(n)`` gives the `n^{th}` Lucas number
+
+    Examples
+    ========
+
+    >>> from sympy import lucas
+
+    >>> [lucas(x) for x in range(11)]
+    [2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123]
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lucas_number
+    .. [2] https://mathworld.wolfram.com/LucasNumber.html
+
+    """
+
+    @classmethod
+    def eval(cls, n):
+        if n is S.Infinity:
+            return S.Infinity
+
+        if n.is_Integer:
+            return fibonacci(n + 1) + fibonacci(n - 1)
+
+    def _eval_rewrite_as_sqrt(self, n, **kwargs):
+       from sympy.functions.elementary.miscellaneous import sqrt
+       return 2**(-n)*((1 + sqrt(5))**n + (-sqrt(5) + 1)**n)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                             Tribonacci numbers                             #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class tribonacci(Function):
+    r"""
+    Tribonacci numbers / Tribonacci polynomials
+
+    The Tribonacci numbers are the integer sequence defined by the
+    initial terms `T_0 = 0`, `T_1 = 1`, `T_2 = 1` and the three-term
+    recurrence relation `T_n = T_{n-1} + T_{n-2} + T_{n-3}`.
+
+    The Tribonacci polynomials are defined by `T_0(x) = 0`, `T_1(x) = 1`,
+    `T_2(x) = x^2`, and `T_n(x) = x^2 T_{n-1}(x) + x T_{n-2}(x) + T_{n-3}(x)`
+    for `n > 2`.  For all positive integers `n`, `T_n(1) = T_n`.
+
+    * ``tribonacci(n)`` gives the `n^{th}` Tribonacci number, `T_n`
+    * ``tribonacci(n, x)`` gives the `n^{th}` Tribonacci polynomial in `x`, `T_n(x)`
+
+    Examples
+    ========
+
+    >>> from sympy import tribonacci, Symbol
+
+    >>> [tribonacci(x) for x in range(11)]
+    [0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149]
+    >>> tribonacci(5, Symbol('t'))
+    t**8 + 3*t**5 + 3*t**2
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Generalizations_of_Fibonacci_numbers#Tribonacci_numbers
+    .. [2] https://mathworld.wolfram.com/TribonacciNumber.html
+    .. [3] https://oeis.org/A000073
+
+    """
+
+    @staticmethod
+    @recurrence_memo([S.Zero, S.One, S.One])
+    def _trib(n, prev):
+        return (prev[-3] + prev[-2] + prev[-1])
+
+    @staticmethod
+    @recurrence_memo([S.Zero, S.One, _sym**2])
+    def _tribpoly(n, prev):
+        return (prev[-3] + _sym*prev[-2] + _sym**2*prev[-1]).expand()
+
+    @classmethod
+    def eval(cls, n, sym=None):
+        if n is S.Infinity:
+            return S.Infinity
+
+        if n.is_Integer:
+            n = int(n)
+            if n < 0:
+                raise ValueError("Tribonacci polynomials are defined "
+                       "only for non-negative integer indices.")
+            if sym is None:
+                return Integer(cls._trib(n))
+            else:
+                return cls._tribpoly(n).subs(_sym, sym)
+
+    def _eval_rewrite_as_sqrt(self, n, **kwargs):
+        from sympy.functions.elementary.miscellaneous import cbrt, sqrt
+        w = (-1 + S.ImaginaryUnit * sqrt(3)) / 2
+        a = (1 + cbrt(19 + 3*sqrt(33)) + cbrt(19 - 3*sqrt(33))) / 3
+        b = (1 + w*cbrt(19 + 3*sqrt(33)) + w**2*cbrt(19 - 3*sqrt(33))) / 3
+        c = (1 + w**2*cbrt(19 + 3*sqrt(33)) + w*cbrt(19 - 3*sqrt(33))) / 3
+        Tn = (a**(n + 1)/((a - b)*(a - c))
+            + b**(n + 1)/((b - a)*(b - c))
+            + c**(n + 1)/((c - a)*(c - b)))
+        return Tn
+
+    def _eval_rewrite_as_TribonacciConstant(self, n, **kwargs):
+        from sympy.functions.elementary.integers import floor
+        from sympy.functions.elementary.miscellaneous import cbrt, sqrt
+        b = cbrt(586 + 102*sqrt(33))
+        Tn = 3 * b * S.TribonacciConstant**n / (b**2 - 2*b + 4)
+        return floor(Tn + S.Half)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Bernoulli numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class bernoulli(Function):
+    r"""
+    Bernoulli numbers / Bernoulli polynomials / Bernoulli function
+
+    The Bernoulli numbers are a sequence of rational numbers
+    defined by `B_0 = 1` and the recursive relation (`n > 0`):
+
+    .. math :: n+1 = \sum_{k=0}^n \binom{n+1}{k} B_k
+
+    They are also commonly defined by their exponential generating
+    function, which is `\frac{x}{1 - e^{-x}}`. For odd indices > 1,
+    the Bernoulli numbers are zero.
+
+    The Bernoulli polynomials satisfy the analogous formula:
+
+    .. math :: B_n(x) = \sum_{k=0}^n (-1)^k \binom{n}{k} B_k x^{n-k}
+
+    Bernoulli numbers and Bernoulli polynomials are related as
+    `B_n(1) = B_n`.
+
+    The generalized Bernoulli function `\operatorname{B}(s, a)`
+    is defined for any complex `s` and `a`, except where `a` is a
+    nonpositive integer and `s` is not a nonnegative integer. It is
+    an entire function of `s` for fixed `a`, related to the Hurwitz
+    zeta function by
+
+    .. math:: \operatorname{B}(s, a) = \begin{cases}
+              -s \zeta(1-s, a) & s \ne 0 \\ 1 & s = 0 \end{cases}
+
+    When `s` is a nonnegative integer this function reduces to the
+    Bernoulli polynomials: `\operatorname{B}(n, x) = B_n(x)`. When
+    `a` is omitted it is assumed to be 1, yielding the (ordinary)
+    Bernoulli function which interpolates the Bernoulli numbers and is
+    related to the Riemann zeta function.
+
+    We compute Bernoulli numbers using Ramanujan's formula:
+
+    .. math :: B_n = \frac{A(n) - S(n)}{\binom{n+3}{n}}
+
+    where:
+
+    .. math :: A(n) = \begin{cases} \frac{n+3}{3} &
+        n \equiv 0\ \text{or}\ 2 \pmod{6} \\
+        -\frac{n+3}{6} & n \equiv 4 \pmod{6} \end{cases}
+
+    and:
+
+    .. math :: S(n) = \sum_{k=1}^{[n/6]} \binom{n+3}{n-6k} B_{n-6k}
+
+    This formula is similar to the sum given in the definition, but
+    cuts `\frac{2}{3}` of the terms. For Bernoulli polynomials, we use
+    Appell sequences.
+
+    For `n` a nonnegative integer and `s`, `a`, `x` arbitrary complex numbers,
+
+    * ``bernoulli(n)`` gives the nth Bernoulli number, `B_n`
+    * ``bernoulli(s)`` gives the Bernoulli function `\operatorname{B}(s)`
+    * ``bernoulli(n, x)`` gives the nth Bernoulli polynomial in `x`, `B_n(x)`
+    * ``bernoulli(s, a)`` gives the generalized Bernoulli function
+      `\operatorname{B}(s, a)`
+
+    .. versionchanged:: 1.12
+        ``bernoulli(1)`` gives `+\frac{1}{2}` instead of `-\frac{1}{2}`.
+        This choice of value confers several theoretical advantages [5]_,
+        including the extension to complex parameters described above
+        which this function now implements. The previous behavior, defined
+        only for nonnegative integers `n`, can be obtained with
+        ``(-1)**n*bernoulli(n)``.
+
+    Examples
+    ========
+
+    >>> from sympy import bernoulli
+    >>> from sympy.abc import x
+    >>> [bernoulli(n) for n in range(11)]
+    [1, 1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66]
+    >>> bernoulli(1000001)
+    0
+    >>> bernoulli(3, x)
+    x**3 - 3*x**2/2 + x/2
+
+    See Also
+    ========
+
+    andre, bell, catalan, euler, fibonacci, harmonic, lucas, genocchi,
+    partition, tribonacci, sympy.polys.appellseqs.bernoulli_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bernoulli_number
+    .. [2] https://en.wikipedia.org/wiki/Bernoulli_polynomial
+    .. [3] https://mathworld.wolfram.com/BernoulliNumber.html
+    .. [4] https://mathworld.wolfram.com/BernoulliPolynomial.html
+    .. [5] Peter Luschny, "The Bernoulli Manifesto",
+           https://luschny.de/math/zeta/The-Bernoulli-Manifesto.html
+    .. [6] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+
+    """
+
+    args: tTuple[Integer]
+
+    # Calculates B_n for positive even n
+    @staticmethod
+    def _calc_bernoulli(n):
+        s = 0
+        a = int(binomial(n + 3, n - 6))
+        for j in range(1, n//6 + 1):
+            s += a * bernoulli(n - 6*j)
+            # Avoid computing each binomial coefficient from scratch
+            a *= _product(n - 6 - 6*j + 1, n - 6*j)
+            a //= _product(6*j + 4, 6*j + 9)
+        if n % 6 == 4:
+            s = -Rational(n + 3, 6) - s
+        else:
+            s = Rational(n + 3, 3) - s
+        return s / binomial(n + 3, n)
+
+    # We implement a specialized memoization scheme to handle each
+    # case modulo 6 separately
+    _cache = {0: S.One, 2: Rational(1, 6), 4: Rational(-1, 30)}
+    _highest = {0: 0, 2: 2, 4: 4}
+
+    @classmethod
+    def eval(cls, n, x=None):
+        if x is S.One:
+            return cls(n)
+        elif n.is_zero:
+            return S.One
+        elif n.is_integer is False or n.is_nonnegative is False:
+            if x is not None and x.is_Integer and x.is_nonpositive:
+                return S.NaN
+            return
+        # Bernoulli numbers
+        elif x is None:
+            if n is S.One:
+                return S.Half
+            elif n.is_odd and (n-1).is_positive:
+                return S.Zero
+            elif n.is_Number:
+                n = int(n)
+                # Use mpmath for enormous Bernoulli numbers
+                if n > 500:
+                    p, q = mp.bernfrac(n)
+                    return Rational(int(p), int(q))
+                case = n % 6
+                highest_cached = cls._highest[case]
+                if n <= highest_cached:
+                    return cls._cache[n]
+                # To avoid excessive recursion when, say, bernoulli(1000) is
+                # requested, calculate and cache the entire sequence ... B_988,
+                # B_994, B_1000 in increasing order
+                for i in range(highest_cached + 6, n + 6, 6):
+                    b = cls._calc_bernoulli(i)
+                    cls._cache[i] = b
+                    cls._highest[case] = i
+                return b
+        # Bernoulli polynomials
+        elif n.is_Number:
+            return bernoulli_poly(n, x)
+
+    def _eval_rewrite_as_zeta(self, n, x=1, **kwargs):
+        from sympy.functions.special.zeta_functions import zeta
+        return Piecewise((1, Eq(n, 0)), (-n * zeta(1-n, x), True))
+
+    def _eval_evalf(self, prec):
+        if not all(x.is_number for x in self.args):
+            return
+        n = self.args[0]._to_mpmath(prec)
+        x = (self.args[1] if len(self.args) > 1 else S.One)._to_mpmath(prec)
+        with workprec(prec):
+            if n == 0:
+                res = mp.mpf(1)
+            elif n == 1:
+                res = x - mp.mpf(0.5)
+            elif mp.isint(n) and n >= 0:
+                res = mp.bernoulli(n) if x == 1 else mp.bernpoly(n, x)
+            else:
+                res = -n * mp.zeta(1-n, x)
+        return Expr._from_mpmath(res, prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                Bell numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class bell(Function):
+    r"""
+    Bell numbers / Bell polynomials
+
+    The Bell numbers satisfy `B_0 = 1` and
+
+    .. math:: B_n = \sum_{k=0}^{n-1} \binom{n-1}{k} B_k.
+
+    They are also given by:
+
+    .. math:: B_n = \frac{1}{e} \sum_{k=0}^{\infty} \frac{k^n}{k!}.
+
+    The Bell polynomials are given by `B_0(x) = 1` and
+
+    .. math:: B_n(x) = x \sum_{k=1}^{n-1} \binom{n-1}{k-1} B_{k-1}(x).
+
+    The second kind of Bell polynomials (are sometimes called "partial" Bell
+    polynomials or incomplete Bell polynomials) are defined as
+
+    .. math:: B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) =
+            \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n}
+                \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!}
+                \left(\frac{x_1}{1!} \right)^{j_1}
+                \left(\frac{x_2}{2!} \right)^{j_2} \dotsb
+                \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}.
+
+    * ``bell(n)`` gives the `n^{th}` Bell number, `B_n`.
+    * ``bell(n, x)`` gives the `n^{th}` Bell polynomial, `B_n(x)`.
+    * ``bell(n, k, (x1, x2, ...))`` gives Bell polynomials of the second kind,
+      `B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})`.
+
+    Notes
+    =====
+
+    Not to be confused with Bernoulli numbers and Bernoulli polynomials,
+    which use the same notation.
+
+    Examples
+    ========
+
+    >>> from sympy import bell, Symbol, symbols
+
+    >>> [bell(n) for n in range(11)]
+    [1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975]
+    >>> bell(30)
+    846749014511809332450147
+    >>> bell(4, Symbol('t'))
+    t**4 + 6*t**3 + 7*t**2 + t
+    >>> bell(6, 2, symbols('x:6')[1:])
+    6*x1*x5 + 15*x2*x4 + 10*x3**2
+
+    See Also
+    ========
+
+    bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bell_number
+    .. [2] https://mathworld.wolfram.com/BellNumber.html
+    .. [3] https://mathworld.wolfram.com/BellPolynomial.html
+
+    """
+
+    @staticmethod
+    @recurrence_memo([1, 1])
+    def _bell(n, prev):
+        s = 1
+        a = 1
+        for k in range(1, n):
+            a = a * (n - k) // k
+            s += a * prev[k]
+        return s
+
+    @staticmethod
+    @recurrence_memo([S.One, _sym])
+    def _bell_poly(n, prev):
+        s = 1
+        a = 1
+        for k in range(2, n + 1):
+            a = a * (n - k + 1) // (k - 1)
+            s += a * prev[k - 1]
+        return expand_mul(_sym * s)
+
+    @staticmethod
+    def _bell_incomplete_poly(n, k, symbols):
+        r"""
+        The second kind of Bell polynomials (incomplete Bell polynomials).
+
+        Calculated by recurrence formula:
+
+        .. math:: B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) =
+                \sum_{m=1}^{n-k+1}
+                \x_m \binom{n-1}{m-1} B_{n-m,k-1}(x_1, x_2, \dotsc, x_{n-m-k})
+
+        where
+            `B_{0,0} = 1;`
+            `B_{n,0} = 0; for n \ge 1`
+            `B_{0,k} = 0; for k \ge 1`
+
+        """
+        if (n == 0) and (k == 0):
+            return S.One
+        elif (n == 0) or (k == 0):
+            return S.Zero
+        s = S.Zero
+        a = S.One
+        for m in range(1, n - k + 2):
+            s += a * bell._bell_incomplete_poly(
+                n - m, k - 1, symbols) * symbols[m - 1]
+            a = a * (n - m) / m
+        return expand_mul(s)
+
+    @classmethod
+    def eval(cls, n, k_sym=None, symbols=None):
+        if n is S.Infinity:
+            if k_sym is None:
+                return S.Infinity
+            else:
+                raise ValueError("Bell polynomial is not defined")
+
+        if n.is_negative or n.is_integer is False:
+            raise ValueError("a non-negative integer expected")
+
+        if n.is_Integer and n.is_nonnegative:
+            if k_sym is None:
+                return Integer(cls._bell(int(n)))
+            elif symbols is None:
+                return cls._bell_poly(int(n)).subs(_sym, k_sym)
+            else:
+                r = cls._bell_incomplete_poly(int(n), int(k_sym), symbols)
+                return r
+
+    def _eval_rewrite_as_Sum(self, n, k_sym=None, symbols=None, **kwargs):
+        from sympy.concrete.summations import Sum
+        if (k_sym is not None) or (symbols is not None):
+            return self
+
+        # Dobinski's formula
+        if not n.is_nonnegative:
+            return self
+        k = Dummy('k', integer=True, nonnegative=True)
+        return 1 / E * Sum(k**n / factorial(k), (k, 0, S.Infinity))
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Harmonic numbers                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class harmonic(Function):
+    r"""
+    Harmonic numbers
+
+    The nth harmonic number is given by `\operatorname{H}_{n} =
+    1 + \frac{1}{2} + \frac{1}{3} + \ldots + \frac{1}{n}`.
+
+    More generally:
+
+    .. math:: \operatorname{H}_{n,m} = \sum_{k=1}^{n} \frac{1}{k^m}
+
+    As `n \rightarrow \infty`, `\operatorname{H}_{n,m} \rightarrow \zeta(m)`,
+    the Riemann zeta function.
+
+    * ``harmonic(n)`` gives the nth harmonic number, `\operatorname{H}_n`
+
+    * ``harmonic(n, m)`` gives the nth generalized harmonic number
+      of order `m`, `\operatorname{H}_{n,m}`, where
+      ``harmonic(n) == harmonic(n, 1)``
+
+    This function can be extended to complex `n` and `m` where `n` is not a
+    negative integer or `m` is a nonpositive integer as
+
+    .. math:: \operatorname{H}_{n,m} = \begin{cases} \zeta(m) - \zeta(m, n+1)
+            & m \ne 1 \\ \psi(n+1) + \gamma & m = 1 \end{cases}
+
+    Examples
+    ========
+
+    >>> from sympy import harmonic, oo
+
+    >>> [harmonic(n) for n in range(6)]
+    [0, 1, 3/2, 11/6, 25/12, 137/60]
+    >>> [harmonic(n, 2) for n in range(6)]
+    [0, 1, 5/4, 49/36, 205/144, 5269/3600]
+    >>> harmonic(oo, 2)
+    pi**2/6
+
+    >>> from sympy import Symbol, Sum
+    >>> n = Symbol("n")
+
+    >>> harmonic(n).rewrite(Sum)
+    Sum(1/_k, (_k, 1, n))
+
+    We can evaluate harmonic numbers for all integral and positive
+    rational arguments:
+
+    >>> from sympy import S, expand_func, simplify
+    >>> harmonic(8)
+    761/280
+    >>> harmonic(11)
+    83711/27720
+
+    >>> H = harmonic(1/S(3))
+    >>> H
+    harmonic(1/3)
+    >>> He = expand_func(H)
+    >>> He
+    -log(6) - sqrt(3)*pi/6 + 2*Sum(log(sin(_k*pi/3))*cos(2*_k*pi/3), (_k, 1, 1))
+                           + 3*Sum(1/(3*_k + 1), (_k, 0, 0))
+    >>> He.doit()
+    -log(6) - sqrt(3)*pi/6 - log(sqrt(3)/2) + 3
+    >>> H = harmonic(25/S(7))
+    >>> He = simplify(expand_func(H).doit())
+    >>> He
+    log(sin(2*pi/7)**(2*cos(16*pi/7))/(14*sin(pi/7)**(2*cos(pi/7))*cos(pi/14)**(2*sin(pi/14)))) + pi*tan(pi/14)/2 + 30247/9900
+    >>> He.n(40)
+    1.983697455232980674869851942390639915940
+    >>> harmonic(25/S(7)).n(40)
+    1.983697455232980674869851942390639915940
+
+    We can rewrite harmonic numbers in terms of polygamma functions:
+
+    >>> from sympy import digamma, polygamma
+    >>> m = Symbol("m", integer=True, positive=True)
+
+    >>> harmonic(n).rewrite(digamma)
+    polygamma(0, n + 1) + EulerGamma
+
+    >>> harmonic(n).rewrite(polygamma)
+    polygamma(0, n + 1) + EulerGamma
+
+    >>> harmonic(n,3).rewrite(polygamma)
+    polygamma(2, n + 1)/2 + zeta(3)
+
+    >>> simplify(harmonic(n,m).rewrite(polygamma))
+    Piecewise((polygamma(0, n + 1) + EulerGamma, Eq(m, 1)),
+    (-(-1)**m*polygamma(m - 1, n + 1)/factorial(m - 1) + zeta(m), True))
+
+    Integer offsets in the argument can be pulled out:
+
+    >>> from sympy import expand_func
+
+    >>> expand_func(harmonic(n+4))
+    harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
+
+    >>> expand_func(harmonic(n-4))
+    harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n
+
+    Some limits can be computed as well:
+
+    >>> from sympy import limit, oo
+
+    >>> limit(harmonic(n), n, oo)
+    oo
+
+    >>> limit(harmonic(n, 2), n, oo)
+    pi**2/6
+
+    >>> limit(harmonic(n, 3), n, oo)
+    zeta(3)
+
+    For `m > 1`, `H_{n,m}` tends to `\zeta(m)` in the limit of infinite `n`:
+
+    >>> m = Symbol("m", positive=True)
+    >>> limit(harmonic(n, m+1), n, oo)
+    zeta(m + 1)
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, lucas, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Harmonic_number
+    .. [2] https://functions.wolfram.com/GammaBetaErf/HarmonicNumber/
+    .. [3] https://functions.wolfram.com/GammaBetaErf/HarmonicNumber2/
+
+    """
+
+    @classmethod
+    def eval(cls, n, m=None):
+        from sympy.functions.special.zeta_functions import zeta
+        if m is S.One:
+            return cls(n)
+        if m is None:
+            m = S.One
+        if n.is_zero:
+            return S.Zero
+        elif m.is_zero:
+            return n
+        elif n is S.Infinity:
+            if m.is_negative:
+                return S.NaN
+            elif is_le(m, S.One):
+                return S.Infinity
+            elif is_gt(m, S.One):
+                return zeta(m)
+        elif m.is_Integer and m.is_nonpositive:
+            return (bernoulli(1-m, n+1) - bernoulli(1-m)) / (1-m)
+        elif n.is_Integer:
+            if n.is_negative and (m.is_integer is False or m.is_nonpositive is False):
+                return S.ComplexInfinity if m is S.One else S.NaN
+            if n.is_nonnegative:
+                return Add(*(k**(-m) for k in range(1, int(n)+1)))
+
+    def _eval_rewrite_as_polygamma(self, n, m=S.One, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma, polygamma
+        if m.is_integer and m.is_positive:
+            return Piecewise((polygamma(0, n+1) + S.EulerGamma, Eq(m, 1)),
+                    (S.NegativeOne**m * (polygamma(m-1, 1) - polygamma(m-1, n+1)) /
+                    gamma(m), True))
+
+    def _eval_rewrite_as_digamma(self, n, m=1, **kwargs):
+        from sympy.functions.special.gamma_functions import polygamma
+        return self.rewrite(polygamma)
+
+    def _eval_rewrite_as_trigamma(self, n, m=1, **kwargs):
+        from sympy.functions.special.gamma_functions import polygamma
+        return self.rewrite(polygamma)
+
+    def _eval_rewrite_as_Sum(self, n, m=None, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k", integer=True)
+        if m is None:
+            m = S.One
+        return Sum(k**(-m), (k, 1, n))
+
+    def _eval_rewrite_as_zeta(self, n, m=S.One, **kwargs):
+        from sympy.functions.special.zeta_functions import zeta
+        from sympy.functions.special.gamma_functions import digamma
+        return Piecewise((digamma(n + 1) + S.EulerGamma, Eq(m, 1)),
+                         (zeta(m) - zeta(m, n+1), True))
+
+    def _eval_expand_func(self, **hints):
+        from sympy.concrete.summations 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:
+                    from sympy.functions.elementary.exponential import log
+                    from sympy.functions.elementary.integers import floor
+                    from sympy.functions.elementary.trigonometric import sin, cos, cot
+                    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 _eval_rewrite_as_tractable(self, n, m=1, limitvar=None, **kwargs):
+        from sympy.functions.special.zeta_functions import zeta
+        from sympy.functions.special.gamma_functions import polygamma
+        pg = self.rewrite(polygamma)
+        if not isinstance(pg, harmonic):
+            return pg.rewrite("tractable", deep=True)
+        arg = m - S.One
+        if arg.is_nonzero:
+            return (zeta(m) - zeta(m, n+1)).rewrite("tractable", deep=True)
+
+    def _eval_evalf(self, prec):
+        if not all(x.is_number for x in self.args):
+            return
+        n = self.args[0]._to_mpmath(prec)
+        m = (self.args[1] if len(self.args) > 1 else S.One)._to_mpmath(prec)
+        if mp.isint(n) and n < 0:
+            return S.NaN
+        with workprec(prec):
+            if m == 1:
+                res = mp.harmonic(n)
+            else:
+                res = mp.zeta(m) - mp.zeta(m, n+1)
+        return Expr._from_mpmath(res, prec)
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.zeta_functions import zeta
+        if len(self.args) == 2:
+            n, m = self.args
+        else:
+            n, m = self.args + (1,)
+        if argindex == 1:
+            return m * zeta(m+1, n+1)
+        else:
+            raise ArgumentIndexError
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Euler numbers                                    #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class euler(Function):
+    r"""
+    Euler numbers / Euler polynomials / Euler function
+
+    The Euler numbers are given by:
+
+    .. math:: E_{2n} = I \sum_{k=1}^{2n+1} \sum_{j=0}^k \binom{k}{j}
+        \frac{(-1)^j (k-2j)^{2n+1}}{2^k I^k k}
+
+    .. math:: E_{2n+1} = 0
+
+    Euler numbers and Euler polynomials are related by
+
+    .. math:: E_n = 2^n E_n\left(\frac{1}{2}\right).
+
+    We compute symbolic Euler polynomials using Appell sequences,
+    but numerical evaluation of the Euler polynomial is computed
+    more efficiently (and more accurately) using the mpmath library.
+
+    The Euler polynomials are special cases of the generalized Euler function,
+    related to the Genocchi function as
+
+    .. math:: \operatorname{E}(s, a) = -\frac{\operatorname{G}(s+1, a)}{s+1}
+
+    with the limit of `\psi\left(\frac{a+1}{2}\right) - \psi\left(\frac{a}{2}\right)`
+    being taken when `s = -1`. The (ordinary) Euler function interpolating
+    the Euler numbers is then obtained as
+    `\operatorname{E}(s) = 2^s \operatorname{E}\left(s, \frac{1}{2}\right)`.
+
+    * ``euler(n)`` gives the nth Euler number `E_n`.
+    * ``euler(s)`` gives the Euler function `\operatorname{E}(s)`.
+    * ``euler(n, x)`` gives the nth Euler polynomial `E_n(x)`.
+    * ``euler(s, a)`` gives the generalized Euler function `\operatorname{E}(s, a)`.
+
+    Examples
+    ========
+
+    >>> from sympy import euler, Symbol, S
+    >>> [euler(n) for n in range(10)]
+    [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0]
+    >>> [2**n*euler(n,1) for n in range(10)]
+    [1, 1, 0, -2, 0, 16, 0, -272, 0, 7936]
+    >>> n = Symbol("n")
+    >>> euler(n + 2*n)
+    euler(3*n)
+
+    >>> x = Symbol("x")
+    >>> euler(n, x)
+    euler(n, x)
+
+    >>> euler(0, x)
+    1
+    >>> euler(1, x)
+    x - 1/2
+    >>> euler(2, x)
+    x**2 - x
+    >>> euler(3, x)
+    x**3 - 3*x**2/2 + 1/4
+    >>> euler(4, x)
+    x**4 - 2*x**3 + x
+
+    >>> euler(12, S.Half)
+    2702765/4096
+    >>> euler(12)
+    2702765
+
+    See Also
+    ========
+
+    andre, bell, bernoulli, catalan, fibonacci, harmonic, lucas, genocchi,
+    partition, tribonacci, sympy.polys.appellseqs.euler_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler_numbers
+    .. [2] https://mathworld.wolfram.com/EulerNumber.html
+    .. [3] https://en.wikipedia.org/wiki/Alternating_permutation
+    .. [4] https://mathworld.wolfram.com/AlternatingPermutation.html
+
+    """
+
+    @classmethod
+    def eval(cls, n, x=None):
+        if n.is_zero:
+            return S.One
+        elif n is S.NegativeOne:
+            if x is None:
+                return S.Pi/2
+            from sympy.functions.special.gamma_functions import digamma
+            return digamma((x+1)/2) - digamma(x/2)
+        elif n.is_integer is False or n.is_nonnegative is False:
+            return
+        # Euler numbers
+        elif x is None:
+            if n.is_odd and n.is_positive:
+                return S.Zero
+            elif n.is_Number:
+                from mpmath import mp
+                n = n._to_mpmath(mp.prec)
+                res = mp.eulernum(n, exact=True)
+                return Integer(res)
+        # Euler polynomials
+        elif n.is_Number:
+            return euler_poly(n, x)
+
+    def _eval_rewrite_as_Sum(self, n, x=None, **kwargs):
+        from sympy.concrete.summations import Sum
+        if x is None and n.is_even:
+            k = Dummy("k", integer=True)
+            j = Dummy("j", integer=True)
+            n = n / 2
+            Em = (S.ImaginaryUnit * Sum(Sum(binomial(k, j) * (S.NegativeOne**j *
+                                                              (k - 2*j)**(2*n + 1)) /
+                  (2**k*S.ImaginaryUnit**k * k), (j, 0, k)), (k, 1, 2*n + 1)))
+            return Em
+        if x:
+            k = Dummy("k", integer=True)
+            return Sum(binomial(n, k)*euler(k)/2**k*(x - S.Half)**(n - k), (k, 0, n))
+
+    def _eval_rewrite_as_genocchi(self, n, x=None, **kwargs):
+        if x is None:
+            return Piecewise((S.Pi/2, Eq(n, -1)),
+                             (-2**n * genocchi(n+1, S.Half) / (n+1), True))
+        from sympy.functions.special.gamma_functions import digamma
+        return Piecewise((digamma((x+1)/2) - digamma(x/2), Eq(n, -1)),
+                         (-genocchi(n+1, x) / (n+1), True))
+
+    def _eval_evalf(self, prec):
+        if not all(i.is_number for i in self.args):
+            return
+        from mpmath import mp
+        m, x = (self.args[0], None) if len(self.args) == 1 else self.args
+        m = m._to_mpmath(prec)
+        if x is not None:
+            x = x._to_mpmath(prec)
+        with workprec(prec):
+            if mp.isint(m) and m >= 0:
+                res = mp.eulernum(m) if x is None else mp.eulerpoly(m, x)
+            else:
+                if m == -1:
+                    res = mp.pi if x is None else mp.digamma((x+1)/2) - mp.digamma(x/2)
+                else:
+                    y = 0.5 if x is None else x
+                    res = 2 * (mp.zeta(-m, y) - 2**(m+1) * mp.zeta(-m, (y+1)/2))
+                if x is None:
+                    res *= 2**m
+        return Expr._from_mpmath(res, prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Catalan numbers                               #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class catalan(Function):
+    r"""
+    Catalan numbers
+
+    The `n^{th}` catalan number is given by:
+
+    .. math :: C_n = \frac{1}{n+1} \binom{2n}{n}
+
+    * ``catalan(n)`` gives the `n^{th}` Catalan number, `C_n`
+
+    Examples
+    ========
+
+    >>> from sympy import (Symbol, binomial, gamma, hyper,
+    ...     catalan, diff, combsimp, Rational, I)
+
+    >>> [catalan(i) for i in range(1,10)]
+    [1, 2, 5, 14, 42, 132, 429, 1430, 4862]
+
+    >>> n = Symbol("n", integer=True)
+
+    >>> catalan(n)
+    catalan(n)
+
+    Catalan numbers can be transformed into several other, identical
+    expressions involving other mathematical functions
+
+    >>> catalan(n).rewrite(binomial)
+    binomial(2*n, n)/(n + 1)
+
+    >>> catalan(n).rewrite(gamma)
+    4**n*gamma(n + 1/2)/(sqrt(pi)*gamma(n + 2))
+
+    >>> catalan(n).rewrite(hyper)
+    hyper((1 - n, -n), (2,), 1)
+
+    For some non-integer values of n we can get closed form
+    expressions by rewriting in terms of gamma functions:
+
+    >>> catalan(Rational(1, 2)).rewrite(gamma)
+    8/(3*pi)
+
+    We can differentiate the Catalan numbers C(n) interpreted as a
+    continuous real function in n:
+
+    >>> diff(catalan(n), n)
+    (polygamma(0, n + 1/2) - polygamma(0, n + 2) + log(4))*catalan(n)
+
+    As a more advanced example consider the following ratio
+    between consecutive numbers:
+
+    >>> combsimp((catalan(n + 1)/catalan(n)).rewrite(binomial))
+    2*(2*n + 1)/(n + 2)
+
+    The Catalan numbers can be generalized to complex numbers:
+
+    >>> catalan(I).rewrite(gamma)
+    4**I*gamma(1/2 + I)/(sqrt(pi)*gamma(2 + I))
+
+    and evaluated with arbitrary precision:
+
+    >>> catalan(I).evalf(20)
+    0.39764993382373624267 - 0.020884341620842555705*I
+
+    See Also
+    ========
+
+    andre, bell, bernoulli, euler, fibonacci, harmonic, lucas, genocchi,
+    partition, tribonacci, sympy.functions.combinatorial.factorials.binomial
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Catalan_number
+    .. [2] https://mathworld.wolfram.com/CatalanNumber.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/CatalanNumber/
+    .. [4] http://geometer.org/mathcircles/catalan.pdf
+
+    """
+
+    @classmethod
+    def eval(cls, n):
+        from sympy.functions.special.gamma_functions import gamma
+        if (n.is_Integer and n.is_nonnegative) or \
+           (n.is_noninteger and n.is_negative):
+            return 4**n*gamma(n + S.Half)/(gamma(S.Half)*gamma(n + 2))
+
+        if (n.is_integer and n.is_negative):
+            if (n + 1).is_negative:
+                return S.Zero
+            if (n + 1).is_zero:
+                return Rational(-1, 2)
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.elementary.exponential import log
+        from sympy.functions.special.gamma_functions import polygamma
+        n = self.args[0]
+        return catalan(n)*(polygamma(0, n + S.Half) - polygamma(0, n + 2) + log(4))
+
+    def _eval_rewrite_as_binomial(self, n, **kwargs):
+        return binomial(2*n, n)/(n + 1)
+
+    def _eval_rewrite_as_factorial(self, n, **kwargs):
+        return factorial(2*n) / (factorial(n+1) * factorial(n))
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        # The gamma function allows to generalize Catalan numbers to complex n
+        return 4**n*gamma(n + S.Half)/(gamma(S.Half)*gamma(n + 2))
+
+    def _eval_rewrite_as_hyper(self, n, **kwargs):
+        from sympy.functions.special.hyper import hyper
+        return hyper([1 - n, -n], [2], 1)
+
+    def _eval_rewrite_as_Product(self, n, **kwargs):
+        from sympy.concrete.products import Product
+        if not (n.is_integer and n.is_nonnegative):
+            return self
+        k = Dummy('k', integer=True, positive=True)
+        return Product((n + k) / k, (k, 2, n))
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_composite(self):
+        if self.args[0].is_integer and (self.args[0] - 3).is_positive:
+            return True
+
+    def _eval_evalf(self, prec):
+        from sympy.functions.special.gamma_functions import gamma
+        if self.args[0].is_number:
+            return self.rewrite(gamma)._eval_evalf(prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Genocchi numbers                                 #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class genocchi(Function):
+    r"""
+    Genocchi numbers / Genocchi polynomials / Genocchi function
+
+    The Genocchi numbers are a sequence of integers `G_n` that satisfy the
+    relation:
+
+    .. math:: \frac{-2t}{1 + e^{-t}} = \sum_{n=0}^\infty \frac{G_n t^n}{n!}
+
+    They are related to the Bernoulli numbers by
+
+    .. math:: G_n = 2 (1 - 2^n) B_n
+
+    and generalize like the Bernoulli numbers to the Genocchi polynomials and
+    function as
+
+    .. math:: \operatorname{G}(s, a) = 2 \left(\operatorname{B}(s, a) -
+              2^s \operatorname{B}\left(s, \frac{a+1}{2}\right)\right)
+
+    .. versionchanged:: 1.12
+        ``genocchi(1)`` gives `-1` instead of `1`.
+
+    Examples
+    ========
+
+    >>> from sympy import genocchi, Symbol
+    >>> [genocchi(n) for n in range(9)]
+    [0, -1, -1, 0, 1, 0, -3, 0, 17]
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> genocchi(2*n + 1)
+    0
+    >>> x = Symbol('x')
+    >>> genocchi(4, x)
+    -4*x**3 + 6*x**2 - 1
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, partition, tribonacci
+    sympy.polys.appellseqs.genocchi_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Genocchi_number
+    .. [2] https://mathworld.wolfram.com/GenocchiNumber.html
+    .. [3] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+
+    """
+
+    @classmethod
+    def eval(cls, n, x=None):
+        if x is S.One:
+            return cls(n)
+        elif n.is_integer is False or n.is_nonnegative is False:
+            return
+        # Genocchi numbers
+        elif x is None:
+            if n.is_odd and (n-1).is_positive:
+                return S.Zero
+            elif n.is_Number:
+                return 2 * (1-S(2)**n) * bernoulli(n)
+        # Genocchi polynomials
+        elif n.is_Number:
+            return genocchi_poly(n, x)
+
+    def _eval_rewrite_as_bernoulli(self, n, x=1, **kwargs):
+        if x == 1 and n.is_integer and n.is_nonnegative:
+            return 2 * (1-S(2)**n) * bernoulli(n)
+        return 2 * (bernoulli(n, x) - 2**n * bernoulli(n, (x+1) / 2))
+
+    def _eval_rewrite_as_dirichlet_eta(self, n, x=1, **kwargs):
+        from sympy.functions.special.zeta_functions import dirichlet_eta
+        return -2*n * dirichlet_eta(1-n, x)
+
+    def _eval_is_integer(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            return True
+
+    def _eval_is_negative(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_odd:
+                return fuzzy_not((n-1).is_positive)
+            return (n/2).is_odd
+
+    def _eval_is_positive(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_zero or n.is_odd:
+                return False
+            return (n/2).is_even
+
+    def _eval_is_even(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_even:
+                return n.is_zero
+            return (n-1).is_positive
+
+    def _eval_is_odd(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_even:
+                return fuzzy_not(n.is_zero)
+            return fuzzy_not((n-1).is_positive)
+
+    def _eval_is_prime(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        # only G_6 = -3 and G_8 = 17 are prime,
+        # but SymPy does not consider negatives as prime
+        # so only n=8 is tested
+        return (n-8).is_zero
+
+    def _eval_evalf(self, prec):
+        if all(i.is_number for i in self.args):
+            return self.rewrite(bernoulli)._eval_evalf(prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Andre numbers                                 #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class andre(Function):
+    r"""
+    Andre numbers / Andre function
+
+    The Andre number `\mathcal{A}_n` is Luschny's name for half the number of
+    *alternating permutations* on `n` elements, where a permutation is alternating
+    if adjacent elements alternately compare "greater" and "smaller" going from
+    left to right. For example, `2 < 3 > 1 < 4` is an alternating permutation.
+
+    This sequence is A000111 in the OEIS, which assigns the names *up/down numbers*
+    and *Euler zigzag numbers*. It satisfies a recurrence relation similar to that
+    for the Catalan numbers, with `\mathcal{A}_0 = 1` and
+
+    .. math:: 2 \mathcal{A}_{n+1} = \sum_{k=0}^n \binom{n}{k} \mathcal{A}_k \mathcal{A}_{n-k}
+
+    The Bernoulli and Euler numbers are signed transformations of the odd- and
+    even-indexed elements of this sequence respectively:
+
+    .. math :: \operatorname{B}_{2k} = \frac{2k \mathcal{A}_{2k-1}}{(-4)^k - (-16)^k}
+
+    .. math :: \operatorname{E}_{2k} = (-1)^k \mathcal{A}_{2k}
+
+    Like the Bernoulli and Euler numbers, the Andre numbers are interpolated by the
+    entire Andre function:
+
+    .. math :: \mathcal{A}(s) = (-i)^{s+1} \operatorname{Li}_{-s}(i) +
+            i^{s+1} \operatorname{Li}_{-s}(-i) = \\ \frac{2 \Gamma(s+1)}{(2\pi)^{s+1}}
+            (\zeta(s+1, 1/4) - \zeta(s+1, 3/4) \cos{\pi s})
+
+    Examples
+    ========
+
+    >>> from sympy import andre, euler, bernoulli
+    >>> [andre(n) for n in range(11)]
+    [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
+    >>> [(-1)**k * andre(2*k) for k in range(7)]
+    [1, -1, 5, -61, 1385, -50521, 2702765]
+    >>> [euler(2*k) for k in range(7)]
+    [1, -1, 5, -61, 1385, -50521, 2702765]
+    >>> [andre(2*k-1) * (2*k) / ((-4)**k - (-16)**k) for k in range(1, 8)]
+    [1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6]
+    >>> [bernoulli(2*k) for k in range(1, 8)]
+    [1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6]
+
+    See Also
+    ========
+
+    bernoulli, catalan, euler, sympy.polys.appellseqs.andre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Alternating_permutation
+    .. [2] https://mathworld.wolfram.com/EulerZigzagNumber.html
+    .. [3] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+    """
+
+    @classmethod
+    def eval(cls, n):
+        if n is S.NaN:
+            return S.NaN
+        elif n is S.Infinity:
+            return S.Infinity
+        if n.is_zero:
+            return S.One
+        elif n == -1:
+            return -log(2)
+        elif n == -2:
+            return -2*S.Catalan
+        elif n.is_Integer:
+            if n.is_nonnegative and n.is_even:
+                return abs(euler(n))
+            elif n.is_odd:
+                from sympy.functions.special.zeta_functions import zeta
+                m = -n-1
+                return I**m * Rational(1-2**m, 4**m) * zeta(-n)
+
+    def _eval_rewrite_as_zeta(self, s, **kwargs):
+        from sympy.functions.elementary.trigonometric import cos
+        from sympy.functions.special.gamma_functions import gamma
+        from sympy.functions.special.zeta_functions import zeta
+        return 2 * gamma(s+1) / (2*pi)**(s+1) * \
+                (zeta(s+1, S.One/4) - cos(pi*s) * zeta(s+1, S(3)/4))
+
+    def _eval_rewrite_as_polylog(self, s, **kwargs):
+        from sympy.functions.special.zeta_functions import polylog
+        return (-I)**(s+1) * polylog(-s, I) + I**(s+1) * polylog(-s, -I)
+
+    def _eval_is_integer(self):
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_nonnegative:
+            return True
+
+    def _eval_evalf(self, prec):
+        if not self.args[0].is_number:
+            return
+        s = self.args[0]._to_mpmath(prec+12)
+        with workprec(prec+12):
+            sp, cp = mp.sinpi(s/2), mp.cospi(s/2)
+            res = 2*mp.dirichlet(-s, (-sp, cp, sp, -cp))
+        return Expr._from_mpmath(res, prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Partition numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+_npartition = [1, 1]
+class partition(Function):
+    r"""
+    Partition numbers
+
+    The Partition numbers are a sequence of integers `p_n` that represent the
+    number of distinct ways of representing `n` as a sum of natural numbers
+    (with order irrelevant). The generating function for `p_n` is given by:
+
+    .. math:: \sum_{n=0}^\infty p_n x^n = \prod_{k=1}^\infty (1 - x^k)^{-1}
+
+    Examples
+    ========
+
+    >>> from sympy import partition, Symbol
+    >>> [partition(n) for n in range(9)]
+    [1, 1, 2, 3, 5, 7, 11, 15, 22]
+    >>> n = Symbol('n', integer=True, negative=True)
+    >>> partition(n)
+    0
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Partition_(number_theory%29
+    .. [2] https://en.wikipedia.org/wiki/Pentagonal_number_theorem
+
+    """
+
+    @staticmethod
+    def _partition(n):
+        L = len(_npartition)
+        if n < L:
+            return _npartition[n]
+        # lengthen cache
+        for _n in range(L, n + 1):
+            v, p, i = 0, 0, 0
+            while 1:
+                s = 0
+                p += 3*i + 1  # p = pentagonal number: 1, 5, 12, ...
+                if _n >= p:
+                    s += _npartition[_n - p]
+                i += 1
+                gp = p + i  # gp = generalized pentagonal: 2, 7, 15, ...
+                if _n >= gp:
+                    s += _npartition[_n - gp]
+                if s == 0:
+                    break
+                else:
+                    v += s if i%2 == 1 else -s
+            _npartition.append(v)
+        return v
+
+    @classmethod
+    def eval(cls, n):
+        is_int = n.is_integer
+        if is_int == False:
+            raise ValueError("Partition numbers are defined only for "
+                             "integers")
+        elif is_int:
+            if n.is_negative:
+                return S.Zero
+
+            if n.is_zero or (n - 1).is_zero:
+                return S.One
+
+            if n.is_Integer:
+                return Integer(cls._partition(n))
+
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer:
+            return True
+
+    def _eval_is_negative(self):
+        if self.args[0].is_integer:
+            return False
+
+    def _eval_is_positive(self):
+        n = self.args[0]
+        if n.is_nonnegative and n.is_integer:
+            return True
+
+
+#######################################################################
+###
+### Functions for enumerating partitions, permutations and combinations
+###
+#######################################################################
+
+
+class _MultisetHistogram(tuple):
+    pass
+
+
+_N = -1
+_ITEMS = -2
+_M = slice(None, _ITEMS)
+
+
+def _multiset_histogram(n):
+    """Return tuple used in permutation and combination counting. Input
+    is a dictionary giving items with counts as values or a sequence of
+    items (which need not be sorted).
+
+    The data is stored in a class deriving from tuple so it is easily
+    recognized and so it can be converted easily to a list.
+    """
+    if isinstance(n, dict):  # item: count
+        if not all(isinstance(v, int) and v >= 0 for v in n.values()):
+            raise ValueError
+        tot = sum(n.values())
+        items = sum(1 for k in n if n[k] > 0)
+        return _MultisetHistogram([n[k] for k in n if n[k] > 0] + [items, tot])
+    else:
+        n = list(n)
+        s = set(n)
+        lens = len(s)
+        lenn = len(n)
+        if lens == lenn:
+            n = [1]*lenn + [lenn, lenn]
+            return _MultisetHistogram(n)
+        m = dict(zip(s, range(lens)))
+        d = dict(zip(range(lens), (0,)*lens))
+        for i in n:
+            d[m[i]] += 1
+        return _multiset_histogram(d)
+
+
+def nP(n, k=None, replacement=False):
+    """Return the number of permutations of ``n`` items taken ``k`` at a time.
+
+    Possible values for ``n``:
+
+        integer - set of length ``n``
+
+        sequence - converted to a multiset internally
+
+        multiset - {element: multiplicity}
+
+    If ``k`` is None then the total of all permutations of length 0
+    through the number of items represented by ``n`` will be returned.
+
+    If ``replacement`` is True then a given item can appear more than once
+    in the ``k`` items. (For example, for 'ab' permutations of 2 would
+    include 'aa', 'ab', 'ba' and 'bb'.) The multiplicity of elements in
+    ``n`` is ignored when ``replacement`` is True but the total number
+    of elements is considered since no element can appear more times than
+    the number of elements in ``n``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import nP
+    >>> from sympy.utilities.iterables import multiset_permutations, multiset
+    >>> nP(3, 2)
+    6
+    >>> nP('abc', 2) == nP(multiset('abc'), 2) == 6
+    True
+    >>> nP('aab', 2)
+    3
+    >>> nP([1, 2, 2], 2)
+    3
+    >>> [nP(3, i) for i in range(4)]
+    [1, 3, 6, 6]
+    >>> nP(3) == sum(_)
+    True
+
+    When ``replacement`` is True, each item can have multiplicity
+    equal to the length represented by ``n``:
+
+    >>> nP('aabc', replacement=True)
+    121
+    >>> [len(list(multiset_permutations('aaaabbbbcccc', i))) for i in range(5)]
+    [1, 3, 9, 27, 81]
+    >>> sum(_)
+    121
+
+    See Also
+    ========
+    sympy.utilities.iterables.multiset_permutations
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Permutation
+
+    """
+    try:
+        n = as_int(n)
+    except ValueError:
+        return Integer(_nP(_multiset_histogram(n), k, replacement))
+    return Integer(_nP(n, k, replacement))
+
+
+@cacheit
+def _nP(n, k=None, replacement=False):
+
+    if k == 0:
+        return 1
+    if isinstance(n, SYMPY_INTS):  # n different items
+        # assert n >= 0
+        if k is None:
+            return sum(_nP(n, i, replacement) for i in range(n + 1))
+        elif replacement:
+            return n**k
+        elif k > n:
+            return 0
+        elif k == n:
+            return factorial(k)
+        elif k == 1:
+            return n
+        else:
+            # assert k >= 0
+            return _product(n - k + 1, n)
+    elif isinstance(n, _MultisetHistogram):
+        if k is None:
+            return sum(_nP(n, i, replacement) for i in range(n[_N] + 1))
+        elif replacement:
+            return n[_ITEMS]**k
+        elif k == n[_N]:
+            return factorial(k)/prod([factorial(i) for i in n[_M] if i > 1])
+        elif k > n[_N]:
+            return 0
+        elif k == 1:
+            return n[_ITEMS]
+        else:
+            # assert k >= 0
+            tot = 0
+            n = list(n)
+            for i in range(len(n[_M])):
+                if not n[i]:
+                    continue
+                n[_N] -= 1
+                if n[i] == 1:
+                    n[i] = 0
+                    n[_ITEMS] -= 1
+                    tot += _nP(_MultisetHistogram(n), k - 1)
+                    n[_ITEMS] += 1
+                    n[i] = 1
+                else:
+                    n[i] -= 1
+                    tot += _nP(_MultisetHistogram(n), k - 1)
+                    n[i] += 1
+                n[_N] += 1
+            return tot
+
+
+@cacheit
+def _AOP_product(n):
+    """for n = (m1, m2, .., mk) return the coefficients of the polynomial,
+    prod(sum(x**i for i in range(nj + 1)) for nj in n); i.e. the coefficients
+    of the product of AOPs (all-one polynomials) or order given in n.  The
+    resulting coefficient corresponding to x**r is the number of r-length
+    combinations of sum(n) elements with multiplicities given in n.
+    The coefficients are given as a default dictionary (so if a query is made
+    for a key that is not present, 0 will be returned).
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import _AOP_product
+    >>> from sympy.abc import x
+    >>> n = (2, 2, 3)  # e.g. aabbccc
+    >>> prod = ((x**2 + x + 1)*(x**2 + x + 1)*(x**3 + x**2 + x + 1)).expand()
+    >>> c = _AOP_product(n); dict(c)
+    {0: 1, 1: 3, 2: 6, 3: 8, 4: 8, 5: 6, 6: 3, 7: 1}
+    >>> [c[i] for i in range(8)] == [prod.coeff(x, i) for i in range(8)]
+    True
+
+    The generating poly used here is the same as that listed in
+    https://tinyurl.com/cep849r, but in a refactored form.
+
+    """
+
+    n = list(n)
+    ord = sum(n)
+    need = (ord + 2)//2
+    rv = [1]*(n.pop() + 1)
+    rv.extend((0,) * (need - len(rv)))
+    rv = rv[:need]
+    while n:
+        ni = n.pop()
+        N = ni + 1
+        was = rv[:]
+        for i in range(1, min(N, len(rv))):
+            rv[i] += rv[i - 1]
+        for i in range(N, need):
+            rv[i] += rv[i - 1] - was[i - N]
+    rev = list(reversed(rv))
+    if ord % 2:
+        rv = rv + rev
+    else:
+        rv[-1:] = rev
+    d = defaultdict(int)
+    for i, r in enumerate(rv):
+        d[i] = r
+    return d
+
+
+def nC(n, k=None, replacement=False):
+    """Return the number of combinations of ``n`` items taken ``k`` at a time.
+
+    Possible values for ``n``:
+
+        integer - set of length ``n``
+
+        sequence - converted to a multiset internally
+
+        multiset - {element: multiplicity}
+
+    If ``k`` is None then the total of all combinations of length 0
+    through the number of items represented in ``n`` will be returned.
+
+    If ``replacement`` is True then a given item can appear more than once
+    in the ``k`` items. (For example, for 'ab' sets of 2 would include 'aa',
+    'ab', and 'bb'.) The multiplicity of elements in ``n`` is ignored when
+    ``replacement`` is True but the total number of elements is considered
+    since no element can appear more times than the number of elements in
+    ``n``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import nC
+    >>> from sympy.utilities.iterables import multiset_combinations
+    >>> nC(3, 2)
+    3
+    >>> nC('abc', 2)
+    3
+    >>> nC('aab', 2)
+    2
+
+    When ``replacement`` is True, each item can have multiplicity
+    equal to the length represented by ``n``:
+
+    >>> nC('aabc', replacement=True)
+    35
+    >>> [len(list(multiset_combinations('aaaabbbbcccc', i))) for i in range(5)]
+    [1, 3, 6, 10, 15]
+    >>> sum(_)
+    35
+
+    If there are ``k`` items with multiplicities ``m_1, m_2, ..., m_k``
+    then the total of all combinations of length 0 through ``k`` is the
+    product, ``(m_1 + 1)*(m_2 + 1)*...*(m_k + 1)``. When the multiplicity
+    of each item is 1 (i.e., k unique items) then there are 2**k
+    combinations. For example, if there are 4 unique items, the total number
+    of combinations is 16:
+
+    >>> sum(nC(4, i) for i in range(5))
+    16
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.multiset_combinations
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Combination
+    .. [2] https://tinyurl.com/cep849r
+
+    """
+
+    if isinstance(n, SYMPY_INTS):
+        if k is None:
+            if not replacement:
+                return 2**n
+            return sum(nC(n, i, replacement) for i in range(n + 1))
+        if k < 0:
+            raise ValueError("k cannot be negative")
+        if replacement:
+            return binomial(n + k - 1, k)
+        return binomial(n, k)
+    if isinstance(n, _MultisetHistogram):
+        N = n[_N]
+        if k is None:
+            if not replacement:
+                return prod(m + 1 for m in n[_M])
+            return sum(nC(n, i, replacement) for i in range(N + 1))
+        elif replacement:
+            return nC(n[_ITEMS], k, replacement)
+        # assert k >= 0
+        elif k in (1, N - 1):
+            return n[_ITEMS]
+        elif k in (0, N):
+            return 1
+        return _AOP_product(tuple(n[_M]))[k]
+    else:
+        return nC(_multiset_histogram(n), k, replacement)
+
+
+def _eval_stirling1(n, k):
+    if n == k == 0:
+        return S.One
+    if 0 in (n, k):
+        return S.Zero
+
+    # some special values
+    if n == k:
+        return S.One
+    elif k == n - 1:
+        return binomial(n, 2)
+    elif k == n - 2:
+        return (3*n - 1)*binomial(n, 3)/4
+    elif k == n - 3:
+        return binomial(n, 2)*binomial(n, 4)
+
+    return _stirling1(n, k)
+
+
+@cacheit
+def _stirling1(n, k):
+    row = [0, 1]+[0]*(k-1) # for n = 1
+    for i in range(2, n+1):
+        for j in range(min(k,i), 0, -1):
+            row[j] = (i-1) * row[j] + row[j-1]
+    return Integer(row[k])
+
+
+def _eval_stirling2(n, k):
+    if n == k == 0:
+        return S.One
+    if 0 in (n, k):
+        return S.Zero
+
+    # some special values
+    if n == k:
+        return S.One
+    elif k == n - 1:
+        return binomial(n, 2)
+    elif k == 1:
+        return S.One
+    elif k == 2:
+        return Integer(2**(n - 1) - 1)
+
+    return _stirling2(n, k)
+
+
+@cacheit
+def _stirling2(n, k):
+    row = [0, 1]+[0]*(k-1) # for n = 1
+    for i in range(2, n+1):
+        for j in range(min(k,i), 0, -1):
+            row[j] = j * row[j] + row[j-1]
+    return Integer(row[k])
+
+
+def stirling(n, k, d=None, kind=2, signed=False):
+    r"""Return Stirling number $S(n, k)$ of the first or second (default) kind.
+
+    The sum of all Stirling numbers of the second kind for $k = 1$
+    through $n$ is ``bell(n)``. The recurrence relationship for these numbers
+    is:
+
+    .. math :: {0 \brace 0} = 1; {n \brace 0} = {0 \brace k} = 0;
+
+    .. math :: {{n+1} \brace k} = j {n \brace k} + {n \brace {k-1}}
+
+    where $j$ is:
+        $n$ for Stirling numbers of the first kind,
+        $-n$ for signed Stirling numbers of the first kind,
+        $k$ for Stirling numbers of the second kind.
+
+    The first kind of Stirling number counts the number of permutations of
+    ``n`` distinct items that have ``k`` cycles; the second kind counts the
+    ways in which ``n`` distinct items can be partitioned into ``k`` parts.
+    If ``d`` is given, the "reduced Stirling number of the second kind" is
+    returned: $S^{d}(n, k) = S(n - d + 1, k - d + 1)$ with $n \ge k \ge d$.
+    (This counts the ways to partition $n$ consecutive integers into $k$
+    groups with no pairwise difference less than $d$. See example below.)
+
+    To obtain the signed Stirling numbers of the first kind, use keyword
+    ``signed=True``. Using this keyword automatically sets ``kind`` to 1.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import stirling, bell
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.utilities.iterables import multiset_partitions, permutations
+
+    First kind (unsigned by default):
+
+    >>> [stirling(6, i, kind=1) for i in range(7)]
+    [0, 120, 274, 225, 85, 15, 1]
+    >>> perms = list(permutations(range(4)))
+    >>> [sum(Permutation(p).cycles == i for p in perms) for i in range(5)]
+    [0, 6, 11, 6, 1]
+    >>> [stirling(4, i, kind=1) for i in range(5)]
+    [0, 6, 11, 6, 1]
+
+    First kind (signed):
+
+    >>> [stirling(4, i, signed=True) for i in range(5)]
+    [0, -6, 11, -6, 1]
+
+    Second kind:
+
+    >>> [stirling(10, i) for i in range(12)]
+    [0, 1, 511, 9330, 34105, 42525, 22827, 5880, 750, 45, 1, 0]
+    >>> sum(_) == bell(10)
+    True
+    >>> len(list(multiset_partitions(range(4), 2))) == stirling(4, 2)
+    True
+
+    Reduced second kind:
+
+    >>> from sympy import subsets, oo
+    >>> def delta(p):
+    ...    if len(p) == 1:
+    ...        return oo
+    ...    return min(abs(i[0] - i[1]) for i in subsets(p, 2))
+    >>> parts = multiset_partitions(range(5), 3)
+    >>> d = 2
+    >>> sum(1 for p in parts if all(delta(i) >= d for i in p))
+    7
+    >>> stirling(5, 3, 2)
+    7
+
+    See Also
+    ========
+    sympy.utilities.iterables.multiset_partitions
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
+    .. [2] https://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
+
+    """
+    # TODO: make this a class like bell()
+
+    n = as_int(n)
+    k = as_int(k)
+    if n < 0:
+        raise ValueError('n must be nonnegative')
+    if k > n:
+        return S.Zero
+    if d:
+        # assert k >= d
+        # kind is ignored -- only kind=2 is supported
+        return _eval_stirling2(n - d + 1, k - d + 1)
+    elif signed:
+        # kind is ignored -- only kind=1 is supported
+        return S.NegativeOne**(n - k)*_eval_stirling1(n, k)
+
+    if kind == 1:
+        return _eval_stirling1(n, k)
+    elif kind == 2:
+        return _eval_stirling2(n, k)
+    else:
+        raise ValueError('kind must be 1 or 2, not %s' % k)
+
+
+@cacheit
+def _nT(n, k):
+    """Return the partitions of ``n`` items into ``k`` parts. This
+    is used by ``nT`` for the case when ``n`` is an integer."""
+    # really quick exits
+    if k > n or k < 0:
+        return 0
+    if k in (1, n):
+        return 1
+    if k == 0:
+        return 0
+    # exits that could be done below but this is quicker
+    if k == 2:
+        return n//2
+    d = n - k
+    if d <= 3:
+        return d
+    # quick exit
+    if 3*k >= n:  # or, equivalently, 2*k >= d
+        # all the information needed in this case
+        # will be in the cache needed to calculate
+        # partition(d), so...
+        # update cache
+        tot = partition._partition(d)
+        # and correct for values not needed
+        if d - k > 0:
+            tot -= sum(_npartition[:d - k])
+        return tot
+    # regular exit
+    # nT(n, k) = Sum(nT(n - k, m), (m, 1, k));
+    # calculate needed nT(i, j) values
+    p = [1]*d
+    for i in range(2, k + 1):
+        for m  in range(i + 1, d):
+            p[m] += p[m - i]
+        d -= 1
+    # if p[0] were appended to the end of p then the last
+    # k values of p are the nT(n, j) values for 0 < j < k in reverse
+    # order p[-1] = nT(n, 1), p[-2] = nT(n, 2), etc.... Instead of
+    # putting the 1 from p[0] there, however, it is simply added to
+    # the sum below which is valid for 1 < k <= n//2
+    return (1 + sum(p[1 - k:]))
+
+
+def nT(n, k=None):
+    """Return the number of ``k``-sized partitions of ``n`` items.
+
+    Possible values for ``n``:
+
+        integer - ``n`` identical items
+
+        sequence - converted to a multiset internally
+
+        multiset - {element: multiplicity}
+
+    Note: the convention for ``nT`` is different than that of ``nC`` and
+    ``nP`` in that
+    here an integer indicates ``n`` *identical* items instead of a set of
+    length ``n``; this is in keeping with the ``partitions`` function which
+    treats its integer-``n`` input like a list of ``n`` 1s. One can use
+    ``range(n)`` for ``n`` to indicate ``n`` distinct items.
+
+    If ``k`` is None then the total number of ways to partition the elements
+    represented in ``n`` will be returned.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import nT
+
+    Partitions of the given multiset:
+
+    >>> [nT('aabbc', i) for i in range(1, 7)]
+    [1, 8, 11, 5, 1, 0]
+    >>> nT('aabbc') == sum(_)
+    True
+
+    >>> [nT("mississippi", i) for i in range(1, 12)]
+    [1, 74, 609, 1521, 1768, 1224, 579, 197, 50, 9, 1]
+
+    Partitions when all items are identical:
+
+    >>> [nT(5, i) for i in range(1, 6)]
+    [1, 2, 2, 1, 1]
+    >>> nT('1'*5) == sum(_)
+    True
+
+    When all items are different:
+
+    >>> [nT(range(5), i) for i in range(1, 6)]
+    [1, 15, 25, 10, 1]
+    >>> nT(range(5)) == sum(_)
+    True
+
+    Partitions of an integer expressed as a sum of positive integers:
+
+    >>> from sympy import partition
+    >>> partition(4)
+    5
+    >>> nT(4, 1) + nT(4, 2) + nT(4, 3) + nT(4, 4)
+    5
+    >>> nT('1'*4)
+    5
+
+    See Also
+    ========
+    sympy.utilities.iterables.partitions
+    sympy.utilities.iterables.multiset_partitions
+    sympy.functions.combinatorial.numbers.partition
+
+    References
+    ==========
+
+    .. [1] https://web.archive.org/web/20210507012732/https://teaching.csse.uwa.edu.au/units/CITS7209/partition.pdf
+
+    """
+
+    if isinstance(n, SYMPY_INTS):
+        # n identical items
+        if k is None:
+            return partition(n)
+        if isinstance(k, SYMPY_INTS):
+            n = as_int(n)
+            k = as_int(k)
+            return Integer(_nT(n, k))
+    if not isinstance(n, _MultisetHistogram):
+        try:
+            # if n contains hashable items there is some
+            # quick handling that can be done
+            u = len(set(n))
+            if u <= 1:
+                return nT(len(n), k)
+            elif u == len(n):
+                n = range(u)
+            raise TypeError
+        except TypeError:
+            n = _multiset_histogram(n)
+    N = n[_N]
+    if k is None and N == 1:
+        return 1
+    if k in (1, N):
+        return 1
+    if k == 2 or N == 2 and k is None:
+        m, r = divmod(N, 2)
+        rv = sum(nC(n, i) for i in range(1, m + 1))
+        if not r:
+            rv -= nC(n, m)//2
+        if k is None:
+            rv += 1  # for k == 1
+        return rv
+    if N == n[_ITEMS]:
+        # all distinct
+        if k is None:
+            return bell(N)
+        return stirling(N, k)
+    m = MultisetPartitionTraverser()
+    if k is None:
+        return m.count_partitions(n[_M])
+    # MultisetPartitionTraverser does not have a range-limited count
+    # method, so need to enumerate and count
+    tot = 0
+    for discard in m.enum_range(n[_M], k-1, k):
+        tot += 1
+    return tot
+
+
+#-----------------------------------------------------------------------------#
+#                                                                             #
+#                          Motzkin numbers                                    #
+#                                                                             #
+#-----------------------------------------------------------------------------#
+
+
+class motzkin(Function):
+    """
+    The nth Motzkin number is the number
+    of ways of drawing non-intersecting chords
+    between n points on a circle (not necessarily touching
+    every point by a chord). The Motzkin numbers are named
+    after Theodore Motzkin and have diverse applications
+    in geometry, combinatorics and number theory.
+
+    Motzkin numbers are the integer sequence defined by the
+    initial terms `M_0 = 1`, `M_1 = 1` and the two-term recurrence relation
+    `M_n = \frac{2*n + 1}{n + 2} * M_{n-1} + \frac{3n - 3}{n + 2} * M_{n-2}`.
+
+
+    Examples
+    ========
+
+    >>> from sympy import motzkin
+
+    >>> motzkin.is_motzkin(5)
+    False
+    >>> motzkin.find_motzkin_numbers_in_range(2,300)
+    [2, 4, 9, 21, 51, 127]
+    >>> motzkin.find_motzkin_numbers_in_range(2,900)
+    [2, 4, 9, 21, 51, 127, 323, 835]
+    >>> motzkin.find_first_n_motzkins(10)
+    [1, 1, 2, 4, 9, 21, 51, 127, 323, 835]
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Motzkin_number
+    .. [2] https://mathworld.wolfram.com/MotzkinNumber.html
+
+    """
+
+    @staticmethod
+    def is_motzkin(n):
+        try:
+            n = as_int(n)
+        except ValueError:
+            return False
+        if n > 0:
+             if n in (1, 2):
+                return True
+
+             tn1 = 1
+             tn = 2
+             i = 3
+             while tn < n:
+                 a = ((2*i + 1)*tn + (3*i - 3)*tn1)/(i + 2)
+                 i += 1
+                 tn1 = tn
+                 tn = a
+
+             if tn == n:
+                 return True
+             else:
+                 return False
+
+        else:
+            return False
+
+    @staticmethod
+    def find_motzkin_numbers_in_range(x, y):
+        if 0 <= x <= y:
+            motzkins = []
+            if x <= 1 <= y:
+                motzkins.append(1)
+            tn1 = 1
+            tn = 2
+            i = 3
+            while tn <= y:
+                if tn >= x:
+                    motzkins.append(tn)
+                a = ((2*i + 1)*tn + (3*i - 3)*tn1)/(i + 2)
+                i += 1
+                tn1 = tn
+                tn = int(a)
+
+            return motzkins
+
+        else:
+            raise ValueError('The provided range is not valid. This condition should satisfy x <= y')
+
+    @staticmethod
+    def find_first_n_motzkins(n):
+        try:
+            n = as_int(n)
+        except ValueError:
+            raise ValueError('The provided number must be a positive integer')
+        if n < 0:
+            raise ValueError('The provided number must be a positive integer')
+        motzkins = [1]
+        if n >= 1:
+            motzkins.append(1)
+        tn1 = 1
+        tn = 2
+        i = 3
+        while i <= n:
+            motzkins.append(tn)
+            a = ((2*i + 1)*tn + (3*i - 3)*tn1)/(i + 2)
+            i += 1
+            tn1 = tn
+            tn = int(a)
+
+        return motzkins
+
+    @staticmethod
+    @recurrence_memo([S.One, S.One])
+    def _motzkin(n, prev):
+        return ((2*n + 1)*prev[-1] + (3*n - 3)*prev[-2]) // (n + 2)
+
+    @classmethod
+    def eval(cls, n):
+        try:
+            n = as_int(n)
+        except ValueError:
+            raise ValueError('The provided number must be a positive integer')
+        if n < 0:
+            raise ValueError('The provided number must be a positive integer')
+        return Integer(cls._motzkin(n - 1))
+
+
+def nD(i=None, brute=None, *, n=None, m=None):
+    """return the number of derangements for: ``n`` unique items, ``i``
+    items (as a sequence or multiset), or multiplicities, ``m`` given
+    as a sequence or multiset.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import generate_derangements as enum
+    >>> from sympy.functions.combinatorial.numbers import nD
+
+    A derangement ``d`` of sequence ``s`` has all ``d[i] != s[i]``:
+
+    >>> set([''.join(i) for i in enum('abc')])
+    {'bca', 'cab'}
+    >>> nD('abc')
+    2
+
+    Input as iterable or dictionary (multiset form) is accepted:
+
+    >>> assert nD([1, 2, 2, 3, 3, 3]) == nD({1: 1, 2: 2, 3: 3})
+
+    By default, a brute-force enumeration and count of multiset permutations
+    is only done if there are fewer than 9 elements. There may be cases when
+    there is high multiplicity with few unique elements that will benefit
+    from a brute-force enumeration, too. For this reason, the `brute`
+    keyword (default None) is provided. When False, the brute-force
+    enumeration will never be used. When True, it will always be used.
+
+    >>> nD('1111222233', brute=True)
+    44
+
+    For convenience, one may specify ``n`` distinct items using the
+    ``n`` keyword:
+
+    >>> assert nD(n=3) == nD('abc') == 2
+
+    Since the number of derangments depends on the multiplicity of the
+    elements and not the elements themselves, it may be more convenient
+    to give a list or multiset of multiplicities using keyword ``m``:
+
+    >>> assert nD('abc') == nD(m=(1,1,1)) == nD(m={1:3}) == 2
+
+    """
+    from sympy.integrals.integrals import integrate
+    from sympy.functions.special.polynomials import laguerre
+    from sympy.abc import x
+    def ok(x):
+        if not isinstance(x, SYMPY_INTS):
+            raise TypeError('expecting integer values')
+        if x < 0:
+            raise ValueError('value must not be negative')
+        return True
+
+    if (i, n, m).count(None) != 2:
+        raise ValueError('enter only 1 of i, n, or m')
+    if i is not None:
+        if isinstance(i, SYMPY_INTS):
+            raise TypeError('items must be a list or dictionary')
+        if not i:
+            return S.Zero
+        if type(i) is not dict:
+            s = list(i)
+            ms = multiset(s)
+        elif type(i) is dict:
+            all(ok(_) for _ in i.values())
+            ms = {k: v for k, v in i.items() if v}
+            s = None
+        if not ms:
+            return S.Zero
+        N = sum(ms.values())
+        counts = multiset(ms.values())
+        nkey = len(ms)
+    elif n is not None:
+        ok(n)
+        if not n:
+            return S.Zero
+        return subfactorial(n)
+    elif m is not None:
+        if isinstance(m, dict):
+            all(ok(i) and ok(j) for i, j in m.items())
+            counts = {k: v for k, v in m.items() if k*v}
+        elif iterable(m) or isinstance(m, str):
+            m = list(m)
+            all(ok(i) for i in m)
+            counts = multiset([i for i in m if i])
+        else:
+            raise TypeError('expecting iterable')
+        if not counts:
+            return S.Zero
+        N = sum(k*v for k, v in counts.items())
+        nkey = sum(counts.values())
+        s = None
+    big = int(max(counts))
+    if big == 1:  # no repetition
+        return subfactorial(nkey)
+    nval = len(counts)
+    if big*2 > N:
+        return S.Zero
+    if big*2 == N:
+        if nkey == 2 and nval == 1:
+            return S.One  # aaabbb
+        if nkey - 1 == big:  # one element repeated
+            return factorial(big)  # e.g. abc part of abcddd
+    if N < 9 and brute is None or brute:
+        # for all possibilities, this was found to be faster
+        if s is None:
+            s = []
+            i = 0
+            for m, v in counts.items():
+                for j in range(v):
+                    s.extend([i]*m)
+                    i += 1
+        return Integer(sum(1 for i in multiset_derangements(s)))
+    from sympy.functions.elementary.exponential import exp
+    return Integer(abs(integrate(exp(-x)*Mul(*[
+        laguerre(i, x)**m for i, m in counts.items()]), (x, 0, oo))))

venv/lib/python3.10/site-packages/sympy/functions/combinatorial/tests/test_comb_factorials.py

@@ -0,0 +1,650 @@
+from sympy.concrete.products import Product
+from sympy.core.function import expand_func
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core import EulerGamma
+from sympy.core.numbers import (Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (ff, rf, binomial, factorial, factorial2)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.gamma_functions import (gamma, polygamma)
+from sympy.polys.polytools import Poly
+from sympy.series.order import O
+from sympy.simplify.simplify import simplify
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.functions.combinatorial.factorials import subfactorial
+from sympy.functions.special.gamma_functions import uppergamma
+from sympy.testing.pytest import XFAIL, raises, slow
+
+#Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+
+def test_rf_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert rf(nan, y) is nan
+    assert rf(x, nan) is nan
+
+    assert unchanged(rf, x, y)
+
+    assert rf(oo, 0) == 1
+    assert rf(-oo, 0) == 1
+
+    assert rf(oo, 6) is oo
+    assert rf(-oo, 7) is -oo
+    assert rf(-oo, 6) is oo
+
+    assert rf(oo, -6) is oo
+    assert rf(-oo, -7) is oo
+
+    assert rf(-1, pi) == 0
+    assert rf(-5, 1 + I) == 0
+
+    assert unchanged(rf, -3, k)
+    assert unchanged(rf, x, Symbol('k', integer=False))
+    assert rf(-3, Symbol('k', integer=False)) == 0
+    assert rf(Symbol('x', negative=True, integer=True), Symbol('k', integer=False)) == 0
+
+    assert rf(x, 0) == 1
+    assert rf(x, 1) == x
+    assert rf(x, 2) == x*(x + 1)
+    assert rf(x, 3) == x*(x + 1)*(x + 2)
+    assert rf(x, 5) == x*(x + 1)*(x + 2)*(x + 3)*(x + 4)
+
+    assert rf(x, -1) == 1/(x - 1)
+    assert rf(x, -2) == 1/((x - 1)*(x - 2))
+    assert rf(x, -3) == 1/((x - 1)*(x - 2)*(x - 3))
+
+    assert rf(1, 100) == factorial(100)
+
+    assert rf(x**2 + 3*x, 2) == (x**2 + 3*x)*(x**2 + 3*x + 1)
+    assert isinstance(rf(x**2 + 3*x, 2), Mul)
+    assert rf(x**3 + x, -2) == 1/((x**3 + x - 1)*(x**3 + x - 2))
+
+    assert rf(Poly(x**2 + 3*x, x), 2) == Poly(x**4 + 8*x**3 + 19*x**2 + 12*x, x)
+    assert isinstance(rf(Poly(x**2 + 3*x, x), 2), Poly)
+    raises(ValueError, lambda: rf(Poly(x**2 + 3*x, x, y), 2))
+    assert rf(Poly(x**3 + x, x), -2) == 1/(x**6 - 9*x**5 + 35*x**4 - 75*x**3 + 94*x**2 - 66*x + 20)
+    raises(ValueError, lambda: rf(Poly(x**3 + x, x, y), -2))
+
+    assert rf(x, m).is_integer is None
+    assert rf(n, k).is_integer is None
+    assert rf(n, m).is_integer is True
+    assert rf(n, k + pi).is_integer is False
+    assert rf(n, m + pi).is_integer is False
+    assert rf(pi, m).is_integer is False
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+          for j in range(-5,5):
+              assert o(i, j) == r(i, j), (o, n, i, j)
+    check(x, k, rf, ff)
+    check(x, k, rf, binomial)
+    check(n, k, rf, factorial)
+    check(x, y, rf, factorial)
+    check(x, y, rf, binomial)
+
+    assert rf(x, k).rewrite(ff) == ff(x + k - 1, k)
+    assert rf(x, k).rewrite(gamma) == Piecewise(
+        (gamma(k + x)/gamma(x), x > 0),
+        ((-1)**k*gamma(1 - x)/gamma(-k - x + 1), True))
+    assert rf(5, k).rewrite(gamma) == gamma(k + 5)/24
+    assert rf(x, k).rewrite(binomial) == factorial(k)*binomial(x + k - 1, k)
+    assert rf(n, k).rewrite(factorial) == Piecewise(
+        (factorial(k + n - 1)/factorial(n - 1), n > 0),
+        ((-1)**k*factorial(-n)/factorial(-k - n), True))
+    assert rf(5, k).rewrite(factorial) == factorial(k + 4)/24
+    assert rf(x, y).rewrite(factorial) == rf(x, y)
+    assert rf(x, y).rewrite(binomial) == rf(x, y)
+
+    import random
+    from mpmath import rf as mpmath_rf
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        assert (abs(mpmath_rf(x, k) - rf(x, k)) < 10**(-15))
+
+
+def test_ff_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert ff(nan, y) is nan
+    assert ff(x, nan) is nan
+
+    assert unchanged(ff, x, y)
+
+    assert ff(oo, 0) == 1
+    assert ff(-oo, 0) == 1
+
+    assert ff(oo, 6) is oo
+    assert ff(-oo, 7) is -oo
+    assert ff(-oo, 6) is oo
+
+    assert ff(oo, -6) is oo
+    assert ff(-oo, -7) is oo
+
+    assert ff(x, 0) == 1
+    assert ff(x, 1) == x
+    assert ff(x, 2) == x*(x - 1)
+    assert ff(x, 3) == x*(x - 1)*(x - 2)
+    assert ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
+
+    assert ff(x, -1) == 1/(x + 1)
+    assert ff(x, -2) == 1/((x + 1)*(x + 2))
+    assert ff(x, -3) == 1/((x + 1)*(x + 2)*(x + 3))
+
+    assert ff(100, 100) == factorial(100)
+
+    assert ff(2*x**2 - 5*x, 2) == (2*x**2  - 5*x)*(2*x**2 - 5*x - 1)
+    assert isinstance(ff(2*x**2 - 5*x, 2), Mul)
+    assert ff(x**2 + 3*x, -2) == 1/((x**2 + 3*x + 1)*(x**2 + 3*x + 2))
+
+    assert ff(Poly(2*x**2 - 5*x, x), 2) == Poly(4*x**4 - 28*x**3 + 59*x**2 - 35*x, x)
+    assert isinstance(ff(Poly(2*x**2 - 5*x, x), 2), Poly)
+    raises(ValueError, lambda: ff(Poly(2*x**2 - 5*x, x, y), 2))
+    assert ff(Poly(x**2 + 3*x, x), -2) == 1/(x**4 + 12*x**3 + 49*x**2 + 78*x + 40)
+    raises(ValueError, lambda: ff(Poly(x**2 + 3*x, x, y), -2))
+
+
+    assert ff(x, m).is_integer is None
+    assert ff(n, k).is_integer is None
+    assert ff(n, m).is_integer is True
+    assert ff(n, k + pi).is_integer is False
+    assert ff(n, m + pi).is_integer is False
+    assert ff(pi, m).is_integer is False
+
+    assert isinstance(ff(x, x), ff)
+    assert ff(n, n) == factorial(n)
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+          for j in range(-5,5):
+              assert o(i, j) == r(i, j), (o, n)
+    check(x, k, ff, rf)
+    check(x, k, ff, gamma)
+    check(n, k, ff, factorial)
+    check(x, k, ff, binomial)
+    check(x, y, ff, factorial)
+    check(x, y, ff, binomial)
+
+    assert ff(x, k).rewrite(rf) == rf(x - k + 1, k)
+    assert ff(x, k).rewrite(gamma) == Piecewise(
+        (gamma(x + 1)/gamma(-k + x + 1), x >= 0),
+        ((-1)**k*gamma(k - x)/gamma(-x), True))
+    assert ff(5, k).rewrite(gamma) == 120/gamma(6 - k)
+    assert ff(n, k).rewrite(factorial) == Piecewise(
+        (factorial(n)/factorial(-k + n), n >= 0),
+        ((-1)**k*factorial(k - n - 1)/factorial(-n - 1), True))
+    assert ff(5, k).rewrite(factorial) == 120/factorial(5 - k)
+    assert ff(x, k).rewrite(binomial) == factorial(k) * binomial(x, k)
+    assert ff(x, y).rewrite(factorial) == ff(x, y)
+    assert ff(x, y).rewrite(binomial) == ff(x, y)
+
+    import random
+    from mpmath import ff as mpmath_ff
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        a = mpmath_ff(x, k)
+        b = ff(x, k)
+        assert (abs(a - b) < abs(a) * 10**(-15))
+
+
+def test_rf_ff_eval_hiprec():
+    maple = Float('6.9109401292234329956525265438452')
+    us = ff(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('6.8261540131125511557924466355367')
+    us = rf(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('34.007346127440197150854651814225')
+    us = rf(Float('4.4', 32), Float('2.2', 32));
+    assert abs(us - maple)/us < 1e-31
+
+
+def test_rf_lambdify_mpmath():
+    from sympy.utilities.lambdify import lambdify
+    x, y = symbols('x,y')
+    f = lambdify((x,y), rf(x, y), 'mpmath')
+    maple = Float('34.007346127440197')
+    us = f(4.4, 2.2)
+    assert abs(us - maple)/us < 1e-15
+
+
+def test_factorial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    r = Symbol('r', integer=False)
+    s = Symbol('s', integer=False, negative=True)
+    t = Symbol('t', nonnegative=True)
+    u = Symbol('u', noninteger=True)
+
+    assert factorial(-2) is zoo
+    assert factorial(0) == 1
+    assert factorial(7) == 5040
+    assert factorial(19) == 121645100408832000
+    assert factorial(31) == 8222838654177922817725562880000000
+    assert factorial(n).func == factorial
+    assert factorial(2*n).func == factorial
+
+    assert factorial(x).is_integer is None
+    assert factorial(n).is_integer is None
+    assert factorial(k).is_integer
+    assert factorial(r).is_integer is None
+
+    assert factorial(n).is_positive is None
+    assert factorial(k).is_positive
+
+    assert factorial(x).is_real is None
+    assert factorial(n).is_real is None
+    assert factorial(k).is_real is True
+    assert factorial(r).is_real is None
+    assert factorial(s).is_real is True
+    assert factorial(t).is_real is True
+    assert factorial(u).is_real is True
+
+    assert factorial(x).is_composite is None
+    assert factorial(n).is_composite is None
+    assert factorial(k).is_composite is None
+    assert factorial(k + 3).is_composite is True
+    assert factorial(r).is_composite is None
+    assert factorial(s).is_composite is None
+    assert factorial(t).is_composite is None
+    assert factorial(u).is_composite is None
+
+    assert factorial(oo) is oo
+
+
+def test_factorial_Mod():
+    pr = Symbol('pr', prime=True)
+    p, q = 10**9 + 9, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+    assert Mod(factorial(pr - 1), pr) == pr - 1
+    assert Mod(factorial(pr - 1), -pr) == -1
+    assert Mod(factorial(r - 1, evaluate=False), r) == 0
+    assert Mod(factorial(s - 1, evaluate=False), s) == 0
+    assert Mod(factorial(p - 1, evaluate=False), p) == p - 1
+    assert Mod(factorial(q - 1, evaluate=False), q) == q - 1
+    assert Mod(factorial(p - 50, evaluate=False), p) == 854928834
+    assert Mod(factorial(q - 1800, evaluate=False), q) == 905504050
+    assert Mod(factorial(153, evaluate=False), r) == Mod(factorial(153), r)
+    assert Mod(factorial(255, evaluate=False), s) == Mod(factorial(255), s)
+    assert Mod(factorial(4, evaluate=False), 3) == S.Zero
+    assert Mod(factorial(5, evaluate=False), 6) == S.Zero
+
+
+def test_factorial_diff():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).diff(n) == \
+        gamma(1 + n)*polygamma(0, 1 + n)
+    assert factorial(n**2).diff(n) == \
+        2*n*gamma(1 + n**2)*polygamma(0, 1 + n**2)
+    raises(ArgumentIndexError, lambda: factorial(n**2).fdiff(2))
+
+
+def test_factorial_series():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).series(n, 0, 3) == \
+        1 - n*EulerGamma + n**2*(EulerGamma**2/2 + pi**2/12) + O(n**3)
+
+
+def test_factorial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+
+    assert factorial(n).rewrite(gamma) == gamma(n + 1)
+    _i = Dummy('i')
+    assert factorial(k).rewrite(Product).dummy_eq(Product(_i, (_i, 1, k)))
+    assert factorial(n).rewrite(Product) == factorial(n)
+
+
+def test_factorial2():
+    n = Symbol('n', integer=True)
+
+    assert factorial2(-1) == 1
+    assert factorial2(0) == 1
+    assert factorial2(7) == 105
+    assert factorial2(8) == 384
+
+    # The following is exhaustive
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tte = Symbol('tte', even=True, nonnegative=True)
+    tpe = Symbol('tpe', even=True, positive=True)
+    tto = Symbol('tto', odd=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tfe = Symbol('tfe', even=True, nonnegative=False)
+    tfo = Symbol('tfo', odd=True, nonnegative=False)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('fn', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nn')
+    z = Symbol('z', zero=True)
+    #Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+    raises(ValueError, lambda: factorial2(oo))
+    raises(ValueError, lambda: factorial2(Rational(5, 2)))
+    raises(ValueError, lambda: factorial2(-4))
+    assert factorial2(n).is_integer is None
+    assert factorial2(tt - 1).is_integer
+    assert factorial2(tte - 1).is_integer
+    assert factorial2(tpe - 3).is_integer
+    assert factorial2(tto - 4).is_integer
+    assert factorial2(tto - 2).is_integer
+    assert factorial2(tf).is_integer is None
+    assert factorial2(tfe).is_integer is None
+    assert factorial2(tfo).is_integer is None
+    assert factorial2(ft).is_integer is None
+    assert factorial2(ff).is_integer is None
+    assert factorial2(fn).is_integer is None
+    assert factorial2(nt).is_integer is None
+    assert factorial2(nf).is_integer is None
+    assert factorial2(nn).is_integer is None
+
+    assert factorial2(n).is_positive is None
+    assert factorial2(tt - 1).is_positive is True
+    assert factorial2(tte - 1).is_positive is True
+    assert factorial2(tpe - 3).is_positive is True
+    assert factorial2(tpe - 1).is_positive is True
+    assert factorial2(tto - 2).is_positive is True
+    assert factorial2(tto - 1).is_positive is True
+    assert factorial2(tf).is_positive is None
+    assert factorial2(tfe).is_positive is None
+    assert factorial2(tfo).is_positive is None
+    assert factorial2(ft).is_positive is None
+    assert factorial2(ff).is_positive is None
+    assert factorial2(fn).is_positive is None
+    assert factorial2(nt).is_positive is None
+    assert factorial2(nf).is_positive is None
+    assert factorial2(nn).is_positive is None
+
+    assert factorial2(tt).is_even is None
+    assert factorial2(tt).is_odd is None
+    assert factorial2(tte).is_even is None
+    assert factorial2(tte).is_odd is None
+    assert factorial2(tte + 2).is_even is True
+    assert factorial2(tpe).is_even is True
+    assert factorial2(tpe).is_odd is False
+    assert factorial2(tto).is_odd is True
+    assert factorial2(tf).is_even is None
+    assert factorial2(tf).is_odd is None
+    assert factorial2(tfe).is_even is None
+    assert factorial2(tfe).is_odd is None
+    assert factorial2(tfo).is_even is False
+    assert factorial2(tfo).is_odd is None
+    assert factorial2(z).is_even is False
+    assert factorial2(z).is_odd is True
+
+
+def test_factorial2_rewrite():
+    n = Symbol('n', integer=True)
+    assert factorial2(n).rewrite(gamma) == \
+        2**(n/2)*Piecewise((1, Eq(Mod(n, 2), 0)), (sqrt(2)/sqrt(pi), Eq(Mod(n, 2), 1)))*gamma(n/2 + 1)
+    assert factorial2(2*n).rewrite(gamma) == 2**n*gamma(n + 1)
+    assert factorial2(2*n + 1).rewrite(gamma) == \
+        sqrt(2)*2**(n + S.Half)*gamma(n + Rational(3, 2))/sqrt(pi)
+
+
+def test_binomial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    nz = Symbol('nz', integer=True, nonzero=True)
+    k = Symbol('k', integer=True)
+    kp = Symbol('kp', integer=True, positive=True)
+    kn = Symbol('kn', integer=True, negative=True)
+    u = Symbol('u', negative=True)
+    v = Symbol('v', nonnegative=True)
+    p = Symbol('p', positive=True)
+    z = Symbol('z', zero=True)
+    nt = Symbol('nt', integer=False)
+    kt = Symbol('kt', integer=False)
+    a = Symbol('a', integer=True, nonnegative=True)
+    b = Symbol('b', integer=True, nonnegative=True)
+
+    assert binomial(0, 0) == 1
+    assert binomial(1, 1) == 1
+    assert binomial(10, 10) == 1
+    assert binomial(n, z) == 1
+    assert binomial(1, 2) == 0
+    assert binomial(-1, 2) == 1
+    assert binomial(1, -1) == 0
+    assert binomial(-1, 1) == -1
+    assert binomial(-1, -1) == 0
+    assert binomial(S.Half, S.Half) == 1
+    assert binomial(-10, 1) == -10
+    assert binomial(-10, 7) == -11440
+    assert binomial(n, -1) == 0 # holds for all integers (negative, zero, positive)
+    assert binomial(kp, -1) == 0
+    assert binomial(nz, 0) == 1
+    assert expand_func(binomial(n, 1)) == n
+    assert expand_func(binomial(n, 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 1)) == n
+    assert binomial(n, 3).func == binomial
+    assert binomial(n, 3).expand(func=True) ==  n**3/6 - n**2/2 + n/3
+    assert expand_func(binomial(n, 3)) ==  n*(n - 2)*(n - 1)/6
+    assert binomial(n, n).func == binomial # e.g. (-1, -1) == 0, (2, 2) == 1
+    assert binomial(n, n + 1).func == binomial  # e.g. (-1, 0) == 1
+    assert binomial(kp, kp + 1) == 0
+    assert binomial(kn, kn) == 0 # issue #14529
+    assert binomial(n, u).func == binomial
+    assert binomial(kp, u).func == binomial
+    assert binomial(n, p).func == binomial
+    assert binomial(n, k).func == binomial
+    assert binomial(n, n + p).func == binomial
+    assert binomial(kp, kp + p).func == binomial
+
+    assert expand_func(binomial(n, n - 3)) == n*(n - 2)*(n - 1)/6
+
+    assert binomial(n, k).is_integer
+    assert binomial(nt, k).is_integer is None
+    assert binomial(x, nt).is_integer is False
+
+    assert binomial(gamma(25), 6) == 79232165267303928292058750056084441948572511312165380965440075720159859792344339983120618959044048198214221915637090855535036339620413440000
+    assert binomial(1324, 47) == 906266255662694632984994480774946083064699457235920708992926525848438478406790323869952
+    assert binomial(1735, 43) == 190910140420204130794758005450919715396159959034348676124678207874195064798202216379800
+    assert binomial(2512, 53) == 213894469313832631145798303740098720367984955243020898718979538096223399813295457822575338958939834177325304000
+    assert binomial(3383, 52) == 27922807788818096863529701501764372757272890613101645521813434902890007725667814813832027795881839396839287659777235
+    assert binomial(4321, 51) == 124595639629264868916081001263541480185227731958274383287107643816863897851139048158022599533438936036467601690983780576
+
+    assert binomial(a, b).is_nonnegative is True
+    assert binomial(-1, 2, evaluate=False).is_nonnegative is True
+    assert binomial(10, 5, evaluate=False).is_nonnegative is True
+    assert binomial(10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 2, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 1, evaluate=False).is_nonnegative is False
+    assert binomial(-10, 7, evaluate=False).is_nonnegative is False
+
+    # issue #14625
+    for _ in (pi, -pi, nt, v, a):
+        assert binomial(_, _) == 1
+        assert binomial(_, _ - 1) == _
+    assert isinstance(binomial(u, u), binomial)
+    assert isinstance(binomial(u, u - 1), binomial)
+    assert isinstance(binomial(x, x), binomial)
+    assert isinstance(binomial(x, x - 1), binomial)
+
+    #issue #18802
+    assert expand_func(binomial(x + 1, x)) == x + 1
+    assert expand_func(binomial(x, x - 1)) == x
+    assert expand_func(binomial(x + 1, x - 1)) == x*(x + 1)/2
+    assert expand_func(binomial(x**2 + 1, x**2)) == x**2 + 1
+
+    # issue #13980 and #13981
+    assert binomial(-7, -5) == 0
+    assert binomial(-23, -12) == 0
+    assert binomial(Rational(13, 2), -10) == 0
+    assert binomial(-49, -51) == 0
+
+    assert binomial(19, Rational(-7, 2)) == S(-68719476736)/(911337863661225*pi)
+    assert binomial(0, Rational(3, 2)) == S(-2)/(3*pi)
+    assert binomial(-3, Rational(-7, 2)) is zoo
+    assert binomial(kn, kt) is zoo
+
+    assert binomial(nt, kt).func == binomial
+    assert binomial(nt, Rational(15, 6)) == 8*gamma(nt + 1)/(15*sqrt(pi)*gamma(nt - Rational(3, 2)))
+    assert binomial(Rational(20, 3), Rational(-10, 8)) == gamma(Rational(23, 3))/(gamma(Rational(-1, 4))*gamma(Rational(107, 12)))
+    assert binomial(Rational(19, 2), Rational(-7, 2)) == Rational(-1615, 8388608)
+    assert binomial(Rational(-13, 5), Rational(-7, 8)) == gamma(Rational(-8, 5))/(gamma(Rational(-29, 40))*gamma(Rational(1, 8)))
+    assert binomial(Rational(-19, 8), Rational(-13, 5)) == gamma(Rational(-11, 8))/(gamma(Rational(-8, 5))*gamma(Rational(49, 40)))
+
+    # binomial for complexes
+    assert binomial(I, Rational(-89, 8)) == gamma(1 + I)/(gamma(Rational(-81, 8))*gamma(Rational(97, 8) + I))
+    assert binomial(I, 2*I) == gamma(1 + I)/(gamma(1 - I)*gamma(1 + 2*I))
+    assert binomial(-7, I) is zoo
+    assert binomial(Rational(-7, 6), I) == gamma(Rational(-1, 6))/(gamma(Rational(-1, 6) - I)*gamma(1 + I))
+    assert binomial((1+2*I), (1+3*I)) == gamma(2 + 2*I)/(gamma(1 - I)*gamma(2 + 3*I))
+    assert binomial(I, 5) == Rational(1, 3) - I/S(12)
+    assert binomial((2*I + 3), 7) == -13*I/S(63)
+    assert isinstance(binomial(I, n), binomial)
+    assert expand_func(binomial(3, 2, evaluate=False)) == 3
+    assert expand_func(binomial(n, 0, evaluate=False)) == 1
+    assert expand_func(binomial(n, -2, evaluate=False)) == 0
+    assert expand_func(binomial(n, k)) == binomial(n, k)
+
+
+def test_binomial_Mod():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r = 10**7 + 5 # composite modulo
+
+    # A few tests to get coverage
+    # Lucas Theorem
+    assert Mod(binomial(156675, 4433, evaluate=False), p) == Mod(binomial(156675, 4433), p)
+
+    # factorial Mod
+    assert Mod(binomial(1234, 432, evaluate=False), q) == Mod(binomial(1234, 432), q)
+
+    # binomial factorize
+    assert Mod(binomial(253, 113, evaluate=False), r) == Mod(binomial(253, 113), r)
+
+
+@slow
+def test_binomial_Mod_slow():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+
+    n, k, m = symbols('n k m')
+    assert (binomial(n, k) % q).subs({n: s, k: p}) == Mod(binomial(s, p), q)
+    assert (binomial(n, k) % m).subs({n: 8, k: 5, m: 13}) == 4
+    assert (binomial(9, k) % 7).subs(k, 2) == 1
+
+    # Lucas Theorem
+    assert Mod(binomial(123456, 43253, evaluate=False), p) == Mod(binomial(123456, 43253), p)
+    assert Mod(binomial(-178911, 237, evaluate=False), p) == Mod(-binomial(178911 + 237 - 1, 237), p)
+    assert Mod(binomial(-178911, 238, evaluate=False), p) == Mod(binomial(178911 + 238 - 1, 238), p)
+
+    # factorial Mod
+    assert Mod(binomial(9734, 451, evaluate=False), q) == Mod(binomial(9734, 451), q)
+    assert Mod(binomial(-10733, 4459, evaluate=False), q) == Mod(binomial(-10733, 4459), q)
+    assert Mod(binomial(-15733, 4458, evaluate=False), q) == Mod(binomial(-15733, 4458), q)
+    assert Mod(binomial(23, -38, evaluate=False), q) is S.Zero
+    assert Mod(binomial(23, 38, evaluate=False), q) is S.Zero
+
+    # binomial factorize
+    assert Mod(binomial(753, 119, evaluate=False), r) == Mod(binomial(753, 119), r)
+    assert Mod(binomial(3781, 948, evaluate=False), s) == Mod(binomial(3781, 948), s)
+    assert Mod(binomial(25773, 1793, evaluate=False), s) == Mod(binomial(25773, 1793), s)
+    assert Mod(binomial(-753, 118, evaluate=False), r) == Mod(binomial(-753, 118), r)
+    assert Mod(binomial(-25773, 1793, evaluate=False), s) == Mod(binomial(-25773, 1793), s)
+
+
+def test_binomial_diff():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+
+    assert binomial(n, k).diff(n) == \
+        (-polygamma(0, 1 + n - k) + polygamma(0, 1 + n))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(n) == \
+        2*n*(-polygamma(
+            0, 1 + n**2 - k**3) + polygamma(0, 1 + n**2))*binomial(n**2, k**3)
+
+    assert binomial(n, k).diff(k) == \
+        (-polygamma(0, 1 + k) + polygamma(0, 1 + n - k))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(k) == \
+        3*k**2*(-polygamma(
+            0, 1 + k**3) + polygamma(0, 1 + n**2 - k**3))*binomial(n**2, k**3)
+    raises(ArgumentIndexError, lambda: binomial(n, k).fdiff(3))
+
+
+def test_binomial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+    x = Symbol('x')
+
+    assert binomial(n, k).rewrite(
+        factorial) == factorial(n)/(factorial(k)*factorial(n - k))
+    assert binomial(
+        n, k).rewrite(gamma) == gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+    assert binomial(n, k).rewrite(ff) == ff(n, k) / factorial(k)
+    assert binomial(n, x).rewrite(ff) == binomial(n, x)
+
+
+@XFAIL
+def test_factorial_simplify_fail():
+    # simplify(factorial(x + 1).diff(x) - ((x + 1)*factorial(x)).diff(x))) == 0
+    from sympy.abc import x
+    assert simplify(x*polygamma(0, x + 1) - x*polygamma(0, x + 2) +
+                    polygamma(0, x + 1) - polygamma(0, x + 2) + 1) == 0
+
+
+def test_subfactorial():
+    assert all(subfactorial(i) == ans for i, ans in enumerate(
+        [1, 0, 1, 2, 9, 44, 265, 1854, 14833, 133496]))
+    assert subfactorial(oo) is oo
+    assert subfactorial(nan) is nan
+    assert subfactorial(23) == 9510425471055777937262
+    assert unchanged(subfactorial, 2.2)
+
+    x = Symbol('x')
+    assert subfactorial(x).rewrite(uppergamma) == uppergamma(x + 1, -1)/S.Exp1
+
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tn = Symbol('tf', integer=True)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('ff', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nf')
+    te = Symbol('te', even=True, nonnegative=True)
+    to = Symbol('to', odd=True, nonnegative=True)
+    assert subfactorial(tt).is_integer
+    assert subfactorial(tf).is_integer is None
+    assert subfactorial(tn).is_integer is None
+    assert subfactorial(ft).is_integer is None
+    assert subfactorial(ff).is_integer is None
+    assert subfactorial(fn).is_integer is None
+    assert subfactorial(nt).is_integer is None
+    assert subfactorial(nf).is_integer is None
+    assert subfactorial(nn).is_integer is None
+    assert subfactorial(tt).is_nonnegative
+    assert subfactorial(tf).is_nonnegative is None
+    assert subfactorial(tn).is_nonnegative is None
+    assert subfactorial(ft).is_nonnegative is None
+    assert subfactorial(ff).is_nonnegative is None
+    assert subfactorial(fn).is_nonnegative is None
+    assert subfactorial(nt).is_nonnegative is None
+    assert subfactorial(nf).is_nonnegative is None
+    assert subfactorial(nn).is_nonnegative is None
+    assert subfactorial(tt).is_even is None
+    assert subfactorial(tt).is_odd is None
+    assert subfactorial(te).is_odd is True
+    assert subfactorial(to).is_even is True

venv/lib/python3.10/site-packages/sympy/functions/combinatorial/tests/test_comb_numbers.py

@@ -0,0 +1,852 @@
+import string
+
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.function import (diff, expand_func)
+from sympy.core import (EulerGamma, TribonacciConstant)
+from sympy.core.numbers import (Float, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.numbers import carmichael
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.integers import floor
+from sympy.polys.polytools import cancel
+from sympy.series.limits import limit, Limit
+from sympy.series.order import O
+from sympy.functions import (
+    bernoulli, harmonic, bell, fibonacci, tribonacci, lucas, euler, catalan,
+    genocchi, andre, partition, motzkin, binomial, gamma, sqrt, cbrt, hyper, log, digamma,
+    trigamma, polygamma, factorial, sin, cos, cot, polylog, zeta, dirichlet_eta)
+from sympy.functions.combinatorial.numbers import _nT
+
+from sympy.core.expr import unchanged
+from sympy.core.numbers import GoldenRatio, Integer
+
+from sympy.testing.pytest import raises, nocache_fail, warns_deprecated_sympy
+from sympy.abc import x
+
+
+def test_carmichael():
+    assert carmichael.find_carmichael_numbers_in_range(0, 561) == []
+    assert carmichael.find_carmichael_numbers_in_range(561, 562) == [561]
+    assert carmichael.find_carmichael_numbers_in_range(561, 1105) == carmichael.find_carmichael_numbers_in_range(561,
+                                                                                                                 562)
+    assert carmichael.find_first_n_carmichaels(5) == [561, 1105, 1729, 2465, 2821]
+    raises(ValueError, lambda: carmichael.is_carmichael(-2))
+    raises(ValueError, lambda: carmichael.find_carmichael_numbers_in_range(-2, 2))
+    raises(ValueError, lambda: carmichael.find_carmichael_numbers_in_range(22, 2))
+    with warns_deprecated_sympy():
+        assert carmichael.is_prime(2821) == False
+
+
+def test_bernoulli():
+    assert bernoulli(0) == 1
+    assert bernoulli(1) == Rational(1, 2)
+    assert bernoulli(2) == Rational(1, 6)
+    assert bernoulli(3) == 0
+    assert bernoulli(4) == Rational(-1, 30)
+    assert bernoulli(5) == 0
+    assert bernoulli(6) == Rational(1, 42)
+    assert bernoulli(7) == 0
+    assert bernoulli(8) == Rational(-1, 30)
+    assert bernoulli(10) == Rational(5, 66)
+    assert bernoulli(1000001) == 0
+
+    assert bernoulli(0, x) == 1
+    assert bernoulli(1, x) == x - S.Half
+    assert bernoulli(2, x) == x**2 - x + Rational(1, 6)
+    assert bernoulli(3, x) == x**3 - (3*x**2)/2 + x/2
+
+    # Should be fast; computed with mpmath
+    b = bernoulli(1000)
+    assert b.p % 10**10 == 7950421099
+    assert b.q == 342999030
+
+    b = bernoulli(10**6, evaluate=False).evalf()
+    assert str(b) == '-2.23799235765713e+4767529'
+
+    # Issue #8527
+    l = Symbol('l', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert isinstance(bernoulli(2 * l + 1), bernoulli)
+    assert isinstance(bernoulli(2 * m + 1), bernoulli)
+    assert bernoulli(2 * n + 1) == 0
+
+    assert bernoulli(x, 1) == bernoulli(x)
+
+    assert str(bernoulli(0.0, 2.3).evalf(n=10)) == '1.000000000'
+    assert str(bernoulli(1.0).evalf(n=10)) == '0.5000000000'
+    assert str(bernoulli(1.2).evalf(n=10)) == '0.4195995367'
+    assert str(bernoulli(1.2, 0.8).evalf(n=10)) == '0.2144830348'
+    assert str(bernoulli(1.2, -0.8).evalf(n=10)) == '-1.158865646 - 0.6745558744*I'
+    assert str(bernoulli(3.0, 1j).evalf(n=10)) == '1.5 - 0.5*I'
+    assert str(bernoulli(I).evalf(n=10)) == '0.9268485643 - 0.5821580598*I'
+    assert str(bernoulli(I, I).evalf(n=10)) == '0.1267792071 + 0.01947413152*I'
+    assert bernoulli(x).evalf() == bernoulli(x)
+
+
+def test_bernoulli_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol('n', integer=True, nonnegative=True)
+
+    assert bernoulli(-1).rewrite(zeta) == pi**2/6
+    assert bernoulli(-2).rewrite(zeta) == 2*zeta(3)
+    assert not bernoulli(n, -3).rewrite(zeta).has(harmonic)
+    assert bernoulli(-4, x).rewrite(zeta) == 4*zeta(5, x)
+    assert isinstance(bernoulli(n, x).rewrite(zeta), Piecewise)
+    assert bernoulli(n+1, x).rewrite(zeta) == -(n+1) * zeta(-n, x)
+
+
+def test_fibonacci():
+    assert [fibonacci(n) for n in range(-3, 5)] == [2, -1, 1, 0, 1, 1, 2, 3]
+    assert fibonacci(100) == 354224848179261915075
+    assert [lucas(n) for n in range(-3, 5)] == [-4, 3, -1, 2, 1, 3, 4, 7]
+    assert lucas(100) == 792070839848372253127
+
+    assert fibonacci(1, x) == 1
+    assert fibonacci(2, x) == x
+    assert fibonacci(3, x) == x**2 + 1
+    assert fibonacci(4, x) == x**3 + 2*x
+
+    # issue #8800
+    n = Dummy('n')
+    assert fibonacci(n).limit(n, S.Infinity) is S.Infinity
+    assert lucas(n).limit(n, S.Infinity) is S.Infinity
+
+    assert fibonacci(n).rewrite(sqrt) == \
+        2**(-n)*sqrt(5)*((1 + sqrt(5))**n - (-sqrt(5) + 1)**n) / 5
+    assert fibonacci(n).rewrite(sqrt).subs(n, 10).expand() == fibonacci(10)
+    assert fibonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(fibonacci(10))
+    assert lucas(n).rewrite(sqrt) == \
+        (fibonacci(n-1).rewrite(sqrt) + fibonacci(n+1).rewrite(sqrt)).simplify()
+    assert lucas(n).rewrite(sqrt).subs(n, 10).expand() == lucas(10)
+    raises(ValueError, lambda: fibonacci(-3, x))
+
+
+def test_tribonacci():
+    assert [tribonacci(n) for n in range(8)] == [0, 1, 1, 2, 4, 7, 13, 24]
+    assert tribonacci(100) == 98079530178586034536500564
+
+    assert tribonacci(0, x) == 0
+    assert tribonacci(1, x) == 1
+    assert tribonacci(2, x) == x**2
+    assert tribonacci(3, x) == x**4 + x
+    assert tribonacci(4, x) == x**6 + 2*x**3 + 1
+    assert tribonacci(5, x) == x**8 + 3*x**5 + 3*x**2
+
+    n = Dummy('n')
+    assert tribonacci(n).limit(n, S.Infinity) is S.Infinity
+
+    w = (-1 + S.ImaginaryUnit * sqrt(3)) / 2
+    a = (1 + cbrt(19 + 3*sqrt(33)) + cbrt(19 - 3*sqrt(33))) / 3
+    b = (1 + w*cbrt(19 + 3*sqrt(33)) + w**2*cbrt(19 - 3*sqrt(33))) / 3
+    c = (1 + w**2*cbrt(19 + 3*sqrt(33)) + w*cbrt(19 - 3*sqrt(33))) / 3
+    assert tribonacci(n).rewrite(sqrt) == \
+      (a**(n + 1)/((a - b)*(a - c))
+      + b**(n + 1)/((b - a)*(b - c))
+      + c**(n + 1)/((c - a)*(c - b)))
+    assert tribonacci(n).rewrite(sqrt).subs(n, 4).simplify() == tribonacci(4)
+    assert tribonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(tribonacci(10))
+    assert tribonacci(n).rewrite(TribonacciConstant) == floor(
+            3*TribonacciConstant**n*(102*sqrt(33) + 586)**Rational(1, 3)/
+            (-2*(102*sqrt(33) + 586)**Rational(1, 3) + 4 + (102*sqrt(33)
+            + 586)**Rational(2, 3)) + S.Half)
+    raises(ValueError, lambda: tribonacci(-1, x))
+
+
+@nocache_fail
+def test_bell():
+    assert [bell(n) for n in range(8)] == [1, 1, 2, 5, 15, 52, 203, 877]
+
+    assert bell(0, x) == 1
+    assert bell(1, x) == x
+    assert bell(2, x) == x**2 + x
+    assert bell(5, x) == x**5 + 10*x**4 + 25*x**3 + 15*x**2 + x
+    assert bell(oo) is S.Infinity
+    raises(ValueError, lambda: bell(oo, x))
+
+    raises(ValueError, lambda: bell(-1))
+    raises(ValueError, lambda: bell(S.Half))
+
+    X = symbols('x:6')
+    # X = (x0, x1, .. x5)
+    # at the same time: X[1] = x1, X[2] = x2 for standard readablity.
+    # but we must supply zero-based indexed object X[1:] = (x1, .. x5)
+
+    assert bell(6, 2, X[1:]) == 6*X[5]*X[1] + 15*X[4]*X[2] + 10*X[3]**2
+    assert bell(
+        6, 3, X[1:]) == 15*X[4]*X[1]**2 + 60*X[3]*X[2]*X[1] + 15*X[2]**3
+
+    X = (1, 10, 100, 1000, 10000)
+    assert bell(6, 2, X) == (6 + 15 + 10)*10000
+
+    X = (1, 2, 3, 3, 5)
+    assert bell(6, 2, X) == 6*5 + 15*3*2 + 10*3**2
+
+    X = (1, 2, 3, 5)
+    assert bell(6, 3, X) == 15*5 + 60*3*2 + 15*2**3
+
+    # Dobinski's formula
+    n = Symbol('n', integer=True, nonnegative=True)
+    # For large numbers, this is too slow
+    # For nonintegers, there are significant precision errors
+    for i in [0, 2, 3, 7, 13, 42, 55]:
+        # Running without the cache this is either very slow or goes into an
+        # infinite loop.
+        assert bell(i).evalf() == bell(n).rewrite(Sum).evalf(subs={n: i})
+
+    m = Symbol("m")
+    assert bell(m).rewrite(Sum) == bell(m)
+    assert bell(n, m).rewrite(Sum) == bell(n, m)
+    # issue 9184
+    n = Dummy('n')
+    assert bell(n).limit(n, S.Infinity) is S.Infinity
+
+
+def test_harmonic():
+    n = Symbol("n")
+    m = Symbol("m")
+
+    assert harmonic(n, 0) == n
+    assert harmonic(n).evalf() == harmonic(n)
+    assert harmonic(n, 1) == harmonic(n)
+    assert harmonic(1, n) == 1
+
+    assert harmonic(0, 1) == 0
+    assert harmonic(1, 1) == 1
+    assert harmonic(2, 1) == Rational(3, 2)
+    assert harmonic(3, 1) == Rational(11, 6)
+    assert harmonic(4, 1) == Rational(25, 12)
+    assert harmonic(0, 2) == 0
+    assert harmonic(1, 2) == 1
+    assert harmonic(2, 2) == Rational(5, 4)
+    assert harmonic(3, 2) == Rational(49, 36)
+    assert harmonic(4, 2) == Rational(205, 144)
+    assert harmonic(0, 3) == 0
+    assert harmonic(1, 3) == 1
+    assert harmonic(2, 3) == Rational(9, 8)
+    assert harmonic(3, 3) == Rational(251, 216)
+    assert harmonic(4, 3) == Rational(2035, 1728)
+
+    assert harmonic(oo, -1) is S.NaN
+    assert harmonic(oo, 0) is oo
+    assert harmonic(oo, S.Half) is oo
+    assert harmonic(oo, 1) is oo
+    assert harmonic(oo, 2) == (pi**2)/6
+    assert harmonic(oo, 3) == zeta(3)
+    assert harmonic(oo, Dummy(negative=True)) is S.NaN
+    ip = Dummy(integer=True, positive=True)
+    if (1/ip <= 1) is True:  #---------------------------------+
+        assert None, 'delete this if-block and the next line' #|
+    ip = Dummy(even=True, positive=True)  #--------------------+
+    assert harmonic(oo, 1/ip) is oo
+    assert harmonic(oo, 1 + ip) is zeta(1 + ip)
+
+    assert harmonic(0, m) == 0
+    assert harmonic(-1, -1) == 0
+    assert harmonic(-1, 0) == -1
+    assert harmonic(-1, 1) is S.ComplexInfinity
+    assert harmonic(-1, 2) is S.NaN
+    assert harmonic(-3, -2) == -5
+    assert harmonic(-3, -3) == 9
+
+
+def test_harmonic_rational():
+    ne = S(6)
+    no = S(5)
+    pe = S(8)
+    po = S(9)
+    qe = S(10)
+    qo = S(13)
+
+    Heee = harmonic(ne + pe/qe)
+    Aeee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(13944145, 4720968))
+
+    Heeo = harmonic(ne + pe/qo)
+    Aeeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2 - 2*log(sin(pi/13))*cos(pi*Rational(3, 13))
+             + Rational(2422020029, 702257080))
+
+    Heoe = harmonic(ne + po/qe)
+    Aeoe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(11818877030, 4286604231) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Heoo = harmonic(ne + po/qo)
+    Aeoo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(3, 13)) + Rational(11669332571, 3628714320))
+
+    Hoee = harmonic(no + pe/qe)
+    Aoee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(779405, 277704))
+
+    Hoeo = harmonic(no + pe/qo)
+    Aoeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2
+             - 2*log(sin(pi/13))*cos(pi*Rational(3, 13)) + Rational(53857323, 16331560))
+
+    Hooe = harmonic(no + po/qe)
+    Aooe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(486853480, 186374097) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Hooo = harmonic(no + po/qo)
+    Aooo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(3*pi/13) + Rational(383693479, 125128080))
+
+    H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
+    A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]
+    for h, a in zip(H, A):
+        e = expand_func(h).doit()
+        assert cancel(e/a) == 1
+        assert abs(h.n() - a.n()) < 1e-12
+
+
+def test_harmonic_evalf():
+    assert str(harmonic(1.5).evalf(n=10)) == '1.280372306'
+    assert str(harmonic(1.5, 2).evalf(n=10)) == '1.154576311'  # issue 7443
+    assert str(harmonic(4.0, -3).evalf(n=10)) == '100.0000000'
+    assert str(harmonic(7.0, 1.0).evalf(n=10)) == '2.592857143'
+    assert str(harmonic(1, pi).evalf(n=10)) == '1.000000000'
+    assert str(harmonic(2, pi).evalf(n=10)) == '1.113314732'
+    assert str(harmonic(1000.0, pi).evalf(n=10)) == '1.176241563'
+    assert str(harmonic(I).evalf(n=10)) == '0.6718659855 + 1.076674047*I'
+    assert str(harmonic(I, I).evalf(n=10)) == '-0.3970915266 + 1.9629689*I'
+
+    assert harmonic(-1.0, 1).evalf() is S.NaN
+    assert harmonic(-2.0, 2.0).evalf() is S.NaN
+
+def test_harmonic_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol("n")
+    m = Symbol("m", integer=True, positive=True)
+    x1 = Symbol("x1", positive=True)
+    x2 = Symbol("x2", negative=True)
+
+    assert harmonic(n).rewrite(digamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(trigamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(polygamma) == polygamma(0, n + 1) + EulerGamma
+
+    assert harmonic(n,3).rewrite(polygamma) == polygamma(2, n + 1)/2 - polygamma(2, 1)/2
+    assert isinstance(harmonic(n,m).rewrite(polygamma), Piecewise)
+
+    assert expand_func(harmonic(n+4)) == harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
+    assert expand_func(harmonic(n-4)) == harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n
+
+    assert harmonic(n, m).rewrite("tractable") == harmonic(n, m).rewrite(polygamma)
+    assert harmonic(n, x1).rewrite("tractable") == harmonic(n, x1)
+    assert harmonic(n, x1 + 1).rewrite("tractable") == zeta(x1 + 1) - zeta(x1 + 1, n + 1)
+    assert harmonic(n, x2).rewrite("tractable") == zeta(x2) - zeta(x2, n + 1)
+
+    _k = Dummy("k")
+    assert harmonic(n).rewrite(Sum).dummy_eq(Sum(1/_k, (_k, 1, n)))
+    assert harmonic(n, m).rewrite(Sum).dummy_eq(Sum(_k**(-m), (_k, 1, n)))
+
+
+def test_harmonic_calculus():
+    y = Symbol("y", positive=True)
+    z = Symbol("z", negative=True)
+    assert harmonic(x, 1).limit(x, 0) == 0
+    assert harmonic(x, y).limit(x, 0) == 0
+    assert harmonic(x, 1).series(x, y, 2) == \
+            harmonic(y) + (x - y)*zeta(2, y + 1) + O((x - y)**2, (x, y))
+    assert limit(harmonic(x, y), x, oo) == harmonic(oo, y)
+    assert limit(harmonic(x, y + 1), x, oo) == zeta(y + 1)
+    assert limit(harmonic(x, y - 1), x, oo) == harmonic(oo, y - 1)
+    assert limit(harmonic(x, z), x, oo) == Limit(harmonic(x, z), x, oo, dir='-')
+    assert limit(harmonic(x, z + 1), x, oo) == oo
+    assert limit(harmonic(x, z + 2), x, oo) == harmonic(oo, z + 2)
+    assert limit(harmonic(x, z - 1), x, oo) == Limit(harmonic(x, z - 1), x, oo, dir='-')
+
+
+def test_euler():
+    assert euler(0) == 1
+    assert euler(1) == 0
+    assert euler(2) == -1
+    assert euler(3) == 0
+    assert euler(4) == 5
+    assert euler(6) == -61
+    assert euler(8) == 1385
+
+    assert euler(20, evaluate=False) != 370371188237525
+
+    n = Symbol('n', integer=True)
+    assert euler(n) != -1
+    assert euler(n).subs(n, 2) == -1
+
+    assert euler(-1) == S.Pi / 2
+    assert euler(-1, 1) == 2*log(2)
+    assert euler(-2).evalf() == (2*S.Catalan).evalf()
+    assert euler(-3).evalf() == (S.Pi**3 / 16).evalf()
+    assert str(euler(2.3).evalf(n=10)) == '-1.052850274'
+    assert str(euler(1.2, 3.4).evalf(n=10)) == '3.575613489'
+    assert str(euler(I).evalf(n=10)) == '1.248446443 - 0.7675445124*I'
+    assert str(euler(I, I).evalf(n=10)) == '0.04812930469 + 0.01052411008*I'
+
+    assert euler(20).evalf() == 370371188237525.0
+    assert euler(20, evaluate=False).evalf() == 370371188237525.0
+
+    assert euler(n).rewrite(Sum) == euler(n)
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert euler(2*n + 1).rewrite(Sum) == 0
+    _j = Dummy('j')
+    _k = Dummy('k')
+    assert euler(2*n).rewrite(Sum).dummy_eq(
+            I*Sum((-1)**_j*2**(-_k)*I**(-_k)*(-2*_j + _k)**(2*n + 1)*
+                  binomial(_k, _j)/_k, (_j, 0, _k), (_k, 1, 2*n + 1)))
+
+
+def test_euler_odd():
+    n = Symbol('n', odd=True, positive=True)
+    assert euler(n) == 0
+    n = Symbol('n', odd=True)
+    assert euler(n) != 0
+
+
+def test_euler_polynomials():
+    assert euler(0, x) == 1
+    assert euler(1, x) == x - S.Half
+    assert euler(2, x) == x**2 - x
+    assert euler(3, x) == x**3 - (3*x**2)/2 + Rational(1, 4)
+    m = Symbol('m')
+    assert isinstance(euler(m, x), euler)
+    from sympy.core.numbers import Float
+    A = Float('-0.46237208575048694923364757452876131e8')  # from Maple
+    B = euler(19, S.Pi).evalf(32)
+    assert abs((A - B)/A) < 1e-31
+
+
+def test_euler_polynomial_rewrite():
+    m = Symbol('m')
+    A = euler(m, x).rewrite('Sum');
+    assert A.subs({m:3, x:5}).doit() == euler(3, 5)
+
+
+def test_catalan():
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True, positive=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    p = Symbol('p', nonnegative=True)
+
+    catalans = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786]
+    for i, c in enumerate(catalans):
+        assert catalan(i) == c
+        assert catalan(n).rewrite(factorial).subs(n, i) == c
+        assert catalan(n).rewrite(Product).subs(n, i).doit() == c
+
+    assert unchanged(catalan, x)
+    assert catalan(2*x).rewrite(binomial) == binomial(4*x, 2*x)/(2*x + 1)
+    assert catalan(S.Half).rewrite(gamma) == 8/(3*pi)
+    assert catalan(S.Half).rewrite(factorial).rewrite(gamma) ==\
+        8 / (3 * pi)
+    assert catalan(3*x).rewrite(gamma) == 4**(
+        3*x)*gamma(3*x + S.Half)/(sqrt(pi)*gamma(3*x + 2))
+    assert catalan(x).rewrite(hyper) == hyper((-x + 1, -x), (2,), 1)
+
+    assert catalan(n).rewrite(factorial) == factorial(2*n) / (factorial(n + 1)
+                                                              * factorial(n))
+    assert isinstance(catalan(n).rewrite(Product), catalan)
+    assert isinstance(catalan(m).rewrite(Product), Product)
+
+    assert diff(catalan(x), x) == (polygamma(
+        0, x + S.Half) - polygamma(0, x + 2) + log(4))*catalan(x)
+
+    assert catalan(x).evalf() == catalan(x)
+    c = catalan(S.Half).evalf()
+    assert str(c) == '0.848826363156775'
+    c = catalan(I).evalf(3)
+    assert str((re(c), im(c))) == '(0.398, -0.0209)'
+
+    # Assumptions
+    assert catalan(p).is_positive is True
+    assert catalan(k).is_integer is True
+    assert catalan(m+3).is_composite is True
+
+
+def test_genocchi():
+    genocchis = [0, -1, -1, 0, 1, 0, -3, 0, 17]
+    for n, g in enumerate(genocchis):
+        assert genocchi(n) == g
+
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert unchanged(genocchi, m)
+    assert genocchi(2*n + 1) == 0
+    gn = 2 * (1 - 2**n) * bernoulli(n)
+    assert genocchi(n).rewrite(bernoulli).factor() == gn.factor()
+    gnx = 2 * (bernoulli(n, x) - 2**n * bernoulli(n, (x+1) / 2))
+    assert genocchi(n, x).rewrite(bernoulli).factor() == gnx.factor()
+    assert genocchi(2 * n).is_odd
+    assert genocchi(2 * n).is_even is False
+    assert genocchi(2 * n + 1).is_even
+    assert genocchi(n).is_integer
+    assert genocchi(4 * n).is_positive
+    # these are the only 2 prime Genocchi numbers
+    assert genocchi(6, evaluate=False).is_prime == S(-3).is_prime
+    assert genocchi(8, evaluate=False).is_prime
+    assert genocchi(4 * n + 2).is_negative
+    assert genocchi(4 * n + 1).is_negative is False
+    assert genocchi(4 * n - 2).is_negative
+
+    g0 = genocchi(0, evaluate=False)
+    assert g0.is_positive is False
+    assert g0.is_negative is False
+    assert g0.is_even is True
+    assert g0.is_odd is False
+
+    assert genocchi(0, x) == 0
+    assert genocchi(1, x) == -1
+    assert genocchi(2, x) == 1 - 2*x
+    assert genocchi(3, x) == 3*x - 3*x**2
+    assert genocchi(4, x) == -1 + 6*x**2 - 4*x**3
+    y = Symbol("y")
+    assert genocchi(5, (x+y)**100) == -5*(x+y)**400 + 10*(x+y)**300 - 5*(x+y)**100
+
+    assert str(genocchi(5.0, 4.0).evalf(n=10)) == '-660.0000000'
+    assert str(genocchi(Rational(5, 4)).evalf(n=10)) == '-1.104286457'
+    assert str(genocchi(-2).evalf(n=10)) == '3.606170709'
+    assert str(genocchi(1.3, 3.7).evalf(n=10)) == '-1.847375373'
+    assert str(genocchi(I, 1.0).evalf(n=10)) == '-0.3161917278 - 1.45311955*I'
+
+    n = Symbol('n')
+    assert genocchi(n, x).rewrite(dirichlet_eta) == -2*n * dirichlet_eta(1-n, x)
+
+
+def test_andre():
+    nums = [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
+    for n, a in enumerate(nums):
+        assert andre(n) == a
+    assert andre(S.Infinity) == S.Infinity
+    assert andre(-1) == -log(2)
+    assert andre(-2) == -2*S.Catalan
+    assert andre(-3) == 3*zeta(3)/16
+    assert andre(-5) == -15*zeta(5)/256
+    # In fact andre(-2*n) is related to the Dirichlet *beta* function
+    # at 2*n, but SymPy doesn't implement that (or general L-functions)
+    assert unchanged(andre, -4)
+
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert unchanged(andre, n)
+    assert andre(n).is_integer is True
+    assert andre(n).is_positive is True
+
+    assert str(andre(10, evaluate=False).evalf(n=10)) == '50521.00000'
+    assert str(andre(-1, evaluate=False).evalf(n=10)) == '-0.6931471806'
+    assert str(andre(-2, evaluate=False).evalf(n=10)) == '-1.831931188'
+    assert str(andre(-4, evaluate=False).evalf(n=10)) == '1.977889103'
+    assert str(andre(I, evaluate=False).evalf(n=10)) == '2.378417833 + 0.6343322845*I'
+
+    assert andre(x).rewrite(polylog) == \
+            (-I)**(x+1) * polylog(-x, I) + I**(x+1) * polylog(-x, -I)
+    assert andre(x).rewrite(zeta) == \
+            2 * gamma(x+1) / (2*pi)**(x+1) * \
+            (zeta(x+1, Rational(1,4)) - cos(pi*x) * zeta(x+1, Rational(3,4)))
+
+
+@nocache_fail
+def test_partition():
+    partition_nums = [1, 1, 2, 3, 5, 7, 11, 15, 22]
+    for n, p in enumerate(partition_nums):
+        assert partition(n) == p
+
+    x = Symbol('x')
+    y = Symbol('y', real=True)
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, negative=True)
+    p = Symbol('p', integer=True, nonnegative=True)
+    assert partition(m).is_integer
+    assert not partition(m).is_negative
+    assert partition(m).is_nonnegative
+    assert partition(n).is_zero
+    assert partition(p).is_positive
+    assert partition(x).subs(x, 7) == 15
+    assert partition(y).subs(y, 8) == 22
+    raises(ValueError, lambda: partition(Rational(5, 4)))
+
+
+def test__nT():
+       assert [_nT(i, j) for i in range(5) for j in range(i + 2)] == [
+    1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 2, 1, 1, 0]
+       check = [_nT(10, i) for i in range(11)]
+       assert check == [0, 1, 5, 8, 9, 7, 5, 3, 2, 1, 1]
+       assert all(type(i) is int for i in check)
+       assert _nT(10, 5) == 7
+       assert _nT(100, 98) == 2
+       assert _nT(100, 100) == 1
+       assert _nT(10, 3) == 8
+
+
+def test_nC_nP_nT():
+    from sympy.utilities.iterables import (
+        multiset_permutations, multiset_combinations, multiset_partitions,
+        partitions, subsets, permutations)
+    from sympy.functions.combinatorial.numbers import (
+        nP, nC, nT, stirling, _stirling1, _stirling2, _multiset_histogram, _AOP_product)
+
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.core.random import choice
+
+    c = string.ascii_lowercase
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nP(s, i)
+                tot += check
+                assert len(list(multiset_permutations(s, i))) == check
+                if u:
+                    assert nP(len(s), i) == check
+            assert nP(s) == tot
+        except AssertionError:
+            print(s, i, 'failed perm test')
+            raise ValueError()
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nC(s, i)
+                tot += check
+                assert len(list(multiset_combinations(s, i))) == check
+                if u:
+                    assert nC(len(s), i) == check
+            assert nC(s) == tot
+            if u:
+                assert nC(len(s)) == tot
+        except AssertionError:
+            print(s, i, 'failed combo test')
+            raise ValueError()
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(i, j)
+            assert check.is_Integer
+            tot += check
+            assert sum(1 for p in partitions(i, j, size=True) if p[0] == j) == check
+        assert nT(i) == tot
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(range(i), j)
+            tot += check
+            assert len(list(multiset_partitions(list(range(i)), j))) == check
+        assert nT(range(i)) == tot
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(1, 8):
+                check = nT(s, i)
+                tot += check
+                assert len(list(multiset_partitions(s, i))) == check
+                if u:
+                    assert nT(range(len(s)), i) == check
+            if u:
+                assert nT(range(len(s))) == tot
+            assert nT(s) == tot
+        except AssertionError:
+            print(s, i, 'failed partition test')
+            raise ValueError()
+
+    # tests for Stirling numbers of the first kind that are not tested in the
+    # above
+    assert [stirling(9, i, kind=1) for i in range(11)] == [
+        0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1, 0]
+    perms = list(permutations(range(4)))
+    assert [sum(1 for p in perms if Permutation(p).cycles == i)
+            for i in range(5)] == [0, 6, 11, 6, 1] == [
+            stirling(4, i, kind=1) for i in range(5)]
+    # http://oeis.org/A008275
+    assert [stirling(n, k, signed=1)
+        for n in range(10) for k in range(1, n + 1)] == [
+            1, -1,
+            1, 2, -3,
+            1, -6, 11, -6,
+            1, 24, -50, 35, -10,
+            1, -120, 274, -225, 85, -15,
+            1, 720, -1764, 1624, -735, 175, -21,
+            1, -5040, 13068, -13132, 6769, -1960, 322, -28,
+            1, 40320, -109584, 118124, -67284, 22449, -4536, 546, -36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
+    assert  [stirling(n, k, kind=1)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 2, 3, 1,
+            0, 6, 11, 6, 1,
+            0, 24, 50, 35, 10, 1,
+            0, 120, 274, 225, 85, 15, 1,
+            0, 720, 1764, 1624, 735, 175, 21, 1,
+            0, 5040, 13068, 13132, 6769, 1960, 322, 28, 1,
+            0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
+    assert [stirling(n, k, kind=2)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 1, 3, 1,
+            0, 1, 7, 6, 1,
+            0, 1, 15, 25, 10, 1,
+            0, 1, 31, 90, 65, 15, 1,
+            0, 1, 63, 301, 350, 140, 21, 1,
+            0, 1, 127, 966, 1701, 1050, 266, 28, 1,
+            0, 1, 255, 3025, 7770, 6951, 2646, 462, 36, 1]
+    assert stirling(3, 4, kind=1) == stirling(3, 4, kind=1) == 0
+    raises(ValueError, lambda: stirling(-2, 2))
+
+    # Assertion that the return type is SymPy Integer.
+    assert isinstance(_stirling1(6, 3), Integer)
+    assert isinstance(_stirling2(6, 3), Integer)
+
+    def delta(p):
+        if len(p) == 1:
+            return oo
+        return min(abs(i[0] - i[1]) for i in subsets(p, 2))
+    parts = multiset_partitions(range(5), 3)
+    d = 2
+    assert (sum(1 for p in parts if all(delta(i) >= d for i in p)) ==
+            stirling(5, 3, d=d) == 7)
+
+    # other coverage tests
+    assert nC('abb', 2) == nC('aab', 2) == 2
+    assert nP(3, 3, replacement=True) == nP('aabc', 3, replacement=True) == 27
+    assert nP(3, 4) == 0
+    assert nP('aabc', 5) == 0
+    assert nC(4, 2, replacement=True) == nC('abcdd', 2, replacement=True) == \
+        len(list(multiset_combinations('aabbccdd', 2))) == 10
+    assert nC('abcdd') == sum(nC('abcdd', i) for i in range(6)) == 24
+    assert nC(list('abcdd'), 4) == 4
+    assert nT('aaaa') == nT(4) == len(list(partitions(4))) == 5
+    assert nT('aaab') == len(list(multiset_partitions('aaab'))) == 7
+    assert nC('aabb'*3, 3) == 4  # aaa, bbb, abb, baa
+    assert dict(_AOP_product((4,1,1,1))) == {
+        0: 1, 1: 4, 2: 7, 3: 8, 4: 8, 5: 7, 6: 4, 7: 1}
+    # the following was the first t that showed a problem in a previous form of
+    # the function, so it's not as random as it may appear
+    t = (3, 9, 4, 6, 6, 5, 5, 2, 10, 4)
+    assert sum(_AOP_product(t)[i] for i in range(55)) == 58212000
+    raises(ValueError, lambda: _multiset_histogram({1:'a'}))
+
+
+def test_PR_14617():
+    from sympy.functions.combinatorial.numbers import nT
+    for n in (0, []):
+        for k in (-1, 0, 1):
+            if k == 0:
+                assert nT(n, k) == 1
+            else:
+                assert nT(n, k) == 0
+
+
+def test_issue_8496():
+    n = Symbol("n")
+    k = Symbol("k")
+
+    raises(TypeError, lambda: catalan(n, k))
+
+
+def test_issue_8601():
+    n = Symbol('n', integer=True, negative=True)
+
+    assert catalan(n - 1) is S.Zero
+    assert catalan(Rational(-1, 2)) is S.ComplexInfinity
+    assert catalan(-S.One) == Rational(-1, 2)
+    c1 = catalan(-5.6).evalf()
+    assert str(c1) == '6.93334070531408e-5'
+    c2 = catalan(-35.4).evalf()
+    assert str(c2) == '-4.14189164517449e-24'
+
+
+def test_motzkin():
+    assert motzkin.is_motzkin(4) == True
+    assert motzkin.is_motzkin(9) == True
+    assert motzkin.is_motzkin(10) == False
+    assert motzkin.find_motzkin_numbers_in_range(10,200) == [21, 51, 127]
+    assert motzkin.find_motzkin_numbers_in_range(10,400) == [21, 51, 127, 323]
+    assert motzkin.find_motzkin_numbers_in_range(10,1600) == [21, 51, 127, 323, 835]
+    assert motzkin.find_first_n_motzkins(5) == [1, 1, 2, 4, 9]
+    assert motzkin.find_first_n_motzkins(7) == [1, 1, 2, 4, 9, 21, 51]
+    assert motzkin.find_first_n_motzkins(10) == [1, 1, 2, 4, 9, 21, 51, 127, 323, 835]
+    raises(ValueError, lambda: motzkin.eval(77.58))
+    raises(ValueError, lambda: motzkin.eval(-8))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(-2,7))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(13,7))
+    raises(ValueError, lambda: motzkin.find_first_n_motzkins(112.8))
+
+
+def test_nD_derangements():
+    from sympy.utilities.iterables import (partitions, multiset,
+        multiset_derangements, multiset_permutations)
+    from sympy.functions.combinatorial.numbers import nD
+
+    got = []
+    for i in partitions(8, k=4):
+        s = []
+        it = 0
+        for k, v in i.items():
+            for i in range(v):
+                s.extend([it]*k)
+                it += 1
+        ms = multiset(s)
+        c1 = sum(1 for i in multiset_permutations(s) if
+            all(i != j for i, j in zip(i, s)))
+        assert c1 == nD(ms) == nD(ms, 0) == nD(ms, 1)
+        v = [tuple(i) for i in multiset_derangements(s)]
+        c2 = len(v)
+        assert c2 == len(set(v))
+        assert c1 == c2
+        got.append(c1)
+    assert got == [1, 4, 6, 12, 24, 24, 61, 126, 315, 780, 297, 772,
+        2033, 5430, 14833]
+
+    assert nD('1112233456', brute=True) == nD('1112233456') == 16356
+    assert nD('') == nD([]) == nD({}) == 0
+    assert nD({1: 0}) == 0
+    raises(ValueError, lambda: nD({1: -1}))
+    assert nD('112') == 0
+    assert nD(i='112') == 0
+    assert [nD(n=i) for i in range(6)] == [0, 0, 1, 2, 9, 44]
+    assert nD((i for i in range(4))) == nD('0123') == 9
+    assert nD(m=(i for i in range(4))) == 3
+    assert nD(m={0: 1, 1: 1, 2: 1, 3: 1}) == 3
+    assert nD(m=[0, 1, 2, 3]) == 3
+    raises(TypeError, lambda: nD(m=0))
+    raises(TypeError, lambda: nD(-1))
+    assert nD({-1: 1, -2: 1}) == 1
+    assert nD(m={0: 3}) == 0
+    raises(ValueError, lambda: nD(i='123', n=3))
+    raises(ValueError, lambda: nD(i='123', m=(1,2)))
+    raises(ValueError, lambda: nD(n=0, m=(1,2)))
+    raises(ValueError, lambda: nD({1: -1}))
+    raises(ValueError, lambda: nD(m={-1: 1, 2: 1}))
+    raises(ValueError, lambda: nD(m={1: -1, 2: 1}))
+    raises(ValueError, lambda: nD(m=[-1, 2]))
+    raises(TypeError, lambda: nD({1: x}))
+    raises(TypeError, lambda: nD(m={1: x}))
+    raises(TypeError, lambda: nD(m={x: 1}))

venv/lib/python3.10/site-packages/sympy/functions/elementary/__init__.py

@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.elementary

venv/lib/python3.10/site-packages/sympy/functions/elementary/_trigonometric_special.py

@@ -0,0 +1,260 @@
+r"""A module for special angle forumlas for trigonometric functions
+
+TODO
+====
+
+This module should be developed in the future to contain direct squrae root
+representation of
+
+.. math
+    F(\frac{n}{m} \pi)
+
+for every
+
+- $m \in \{ 3, 5, 17, 257, 65537 \}$
+- $n \in \mathbb{N}$, $0 \le n < m$
+- $F \in \{\sin, \cos, \tan, \csc, \sec, \cot\}$
+
+Without multi-step rewrites
+(e.g. $\tan \to \cos/\sin \to \cos/\sqrt \to \ sqrt$)
+or using chebyshev identities
+(e.g. $\cos \to \cos + \cos^2 + \cdots \to \sqrt{} + \sqrt{}^2 + \cdots $),
+which are trivial to implement in sympy,
+and had used to give overly complicated expressions.
+
+The reference can be found below, if anyone may need help implementing them.
+
+References
+==========
+
+.. [*] Gottlieb, Christian. (1999). The Simple and straightforward construction
+   of the regular 257-gon. The Mathematical Intelligencer. 21. 31-37.
+   10.1007/BF03024829.
+.. [*] https://resources.wolframcloud.com/FunctionRepository/resources/Cos2PiOverFermatPrime
+"""
+from __future__ import annotations
+from typing import Callable
+from functools import reduce
+from sympy.core.expr import Expr
+from sympy.core.singleton import S
+from sympy.core.numbers import igcdex, Integer
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core.cache import cacheit
+
+
+def migcdex(*x: int) -> tuple[tuple[int, ...], int]:
+    r"""Compute extended gcd for multiple integers.
+
+    Explanation
+    ===========
+
+    Given the integers $x_1, \cdots, x_n$ and
+    an extended gcd for multiple arguments are defined as a solution
+    $(y_1, \cdots, y_n), g$ for the diophantine equation
+    $x_1 y_1 + \cdots + x_n y_n = g$ such that
+    $g = \gcd(x_1, \cdots, x_n)$.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary._trigonometric_special import migcdex
+    >>> migcdex()
+    ((), 0)
+    >>> migcdex(4)
+    ((1,), 4)
+    >>> migcdex(4, 6)
+    ((-1, 1), 2)
+    >>> migcdex(6, 10, 15)
+    ((1, 1, -1), 1)
+    """
+    if not x:
+        return (), 0
+
+    if len(x) == 1:
+        return (1,), x[0]
+
+    if len(x) == 2:
+        u, v, h = igcdex(x[0], x[1])
+        return (u, v), h
+
+    y, g = migcdex(*x[1:])
+    u, v, h = igcdex(x[0], g)
+    return (u, *(v * i for i in y)), h
+
+
+def ipartfrac(*denoms: int) -> tuple[int, ...]:
+    r"""Compute the the partial fraction decomposition.
+
+    Explanation
+    ===========
+
+    Given a rational number $\frac{1}{q_1 \cdots q_n}$ where all
+    $q_1, \cdots, q_n$ are pairwise coprime,
+
+    A partial fraction decomposition is defined as
+
+    .. math::
+        \frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}
+
+    And it can be derived from solving the following diophantine equation for
+    the $p_1, \cdots, p_n$
+
+    .. math::
+        1 = p_1 \prod_{i \ne 1}q_i + \cdots + p_n \prod_{i \ne n}q_i
+
+    Where $q_1, \cdots, q_n$ being pairwise coprime implies
+    $\gcd(\prod_{i \ne 1}q_i, \cdots, \prod_{i \ne n}q_i) = 1$,
+    which guarantees the existance of the solution.
+
+    It is sufficient to compute partial fraction decomposition only
+    for numerator $1$ because partial fraction decomposition for any
+    $\frac{n}{q_1 \cdots q_n}$ can be easily computed by multiplying
+    the result by $n$ afterwards.
+
+    Parameters
+    ==========
+
+    denoms : int
+        The pairwise coprime integer denominators $q_i$ which defines the
+        rational number $\frac{1}{q_1 \cdots q_n}$
+
+    Returns
+    =======
+
+    tuple[int, ...]
+        The list of numerators which semantically corresponds to $p_i$ of the
+        partial fraction decomposition
+        $\frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}$
+
+    Examples
+    ========
+
+    >>> from sympy import Rational, Mul
+    >>> from sympy.functions.elementary._trigonometric_special import ipartfrac
+
+    >>> denoms = 2, 3, 5
+    >>> numers = ipartfrac(2, 3, 5)
+    >>> numers
+    (1, 7, -14)
+
+    >>> Rational(1, Mul(*denoms))
+    1/30
+    >>> out = 0
+    >>> for n, d in zip(numers, denoms):
+    ...    out += Rational(n, d)
+    >>> out
+    1/30
+    """
+    if not denoms:
+        return ()
+
+    def mul(x: int, y: int) -> int:
+        return x * y
+
+    denom = reduce(mul, denoms)
+    a = [denom // x for x in denoms]
+    h, _ = migcdex(*a)
+    return h
+
+
+def fermat_coords(n: int) -> list[int] | None:
+    """If n can be factored in terms of Fermat primes with
+    multiplicity of each being 1, return those primes, else
+    None
+    """
+    primes = []
+    for p in [3, 5, 17, 257, 65537]:
+        quotient, remainder = divmod(n, p)
+        if remainder == 0:
+            n = quotient
+            primes.append(p)
+            if n == 1:
+                return primes
+    return None
+
+
+@cacheit
+def cos_3() -> Expr:
+    r"""Computes $\cos \frac{\pi}{3}$ in square roots"""
+    return S.Half
+
+
+@cacheit
+def cos_5() -> Expr:
+    r"""Computes $\cos \frac{\pi}{5}$ in square roots"""
+    return (sqrt(5) + 1) / 4
+
+
+@cacheit
+def cos_17() -> Expr:
+    r"""Computes $\cos \frac{\pi}{17}$ in square roots"""
+    return sqrt(
+        (15 + sqrt(17)) / 32 + sqrt(2) * (sqrt(17 - sqrt(17)) +
+        sqrt(sqrt(2) * (-8 * sqrt(17 + sqrt(17)) - (1 - sqrt(17))
+        * sqrt(17 - sqrt(17))) + 6 * sqrt(17) + 34)) / 32)
+
+
+@cacheit
+def cos_257() -> Expr:
+    r"""Computes $\cos \frac{\pi}{257}$ in square roots
+
+    References
+    ==========
+
+    .. [*] https://math.stackexchange.com/questions/516142/how-does-cos2-pi-257-look-like-in-real-radicals
+    .. [*] https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    def f1(a: Expr, b: Expr) -> tuple[Expr, Expr]:
+        return (a + sqrt(a**2 + b)) / 2, (a - sqrt(a**2 + b)) / 2
+
+    def f2(a: Expr, b: Expr) -> Expr:
+        return (a - sqrt(a**2 + b))/2
+
+    t1, t2 = f1(S.NegativeOne, Integer(256))
+    z1, z3 = f1(t1, Integer(64))
+    z2, z4 = f1(t2, Integer(64))
+    y1, y5 = f1(z1, 4*(5 + t1 + 2*z1))
+    y6, y2 = f1(z2, 4*(5 + t2 + 2*z2))
+    y3, y7 = f1(z3, 4*(5 + t1 + 2*z3))
+    y8, y4 = f1(z4, 4*(5 + t2 + 2*z4))
+    x1, x9 = f1(y1, -4*(t1 + y1 + y3 + 2*y6))
+    x2, x10 = f1(y2, -4*(t2 + y2 + y4 + 2*y7))
+    x3, x11 = f1(y3, -4*(t1 + y3 + y5 + 2*y8))
+    x4, x12 = f1(y4, -4*(t2 + y4 + y6 + 2*y1))
+    x5, x13 = f1(y5, -4*(t1 + y5 + y7 + 2*y2))
+    x6, x14 = f1(y6, -4*(t2 + y6 + y8 + 2*y3))
+    x15, x7 = f1(y7, -4*(t1 + y7 + y1 + 2*y4))
+    x8, x16 = f1(y8, -4*(t2 + y8 + y2 + 2*y5))
+    v1 = f2(x1, -4*(x1 + x2 + x3 + x6))
+    v2 = f2(x2, -4*(x2 + x3 + x4 + x7))
+    v3 = f2(x8, -4*(x8 + x9 + x10 + x13))
+    v4 = f2(x9, -4*(x9 + x10 + x11 + x14))
+    v5 = f2(x10, -4*(x10 + x11 + x12 + x15))
+    v6 = f2(x16, -4*(x16 + x1 + x2 + x5))
+    u1 = -f2(-v1, -4*(v2 + v3))
+    u2 = -f2(-v4, -4*(v5 + v6))
+    w1 = -2*f2(-u1, -4*u2)
+    return sqrt(sqrt(2)*sqrt(w1 + 4)/8 + S.Half)
+
+
+def cos_table() -> dict[int, Callable[[], Expr]]:
+    r"""Lazily evaluated table for $\cos \frac{\pi}{n}$ in square roots for
+    $n \in \{3, 5, 17, 257, 65537\}$.
+
+    Notes
+    =====
+
+    65537 is the only other known Fermat prime and it is nearly impossible to
+    build in the current SymPy due to performance issues.
+
+    References
+    ==========
+
+    https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    return {
+        3: cos_3,
+        5: cos_5,
+        17: cos_17,
+        257: cos_257
+    }

venv/lib/python3.10/site-packages/sympy/functions/elementary/benchmarks/bench_exp.py

@@ -0,0 +1,11 @@
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+
+x, y = symbols('x,y')
+
+e = exp(2*x)
+q = exp(3*x)
+
+
+def timeit_exp_subs():
+    e.subs(q, y)

venv/lib/python3.10/site-packages/sympy/functions/elementary/complexes.py

@@ -0,0 +1,1465 @@
+from typing import Tuple as tTuple
+
+from sympy.core import S, Add, Mul, sympify, Symbol, Dummy, Basic
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import (Function, Derivative, ArgumentIndexError,
+    AppliedUndef, expand_mul)
+from sympy.core.logic import fuzzy_not, fuzzy_or
+from sympy.core.numbers import pi, I, oo
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+
+###############################################################################
+######################### REAL and IMAGINARY PARTS ############################
+###############################################################################
+
+
+class re(Function):
+    """
+    Returns real part of expression. This function performs only
+    elementary analysis and so it will fail to decompose properly
+    more complicated expressions. If completely simplified result
+    is needed then use ``Basic.as_real_imag()`` or perform complex
+    expansion on instance of this function.
+
+    Examples
+    ========
+
+    >>> from sympy import re, im, I, E, symbols
+    >>> x, y = symbols('x y', real=True)
+    >>> re(2*E)
+    2*E
+    >>> re(2*I + 17)
+    17
+    >>> re(2*I)
+    0
+    >>> re(im(x) + x*I + 2)
+    2
+    >>> re(5 + I + 2)
+    7
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Real part of expression.
+
+    See Also
+    ========
+
+    im
+    """
+
+    args: tTuple[Expr]
+
+    is_extended_real = True
+    unbranched = True  # implicitly works on the projection to C
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        if arg is S.NaN:
+            return S.NaN
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif arg.is_extended_real:
+            return arg
+        elif arg.is_imaginary or (I*arg).is_extended_real:
+            return S.Zero
+        elif arg.is_Matrix:
+            return arg.as_real_imag()[0]
+        elif arg.is_Function and isinstance(arg, conjugate):
+            return re(arg.args[0])
+        else:
+
+            included, reverted, excluded = [], [], []
+            args = Add.make_args(arg)
+            for term in args:
+                coeff = term.as_coefficient(I)
+
+                if coeff is not None:
+                    if not coeff.is_extended_real:
+                        reverted.append(coeff)
+                elif not term.has(I) and term.is_extended_real:
+                    excluded.append(term)
+                else:
+                    # Try to do some advanced expansion.  If
+                    # impossible, don't try to do re(arg) again
+                    # (because this is what we are trying to do now).
+                    real_imag = term.as_real_imag(ignore=arg)
+                    if real_imag:
+                        excluded.append(real_imag[0])
+                    else:
+                        included.append(term)
+
+            if len(args) != len(included):
+                a, b, c = (Add(*xs) for xs in [included, reverted, excluded])
+
+                return cls(a) - im(b) + c
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns the real number with a zero imaginary part.
+
+        """
+        return (self, S.Zero)
+
+    def _eval_derivative(self, x):
+        if x.is_extended_real or self.args[0].is_extended_real:
+            return re(Derivative(self.args[0], x, evaluate=True))
+        if x.is_imaginary or self.args[0].is_imaginary:
+            return -I \
+                * im(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_rewrite_as_im(self, arg, **kwargs):
+        return self.args[0] - I*im(self.args[0])
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_is_zero(self):
+        # is_imaginary implies nonzero
+        return fuzzy_or([self.args[0].is_imaginary, self.args[0].is_zero])
+
+    def _eval_is_finite(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_complex(self):
+        if self.args[0].is_finite:
+            return True
+
+
+class im(Function):
+    """
+    Returns imaginary part of expression. This function performs only
+    elementary analysis and so it will fail to decompose properly more
+    complicated expressions. If completely simplified result is needed then
+    use ``Basic.as_real_imag()`` or perform complex expansion on instance of
+    this function.
+
+    Examples
+    ========
+
+    >>> from sympy import re, im, E, I
+    >>> from sympy.abc import x, y
+    >>> im(2*E)
+    0
+    >>> im(2*I + 17)
+    2
+    >>> im(x*I)
+    re(x)
+    >>> im(re(x) + y)
+    im(y)
+    >>> im(2 + 3*I)
+    3
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Imaginary part of expression.
+
+    See Also
+    ========
+
+    re
+    """
+
+    args: tTuple[Expr]
+
+    is_extended_real = True
+    unbranched = True  # implicitly works on the projection to C
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        if arg is S.NaN:
+            return S.NaN
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif arg.is_extended_real:
+            return S.Zero
+        elif arg.is_imaginary or (I*arg).is_extended_real:
+            return -I * arg
+        elif arg.is_Matrix:
+            return arg.as_real_imag()[1]
+        elif arg.is_Function and isinstance(arg, conjugate):
+            return -im(arg.args[0])
+        else:
+            included, reverted, excluded = [], [], []
+            args = Add.make_args(arg)
+            for term in args:
+                coeff = term.as_coefficient(I)
+
+                if coeff is not None:
+                    if not coeff.is_extended_real:
+                        reverted.append(coeff)
+                    else:
+                        excluded.append(coeff)
+                elif term.has(I) or not term.is_extended_real:
+                    # Try to do some advanced expansion.  If
+                    # impossible, don't try to do im(arg) again
+                    # (because this is what we are trying to do now).
+                    real_imag = term.as_real_imag(ignore=arg)
+                    if real_imag:
+                        excluded.append(real_imag[1])
+                    else:
+                        included.append(term)
+
+            if len(args) != len(included):
+                a, b, c = (Add(*xs) for xs in [included, reverted, excluded])
+
+                return cls(a) + re(b) + c
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Return the imaginary part with a zero real part.
+
+        """
+        return (self, S.Zero)
+
+    def _eval_derivative(self, x):
+        if x.is_extended_real or self.args[0].is_extended_real:
+            return im(Derivative(self.args[0], x, evaluate=True))
+        if x.is_imaginary or self.args[0].is_imaginary:
+            return -I \
+                * re(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_rewrite_as_re(self, arg, **kwargs):
+        return -I*(self.args[0] - re(self.args[0]))
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_is_zero(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_finite(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_complex(self):
+        if self.args[0].is_finite:
+            return True
+
+###############################################################################
+############### SIGN, ABSOLUTE VALUE, ARGUMENT and CONJUGATION ################
+###############################################################################
+
+class sign(Function):
+    """
+    Returns the complex sign of an expression:
+
+    Explanation
+    ===========
+
+    If the expression is real the sign will be:
+
+        * $1$ if expression is positive
+        * $0$ if expression is equal to zero
+        * $-1$ if expression is negative
+
+    If the expression is imaginary the sign will be:
+
+        * $I$ if im(expression) is positive
+        * $-I$ if im(expression) is negative
+
+    Otherwise an unevaluated expression will be returned. When evaluated, the
+    result (in general) will be ``cos(arg(expr)) + I*sin(arg(expr))``.
+
+    Examples
+    ========
+
+    >>> from sympy import sign, I
+
+    >>> sign(-1)
+    -1
+    >>> sign(0)
+    0
+    >>> sign(-3*I)
+    -I
+    >>> sign(1 + I)
+    sign(1 + I)
+    >>> _.evalf()
+    0.707106781186548 + 0.707106781186548*I
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or imaginary expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Complex sign of expression.
+
+    See Also
+    ========
+
+    Abs, conjugate
+    """
+
+    is_complex = True
+    _singularities = True
+
+    def doit(self, **hints):
+        s = super().doit()
+        if s == self and self.args[0].is_zero is False:
+            return self.args[0] / Abs(self.args[0])
+        return s
+
+    @classmethod
+    def eval(cls, arg):
+        # handle what we can
+        if arg.is_Mul:
+            c, args = arg.as_coeff_mul()
+            unk = []
+            s = sign(c)
+            for a in args:
+                if a.is_extended_negative:
+                    s = -s
+                elif a.is_extended_positive:
+                    pass
+                else:
+                    if a.is_imaginary:
+                        ai = im(a)
+                        if ai.is_comparable:  # i.e. a = I*real
+                            s *= I
+                            if ai.is_extended_negative:
+                                # can't use sign(ai) here since ai might not be
+                                # a Number
+                                s = -s
+                        else:
+                            unk.append(a)
+                    else:
+                        unk.append(a)
+            if c is S.One and len(unk) == len(args):
+                return None
+            return s * cls(arg._new_rawargs(*unk))
+        if arg is S.NaN:
+            return S.NaN
+        if arg.is_zero:  # it may be an Expr that is zero
+            return S.Zero
+        if arg.is_extended_positive:
+            return S.One
+        if arg.is_extended_negative:
+            return S.NegativeOne
+        if arg.is_Function:
+            if isinstance(arg, sign):
+                return arg
+        if arg.is_imaginary:
+            if arg.is_Pow and arg.exp is S.Half:
+                # we catch this because non-trivial sqrt args are not expanded
+                # e.g. sqrt(1-sqrt(2)) --x-->  to I*sqrt(sqrt(2) - 1)
+                return I
+            arg2 = -I * arg
+            if arg2.is_extended_positive:
+                return I
+            if arg2.is_extended_negative:
+                return -I
+
+    def _eval_Abs(self):
+        if fuzzy_not(self.args[0].is_zero):
+            return S.One
+
+    def _eval_conjugate(self):
+        return sign(conjugate(self.args[0]))
+
+    def _eval_derivative(self, x):
+        if self.args[0].is_extended_real:
+            from sympy.functions.special.delta_functions import DiracDelta
+            return 2 * Derivative(self.args[0], x, evaluate=True) \
+                * DiracDelta(self.args[0])
+        elif self.args[0].is_imaginary:
+            from sympy.functions.special.delta_functions import DiracDelta
+            return 2 * Derivative(self.args[0], x, evaluate=True) \
+                * DiracDelta(-I * self.args[0])
+
+    def _eval_is_nonnegative(self):
+        if self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_nonpositive(self):
+        if self.args[0].is_nonpositive:
+            return True
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def _eval_is_integer(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_power(self, other):
+        if (
+            fuzzy_not(self.args[0].is_zero) and
+            other.is_integer and
+            other.is_even
+        ):
+            return S.One
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg0 = self.args[0]
+        x0 = arg0.subs(x, 0)
+        if x0 != 0:
+            return self.func(x0)
+        if cdir != 0:
+            cdir = arg0.dir(x, cdir)
+        return -S.One if re(cdir) < 0 else S.One
+
+    def _eval_rewrite_as_Piecewise(self, arg, **kwargs):
+        if arg.is_extended_real:
+            return Piecewise((1, arg > 0), (-1, arg < 0), (0, True))
+
+    def _eval_rewrite_as_Heaviside(self, arg, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        if arg.is_extended_real:
+            return Heaviside(arg) * 2 - 1
+
+    def _eval_rewrite_as_Abs(self, arg, **kwargs):
+        return Piecewise((0, Eq(arg, 0)), (arg / Abs(arg), True))
+
+    def _eval_simplify(self, **kwargs):
+        return self.func(factor_terms(self.args[0]))  # XXX include doit?
+
+
+class Abs(Function):
+    """
+    Return the absolute value of the argument.
+
+    Explanation
+    ===========
+
+    This is an extension of the built-in function ``abs()`` to accept symbolic
+    values.  If you pass a SymPy expression to the built-in ``abs()``, it will
+    pass it automatically to ``Abs()``.
+
+    Examples
+    ========
+
+    >>> from sympy import Abs, Symbol, S, I
+    >>> Abs(-1)
+    1
+    >>> x = Symbol('x', real=True)
+    >>> Abs(-x)
+    Abs(x)
+    >>> Abs(x**2)
+    x**2
+    >>> abs(-x) # The Python built-in
+    Abs(x)
+    >>> Abs(3*x + 2*I)
+    sqrt(9*x**2 + 4)
+    >>> Abs(8*I)
+    8
+
+    Note that the Python built-in will return either an Expr or int depending on
+    the argument::
+
+        >>> type(abs(-1))
+        <... 'int'>
+        >>> type(abs(S.NegativeOne))
+        <class 'sympy.core.numbers.One'>
+
+    Abs will always return a SymPy object.
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Absolute value returned can be an expression or integer depending on
+        input arg.
+
+    See Also
+    ========
+
+    sign, conjugate
+    """
+
+    args: tTuple[Expr]
+
+    is_extended_real = True
+    is_extended_negative = False
+    is_extended_nonnegative = True
+    unbranched = True
+    _singularities = True  # non-holomorphic
+
+    def fdiff(self, argindex=1):
+        """
+        Get the first derivative of the argument to Abs().
+
+        """
+        if argindex == 1:
+            return sign(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.simplify.simplify import signsimp
+
+        if hasattr(arg, '_eval_Abs'):
+            obj = arg._eval_Abs()
+            if obj is not None:
+                return obj
+        if not isinstance(arg, Expr):
+            raise TypeError("Bad argument type for Abs(): %s" % type(arg))
+
+        # handle what we can
+        arg = signsimp(arg, evaluate=False)
+        n, d = arg.as_numer_denom()
+        if d.free_symbols and not n.free_symbols:
+            return cls(n)/cls(d)
+
+        if arg.is_Mul:
+            known = []
+            unk = []
+            for t in arg.args:
+                if t.is_Pow and t.exp.is_integer and t.exp.is_negative:
+                    bnew = cls(t.base)
+                    if isinstance(bnew, cls):
+                        unk.append(t)
+                    else:
+                        known.append(Pow(bnew, t.exp))
+                else:
+                    tnew = cls(t)
+                    if isinstance(tnew, cls):
+                        unk.append(t)
+                    else:
+                        known.append(tnew)
+            known = Mul(*known)
+            unk = cls(Mul(*unk), evaluate=False) if unk else S.One
+            return known*unk
+        if arg is S.NaN:
+            return S.NaN
+        if arg is S.ComplexInfinity:
+            return oo
+        from sympy.functions.elementary.exponential import exp, log
+
+        if arg.is_Pow:
+            base, exponent = arg.as_base_exp()
+            if base.is_extended_real:
+                if exponent.is_integer:
+                    if exponent.is_even:
+                        return arg
+                    if base is S.NegativeOne:
+                        return S.One
+                    return Abs(base)**exponent
+                if base.is_extended_nonnegative:
+                    return base**re(exponent)
+                if base.is_extended_negative:
+                    return (-base)**re(exponent)*exp(-pi*im(exponent))
+                return
+            elif not base.has(Symbol): # complex base
+                # express base**exponent as exp(exponent*log(base))
+                a, b = log(base).as_real_imag()
+                z = a + I*b
+                return exp(re(exponent*z))
+        if isinstance(arg, exp):
+            return exp(re(arg.args[0]))
+        if isinstance(arg, AppliedUndef):
+            if arg.is_positive:
+                return arg
+            elif arg.is_negative:
+                return -arg
+            return
+        if arg.is_Add and arg.has(oo, S.NegativeInfinity):
+            if any(a.is_infinite for a in arg.as_real_imag()):
+                return oo
+        if arg.is_zero:
+            return S.Zero
+        if arg.is_extended_nonnegative:
+            return arg
+        if arg.is_extended_nonpositive:
+            return -arg
+        if arg.is_imaginary:
+            arg2 = -I * arg
+            if arg2.is_extended_nonnegative:
+                return arg2
+        if arg.is_extended_real:
+            return
+        # reject result if all new conjugates are just wrappers around
+        # an expression that was already in the arg
+        conj = signsimp(arg.conjugate(), evaluate=False)
+        new_conj = conj.atoms(conjugate) - arg.atoms(conjugate)
+        if new_conj and all(arg.has(i.args[0]) for i in new_conj):
+            return
+        if arg != conj and arg != -conj:
+            ignore = arg.atoms(Abs)
+            abs_free_arg = arg.xreplace({i: Dummy(real=True) for i in ignore})
+            unk = [a for a in abs_free_arg.free_symbols if a.is_extended_real is None]
+            if not unk or not all(conj.has(conjugate(u)) for u in unk):
+                return sqrt(expand_mul(arg*conj))
+
+    def _eval_is_real(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_integer(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_integer
+
+    def _eval_is_extended_nonzero(self):
+        return fuzzy_not(self._args[0].is_zero)
+
+    def _eval_is_zero(self):
+        return self._args[0].is_zero
+
+    def _eval_is_extended_positive(self):
+        return fuzzy_not(self._args[0].is_zero)
+
+    def _eval_is_rational(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_rational
+
+    def _eval_is_even(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_even
+
+    def _eval_is_odd(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_odd
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_power(self, exponent):
+        if self.args[0].is_extended_real and exponent.is_integer:
+            if exponent.is_even:
+                return self.args[0]**exponent
+            elif exponent is not S.NegativeOne and exponent.is_Integer:
+                return self.args[0]**(exponent - 1)*self
+        return
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.functions.elementary.exponential import log
+        direction = self.args[0].leadterm(x)[0]
+        if direction.has(log(x)):
+            direction = direction.subs(log(x), logx)
+        s = self.args[0]._eval_nseries(x, n=n, logx=logx)
+        return (sign(direction)*s).expand()
+
+    def _eval_derivative(self, x):
+        if self.args[0].is_extended_real or self.args[0].is_imaginary:
+            return Derivative(self.args[0], x, evaluate=True) \
+                * sign(conjugate(self.args[0]))
+        rv = (re(self.args[0]) * Derivative(re(self.args[0]), x,
+            evaluate=True) + im(self.args[0]) * Derivative(im(self.args[0]),
+                x, evaluate=True)) / Abs(self.args[0])
+        return rv.rewrite(sign)
+
+    def _eval_rewrite_as_Heaviside(self, arg, **kwargs):
+        # Note this only holds for real arg (since Heaviside is not defined
+        # for complex arguments).
+        from sympy.functions.special.delta_functions import Heaviside
+        if arg.is_extended_real:
+            return arg*(Heaviside(arg) - Heaviside(-arg))
+
+    def _eval_rewrite_as_Piecewise(self, arg, **kwargs):
+        if arg.is_extended_real:
+            return Piecewise((arg, arg >= 0), (-arg, True))
+        elif arg.is_imaginary:
+            return Piecewise((I*arg, I*arg >= 0), (-I*arg, True))
+
+    def _eval_rewrite_as_sign(self, arg, **kwargs):
+        return arg/sign(arg)
+
+    def _eval_rewrite_as_conjugate(self, arg, **kwargs):
+        return sqrt(arg*conjugate(arg))
+
+
+class arg(Function):
+    r"""
+    Returns the argument (in radians) of a complex number. The argument is
+    evaluated in consistent convention with ``atan2`` where the branch-cut is
+    taken along the negative real axis and ``arg(z)`` is in the interval
+    $(-\pi,\pi]$. For a positive number, the argument is always 0; the
+    argument of a negative number is $\pi$; and the argument of 0
+    is undefined and returns ``nan``. So the ``arg`` function will never nest
+    greater than 3 levels since at the 4th application, the result must be
+    nan; for a real number, nan is returned on the 3rd application.
+
+    Examples
+    ========
+
+    >>> from sympy import arg, I, sqrt, Dummy
+    >>> from sympy.abc import x
+    >>> arg(2.0)
+    0
+    >>> arg(I)
+    pi/2
+    >>> arg(sqrt(2) + I*sqrt(2))
+    pi/4
+    >>> arg(sqrt(3)/2 + I/2)
+    pi/6
+    >>> arg(4 + 3*I)
+    atan(3/4)
+    >>> arg(0.8 + 0.6*I)
+    0.643501108793284
+    >>> arg(arg(arg(arg(x))))
+    nan
+    >>> real = Dummy(real=True)
+    >>> arg(arg(arg(real)))
+    nan
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    value : Expr
+        Returns arc tangent of arg measured in radians.
+
+    """
+
+    is_extended_real = True
+    is_real = True
+    is_finite = True
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        a = arg
+        for i in range(3):
+            if isinstance(a, cls):
+                a = a.args[0]
+            else:
+                if i == 2 and a.is_extended_real:
+                    return S.NaN
+                break
+        else:
+            return S.NaN
+        from sympy.functions.elementary.exponential import exp_polar
+        if isinstance(arg, exp_polar):
+            return periodic_argument(arg, oo)
+        if not arg.is_Atom:
+            c, arg_ = factor_terms(arg).as_coeff_Mul()
+            if arg_.is_Mul:
+                arg_ = Mul(*[a if (sign(a) not in (-1, 1)) else
+                    sign(a) for a in arg_.args])
+            arg_ = sign(c)*arg_
+        else:
+            arg_ = arg
+        if any(i.is_extended_positive is None for i in arg_.atoms(AppliedUndef)):
+            return
+        from sympy.functions.elementary.trigonometric import atan2
+        x, y = arg_.as_real_imag()
+        rv = atan2(y, x)
+        if rv.is_number:
+            return rv
+        if arg_ != arg:
+            return cls(arg_, evaluate=False)
+
+    def _eval_derivative(self, t):
+        x, y = self.args[0].as_real_imag()
+        return (x * Derivative(y, t, evaluate=True) - y *
+                    Derivative(x, t, evaluate=True)) / (x**2 + y**2)
+
+    def _eval_rewrite_as_atan2(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import atan2
+        x, y = self.args[0].as_real_imag()
+        return atan2(y, x)
+
+
+class conjugate(Function):
+    """
+    Returns the *complex conjugate* [1]_ of an argument.
+    In mathematics, the complex conjugate of a complex number
+    is given by changing the sign of the imaginary part.
+
+    Thus, the conjugate of the complex number
+    :math:`a + ib` (where $a$ and $b$ are real numbers) is :math:`a - ib`
+
+    Examples
+    ========
+
+    >>> from sympy import conjugate, I
+    >>> conjugate(2)
+    2
+    >>> conjugate(I)
+    -I
+    >>> conjugate(3 + 2*I)
+    3 - 2*I
+    >>> conjugate(5 - I)
+    5 + I
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    arg : Expr
+        Complex conjugate of arg as real, imaginary or mixed expression.
+
+    See Also
+    ========
+
+    sign, Abs
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Complex_conjugation
+    """
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_conjugate()
+        if obj is not None:
+            return obj
+
+    def inverse(self):
+        return conjugate
+
+    def _eval_Abs(self):
+        return Abs(self.args[0], evaluate=True)
+
+    def _eval_adjoint(self):
+        return transpose(self.args[0])
+
+    def _eval_conjugate(self):
+        return self.args[0]
+
+    def _eval_derivative(self, x):
+        if x.is_real:
+            return conjugate(Derivative(self.args[0], x, evaluate=True))
+        elif x.is_imaginary:
+            return -conjugate(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_transpose(self):
+        return adjoint(self.args[0])
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+
+class transpose(Function):
+    """
+    Linear map transposition.
+
+    Examples
+    ========
+
+    >>> from sympy import transpose, Matrix, MatrixSymbol
+    >>> A = MatrixSymbol('A', 25, 9)
+    >>> transpose(A)
+    A.T
+    >>> B = MatrixSymbol('B', 9, 22)
+    >>> transpose(B)
+    B.T
+    >>> transpose(A*B)
+    B.T*A.T
+    >>> M = Matrix([[4, 5], [2, 1], [90, 12]])
+    >>> M
+    Matrix([
+    [ 4,  5],
+    [ 2,  1],
+    [90, 12]])
+    >>> transpose(M)
+    Matrix([
+    [4, 2, 90],
+    [5, 1, 12]])
+
+    Parameters
+    ==========
+
+    arg : Matrix
+         Matrix or matrix expression to take the transpose of.
+
+    Returns
+    =======
+
+    value : Matrix
+        Transpose of arg.
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_transpose()
+        if obj is not None:
+            return obj
+
+    def _eval_adjoint(self):
+        return conjugate(self.args[0])
+
+    def _eval_conjugate(self):
+        return adjoint(self.args[0])
+
+    def _eval_transpose(self):
+        return self.args[0]
+
+
+class adjoint(Function):
+    """
+    Conjugate transpose or Hermite conjugation.
+
+    Examples
+    ========
+
+    >>> from sympy import adjoint, MatrixSymbol
+    >>> A = MatrixSymbol('A', 10, 5)
+    >>> adjoint(A)
+    Adjoint(A)
+
+    Parameters
+    ==========
+
+    arg : Matrix
+        Matrix or matrix expression to take the adjoint of.
+
+    Returns
+    =======
+
+    value : Matrix
+        Represents the conjugate transpose or Hermite
+        conjugation of arg.
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_adjoint()
+        if obj is not None:
+            return obj
+        obj = arg._eval_transpose()
+        if obj is not None:
+            return conjugate(obj)
+
+    def _eval_adjoint(self):
+        return self.args[0]
+
+    def _eval_conjugate(self):
+        return transpose(self.args[0])
+
+    def _eval_transpose(self):
+        return conjugate(self.args[0])
+
+    def _latex(self, printer, exp=None, *args):
+        arg = printer._print(self.args[0])
+        tex = r'%s^{\dagger}' % arg
+        if exp:
+            tex = r'\left(%s\right)^{%s}' % (tex, exp)
+        return tex
+
+    def _pretty(self, printer, *args):
+        from sympy.printing.pretty.stringpict import prettyForm
+        pform = printer._print(self.args[0], *args)
+        if printer._use_unicode:
+            pform = pform**prettyForm('\N{DAGGER}')
+        else:
+            pform = pform**prettyForm('+')
+        return pform
+
+###############################################################################
+############### HANDLING OF POLAR NUMBERS #####################################
+###############################################################################
+
+
+class polar_lift(Function):
+    """
+    Lift argument to the Riemann surface of the logarithm, using the
+    standard branch.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, polar_lift, I
+    >>> p = Symbol('p', polar=True)
+    >>> x = Symbol('x')
+    >>> polar_lift(4)
+    4*exp_polar(0)
+    >>> polar_lift(-4)
+    4*exp_polar(I*pi)
+    >>> polar_lift(-I)
+    exp_polar(-I*pi/2)
+    >>> polar_lift(I + 2)
+    polar_lift(2 + I)
+
+    >>> polar_lift(4*x)
+    4*polar_lift(x)
+    >>> polar_lift(4*p)
+    4*p
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    periodic_argument
+    """
+
+    is_polar = True
+    is_comparable = False  # Cannot be evalf'd.
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.functions.elementary.complexes import arg as argument
+        if arg.is_number:
+            ar = argument(arg)
+            # In general we want to affirm that something is known,
+            # e.g. `not ar.has(argument) and not ar.has(atan)`
+            # but for now we will just be more restrictive and
+            # see that it has evaluated to one of the known values.
+            if ar in (0, pi/2, -pi/2, pi):
+                from sympy.functions.elementary.exponential import exp_polar
+                return exp_polar(I*ar)*abs(arg)
+
+        if arg.is_Mul:
+            args = arg.args
+        else:
+            args = [arg]
+        included = []
+        excluded = []
+        positive = []
+        for arg in args:
+            if arg.is_polar:
+                included += [arg]
+            elif arg.is_positive:
+                positive += [arg]
+            else:
+                excluded += [arg]
+        if len(excluded) < len(args):
+            if excluded:
+                return Mul(*(included + positive))*polar_lift(Mul(*excluded))
+            elif included:
+                return Mul(*(included + positive))
+            else:
+                from sympy.functions.elementary.exponential import exp_polar
+                return Mul(*positive)*exp_polar(0)
+
+    def _eval_evalf(self, prec):
+        """ Careful! any evalf of polar numbers is flaky """
+        return self.args[0]._eval_evalf(prec)
+
+    def _eval_Abs(self):
+        return Abs(self.args[0], evaluate=True)
+
+
+class periodic_argument(Function):
+    r"""
+    Represent the argument on a quotient of the Riemann surface of the
+    logarithm. That is, given a period $P$, always return a value in
+    $(-P/2, P/2]$, by using $\exp(PI) = 1$.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, periodic_argument
+    >>> from sympy import I, pi
+    >>> periodic_argument(exp_polar(10*I*pi), 2*pi)
+    0
+    >>> periodic_argument(exp_polar(5*I*pi), 4*pi)
+    pi
+    >>> from sympy import exp_polar, periodic_argument
+    >>> from sympy import I, pi
+    >>> periodic_argument(exp_polar(5*I*pi), 2*pi)
+    pi
+    >>> periodic_argument(exp_polar(5*I*pi), 3*pi)
+    -pi
+    >>> periodic_argument(exp_polar(5*I*pi), pi)
+    0
+
+    Parameters
+    ==========
+
+    ar : Expr
+        A polar number.
+
+    period : Expr
+        The period $P$.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    polar_lift : Lift argument to the Riemann surface of the logarithm
+    principal_branch
+    """
+
+    @classmethod
+    def _getunbranched(cls, ar):
+        from sympy.functions.elementary.exponential import exp_polar, log
+        if ar.is_Mul:
+            args = ar.args
+        else:
+            args = [ar]
+        unbranched = 0
+        for a in args:
+            if not a.is_polar:
+                unbranched += arg(a)
+            elif isinstance(a, exp_polar):
+                unbranched += a.exp.as_real_imag()[1]
+            elif a.is_Pow:
+                re, im = a.exp.as_real_imag()
+                unbranched += re*unbranched_argument(
+                    a.base) + im*log(abs(a.base))
+            elif isinstance(a, polar_lift):
+                unbranched += arg(a.args[0])
+            else:
+                return None
+        return unbranched
+
+    @classmethod
+    def eval(cls, ar, period):
+        # Our strategy is to evaluate the argument on the Riemann surface of the
+        # logarithm, and then reduce.
+        # NOTE evidently this means it is a rather bad idea to use this with
+        # period != 2*pi and non-polar numbers.
+        if not period.is_extended_positive:
+            return None
+        if period == oo and isinstance(ar, principal_branch):
+            return periodic_argument(*ar.args)
+        if isinstance(ar, polar_lift) and period >= 2*pi:
+            return periodic_argument(ar.args[0], period)
+        if ar.is_Mul:
+            newargs = [x for x in ar.args if not x.is_positive]
+            if len(newargs) != len(ar.args):
+                return periodic_argument(Mul(*newargs), period)
+        unbranched = cls._getunbranched(ar)
+        if unbranched is None:
+            return None
+        from sympy.functions.elementary.trigonometric import atan, atan2
+        if unbranched.has(periodic_argument, atan2, atan):
+            return None
+        if period == oo:
+            return unbranched
+        if period != oo:
+            from sympy.functions.elementary.integers import ceiling
+            n = ceiling(unbranched/period - S.Half)*period
+            if not n.has(ceiling):
+                return unbranched - n
+
+    def _eval_evalf(self, prec):
+        z, period = self.args
+        if period == oo:
+            unbranched = periodic_argument._getunbranched(z)
+            if unbranched is None:
+                return self
+            return unbranched._eval_evalf(prec)
+        ub = periodic_argument(z, oo)._eval_evalf(prec)
+        from sympy.functions.elementary.integers import ceiling
+        return (ub - ceiling(ub/period - S.Half)*period)._eval_evalf(prec)
+
+
+def unbranched_argument(arg):
+    '''
+    Returns periodic argument of arg with period as infinity.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, unbranched_argument
+    >>> from sympy import I, pi
+    >>> unbranched_argument(exp_polar(15*I*pi))
+    15*pi
+    >>> unbranched_argument(exp_polar(7*I*pi))
+    7*pi
+
+    See also
+    ========
+
+    periodic_argument
+    '''
+    return periodic_argument(arg, oo)
+
+
+class principal_branch(Function):
+    """
+    Represent a polar number reduced to its principal branch on a quotient
+    of the Riemann surface of the logarithm.
+
+    Explanation
+    ===========
+
+    This is a function of two arguments. The first argument is a polar
+    number `z`, and the second one a positive real number or infinity, `p`.
+    The result is ``z mod exp_polar(I*p)``.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, principal_branch, oo, I, pi
+    >>> from sympy.abc import z
+    >>> principal_branch(z, oo)
+    z
+    >>> principal_branch(exp_polar(2*pi*I)*3, 2*pi)
+    3*exp_polar(0)
+    >>> principal_branch(exp_polar(2*pi*I)*3*z, 2*pi)
+    3*principal_branch(z, 2*pi)
+
+    Parameters
+    ==========
+
+    x : Expr
+        A polar number.
+
+    period : Expr
+        Positive real number or infinity.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    polar_lift : Lift argument to the Riemann surface of the logarithm
+    periodic_argument
+    """
+
+    is_polar = True
+    is_comparable = False  # cannot always be evalf'd
+
+    @classmethod
+    def eval(self, x, period):
+        from sympy.functions.elementary.exponential import exp_polar
+        if isinstance(x, polar_lift):
+            return principal_branch(x.args[0], period)
+        if period == oo:
+            return x
+        ub = periodic_argument(x, oo)
+        barg = periodic_argument(x, period)
+        if ub != barg and not ub.has(periodic_argument) \
+                and not barg.has(periodic_argument):
+            pl = polar_lift(x)
+
+            def mr(expr):
+                if not isinstance(expr, Symbol):
+                    return polar_lift(expr)
+                return expr
+            pl = pl.replace(polar_lift, mr)
+            # Recompute unbranched argument
+            ub = periodic_argument(pl, oo)
+            if not pl.has(polar_lift):
+                if ub != barg:
+                    res = exp_polar(I*(barg - ub))*pl
+                else:
+                    res = pl
+                if not res.is_polar and not res.has(exp_polar):
+                    res *= exp_polar(0)
+                return res
+
+        if not x.free_symbols:
+            c, m = x, ()
+        else:
+            c, m = x.as_coeff_mul(*x.free_symbols)
+        others = []
+        for y in m:
+            if y.is_positive:
+                c *= y
+            else:
+                others += [y]
+        m = tuple(others)
+        arg = periodic_argument(c, period)
+        if arg.has(periodic_argument):
+            return None
+        if arg.is_number and (unbranched_argument(c) != arg or
+                              (arg == 0 and m != () and c != 1)):
+            if arg == 0:
+                return abs(c)*principal_branch(Mul(*m), period)
+            return principal_branch(exp_polar(I*arg)*Mul(*m), period)*abs(c)
+        if arg.is_number and ((abs(arg) < period/2) == True or arg == period/2) \
+                and m == ():
+            return exp_polar(arg*I)*abs(c)
+
+    def _eval_evalf(self, prec):
+        z, period = self.args
+        p = periodic_argument(z, period)._eval_evalf(prec)
+        if abs(p) > pi or p == -pi:
+            return self  # Cannot evalf for this argument.
+        from sympy.functions.elementary.exponential import exp
+        return (abs(z)*exp(I*p))._eval_evalf(prec)
+
+
+def _polarify(eq, lift, pause=False):
+    from sympy.integrals.integrals import Integral
+    if eq.is_polar:
+        return eq
+    if eq.is_number and not pause:
+        return polar_lift(eq)
+    if isinstance(eq, Symbol) and not pause and lift:
+        return polar_lift(eq)
+    elif eq.is_Atom:
+        return eq
+    elif eq.is_Add:
+        r = eq.func(*[_polarify(arg, lift, pause=True) for arg in eq.args])
+        if lift:
+            return polar_lift(r)
+        return r
+    elif eq.is_Pow and eq.base == S.Exp1:
+        return eq.func(S.Exp1, _polarify(eq.exp, lift, pause=False))
+    elif eq.is_Function:
+        return eq.func(*[_polarify(arg, lift, pause=False) for arg in eq.args])
+    elif isinstance(eq, Integral):
+        # Don't lift the integration variable
+        func = _polarify(eq.function, lift, pause=pause)
+        limits = []
+        for limit in eq.args[1:]:
+            var = _polarify(limit[0], lift=False, pause=pause)
+            rest = _polarify(limit[1:], lift=lift, pause=pause)
+            limits.append((var,) + rest)
+        return Integral(*((func,) + tuple(limits)))
+    else:
+        return eq.func(*[_polarify(arg, lift, pause=pause)
+                         if isinstance(arg, Expr) else arg for arg in eq.args])
+
+
+def polarify(eq, subs=True, lift=False):
+    """
+    Turn all numbers in eq into their polar equivalents (under the standard
+    choice of argument).
+
+    Note that no attempt is made to guess a formal convention of adding
+    polar numbers, expressions like $1 + x$ will generally not be altered.
+
+    Note also that this function does not promote ``exp(x)`` to ``exp_polar(x)``.
+
+    If ``subs`` is ``True``, all symbols which are not already polar will be
+    substituted for polar dummies; in this case the function behaves much
+    like :func:`~.posify`.
+
+    If ``lift`` is ``True``, both addition statements and non-polar symbols are
+    changed to their ``polar_lift()``ed versions.
+    Note that ``lift=True`` implies ``subs=False``.
+
+    Examples
+    ========
+
+    >>> from sympy import polarify, sin, I
+    >>> from sympy.abc import x, y
+    >>> expr = (-x)**y
+    >>> expr.expand()
+    (-x)**y
+    >>> polarify(expr)
+    ((_x*exp_polar(I*pi))**_y, {_x: x, _y: y})
+    >>> polarify(expr)[0].expand()
+    _x**_y*exp_polar(_y*I*pi)
+    >>> polarify(x, lift=True)
+    polar_lift(x)
+    >>> polarify(x*(1+y), lift=True)
+    polar_lift(x)*polar_lift(y + 1)
+
+    Adds are treated carefully:
+
+    >>> polarify(1 + sin((1 + I)*x))
+    (sin(_x*polar_lift(1 + I)) + 1, {_x: x})
+    """
+    if lift:
+        subs = False
+    eq = _polarify(sympify(eq), lift)
+    if not subs:
+        return eq
+    reps = {s: Dummy(s.name, polar=True) for s in eq.free_symbols}
+    eq = eq.subs(reps)
+    return eq, {r: s for s, r in reps.items()}
+
+
+def _unpolarify(eq, exponents_only, pause=False):
+    if not isinstance(eq, Basic) or eq.is_Atom:
+        return eq
+
+    if not pause:
+        from sympy.functions.elementary.exponential import exp, exp_polar
+        if isinstance(eq, exp_polar):
+            return exp(_unpolarify(eq.exp, exponents_only))
+        if isinstance(eq, principal_branch) and eq.args[1] == 2*pi:
+            return _unpolarify(eq.args[0], exponents_only)
+        if (
+            eq.is_Add or eq.is_Mul or eq.is_Boolean or
+            eq.is_Relational and (
+                eq.rel_op in ('==', '!=') and 0 in eq.args or
+                eq.rel_op not in ('==', '!='))
+        ):
+            return eq.func(*[_unpolarify(x, exponents_only) for x in eq.args])
+        if isinstance(eq, polar_lift):
+            return _unpolarify(eq.args[0], exponents_only)
+
+    if eq.is_Pow:
+        expo = _unpolarify(eq.exp, exponents_only)
+        base = _unpolarify(eq.base, exponents_only,
+            not (expo.is_integer and not pause))
+        return base**expo
+
+    if eq.is_Function and getattr(eq.func, 'unbranched', False):
+        return eq.func(*[_unpolarify(x, exponents_only, exponents_only)
+            for x in eq.args])
+
+    return eq.func(*[_unpolarify(x, exponents_only, True) for x in eq.args])
+
+
+def unpolarify(eq, subs=None, exponents_only=False):
+    """
+    If `p` denotes the projection from the Riemann surface of the logarithm to
+    the complex line, return a simplified version `eq'` of `eq` such that
+    `p(eq') = p(eq)`.
+    Also apply the substitution subs in the end. (This is a convenience, since
+    ``unpolarify``, in a certain sense, undoes :func:`polarify`.)
+
+    Examples
+    ========
+
+    >>> from sympy import unpolarify, polar_lift, sin, I
+    >>> unpolarify(polar_lift(I + 2))
+    2 + I
+    >>> unpolarify(sin(polar_lift(I + 7)))
+    sin(7 + I)
+    """
+    if isinstance(eq, bool):
+        return eq
+
+    eq = sympify(eq)
+    if subs is not None:
+        return unpolarify(eq.subs(subs))
+    changed = True
+    pause = False
+    if exponents_only:
+        pause = True
+    while changed:
+        changed = False
+        res = _unpolarify(eq, exponents_only, pause)
+        if res != eq:
+            changed = True
+            eq = res
+        if isinstance(res, bool):
+            return res
+    # Finally, replacing Exp(0) by 1 is always correct.
+    # So is polar_lift(0) -> 0.
+    from sympy.functions.elementary.exponential import exp_polar
+    return res.subs({exp_polar(0): 1, polar_lift(0): 0})

venv/lib/python3.10/site-packages/sympy/functions/elementary/exponential.py

@@ -0,0 +1,1291 @@
+from itertools import product
+from typing import Tuple as tTuple
+
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import (Function, ArgumentIndexError, expand_log,
+    expand_mul, FunctionClass, PoleError, expand_multinomial, expand_complex)
+from sympy.core.logic import fuzzy_and, fuzzy_not, fuzzy_or
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer, Rational, pi, I, ImaginaryUnit
+from sympy.core.parameters import global_parameters
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Wild, Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import arg, unpolarify, im, re, Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.ntheory import multiplicity, perfect_power
+from sympy.ntheory.factor_ import factorint
+
+# NOTE IMPORTANT
+# The series expansion code in this file is an important part of the gruntz
+# algorithm for determining limits. _eval_nseries has to return a generalized
+# power series with coefficients in C(log(x), log).
+# In more detail, the result of _eval_nseries(self, x, n) must be
+#   c_0*x**e_0 + ... (finitely many terms)
+# where e_i are numbers (not necessarily integers) and c_i involve only
+# numbers, the function log, and log(x). [This also means it must not contain
+# log(x(1+p)), this *has* to be expanded to log(x)+log(1+p) if x.is_positive and
+# p.is_positive.]
+
+
+class ExpBase(Function):
+
+    unbranched = True
+    _singularities = (S.ComplexInfinity,)
+
+    @property
+    def kind(self):
+        return self.exp.kind
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse function of ``exp(x)``.
+        """
+        return log
+
+    def as_numer_denom(self):
+        """
+        Returns this with a positive exponent as a 2-tuple (a fraction).
+
+        Examples
+        ========
+
+        >>> from sympy import exp
+        >>> from sympy.abc import x
+        >>> exp(-x).as_numer_denom()
+        (1, exp(x))
+        >>> exp(x).as_numer_denom()
+        (exp(x), 1)
+        """
+        # this should be the same as Pow.as_numer_denom wrt
+        # exponent handling
+        exp = self.exp
+        neg_exp = exp.is_negative
+        if not neg_exp and not (-exp).is_negative:
+            neg_exp = exp.could_extract_minus_sign()
+        if neg_exp:
+            return S.One, self.func(-exp)
+        return self, S.One
+
+    @property
+    def exp(self):
+        """
+        Returns the exponent of the function.
+        """
+        return self.args[0]
+
+    def as_base_exp(self):
+        """
+        Returns the 2-tuple (base, exponent).
+        """
+        return self.func(1), Mul(*self.args)
+
+    def _eval_adjoint(self):
+        return self.func(self.exp.adjoint())
+
+    def _eval_conjugate(self):
+        return self.func(self.exp.conjugate())
+
+    def _eval_transpose(self):
+        return self.func(self.exp.transpose())
+
+    def _eval_is_finite(self):
+        arg = self.exp
+        if arg.is_infinite:
+            if arg.is_extended_negative:
+                return True
+            if arg.is_extended_positive:
+                return False
+        if arg.is_finite:
+            return True
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            z = s.exp.is_zero
+            if z:
+                return True
+            elif s.exp.is_rational and fuzzy_not(z):
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_zero(self):
+        return self.exp is S.NegativeInfinity
+
+    def _eval_power(self, other):
+        """exp(arg)**e -> exp(arg*e) if assumptions allow it.
+        """
+        b, e = self.as_base_exp()
+        return Pow._eval_power(Pow(b, e, evaluate=False), other)
+
+    def _eval_expand_power_exp(self, **hints):
+        from sympy.concrete.products import Product
+        from sympy.concrete.summations import Sum
+        arg = self.args[0]
+        if arg.is_Add and arg.is_commutative:
+            return Mul.fromiter(self.func(x) for x in arg.args)
+        elif isinstance(arg, Sum) and arg.is_commutative:
+            return Product(self.func(arg.function), *arg.limits)
+        return self.func(arg)
+
+
+class exp_polar(ExpBase):
+    r"""
+    Represent a *polar number* (see g-function Sphinx documentation).
+
+    Explanation
+    ===========
+
+    ``exp_polar`` represents the function
+    `Exp: \mathbb{C} \rightarrow \mathcal{S}`, sending the complex number
+    `z = a + bi` to the polar number `r = exp(a), \theta = b`. It is one of
+    the main functions to construct polar numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, pi, I, exp
+
+    The main difference is that polar numbers do not "wrap around" at `2 \pi`:
+
+    >>> exp(2*pi*I)
+    1
+    >>> exp_polar(2*pi*I)
+    exp_polar(2*I*pi)
+
+    apart from that they behave mostly like classical complex numbers:
+
+    >>> exp_polar(2)*exp_polar(3)
+    exp_polar(5)
+
+    See Also
+    ========
+
+    sympy.simplify.powsimp.powsimp
+    polar_lift
+    periodic_argument
+    principal_branch
+    """
+
+    is_polar = True
+    is_comparable = False  # cannot be evalf'd
+
+    def _eval_Abs(self):   # Abs is never a polar number
+        return exp(re(self.args[0]))
+
+    def _eval_evalf(self, prec):
+        """ Careful! any evalf of polar numbers is flaky """
+        i = im(self.args[0])
+        try:
+            bad = (i <= -pi or i > pi)
+        except TypeError:
+            bad = True
+        if bad:
+            return self  # cannot evalf for this argument
+        res = exp(self.args[0])._eval_evalf(prec)
+        if i > 0 and im(res) < 0:
+            # i ~ pi, but exp(I*i) evaluated to argument slightly bigger than pi
+            return re(res)
+        return res
+
+    def _eval_power(self, other):
+        return self.func(self.args[0]*other)
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def as_base_exp(self):
+        # XXX exp_polar(0) is special!
+        if self.args[0] == 0:
+            return self, S.One
+        return ExpBase.as_base_exp(self)
+
+
+class ExpMeta(FunctionClass):
+    def __instancecheck__(cls, instance):
+        if exp in instance.__class__.__mro__:
+            return True
+        return isinstance(instance, Pow) and instance.base is S.Exp1
+
+
+class exp(ExpBase, metaclass=ExpMeta):
+    """
+    The exponential function, :math:`e^x`.
+
+    Examples
+    ========
+
+    >>> from sympy import exp, I, pi
+    >>> from sympy.abc import x
+    >>> exp(x)
+    exp(x)
+    >>> exp(x).diff(x)
+    exp(x)
+    >>> exp(I*pi)
+    -1
+
+    Parameters
+    ==========
+
+    arg : Expr
+
+    See Also
+    ========
+
+    log
+    """
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return self
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_refine(self, assumptions):
+        from sympy.assumptions import ask, Q
+        arg = self.args[0]
+        if arg.is_Mul:
+            Ioo = I*S.Infinity
+            if arg in [Ioo, -Ioo]:
+                return S.NaN
+
+            coeff = arg.as_coefficient(pi*I)
+            if coeff:
+                if ask(Q.integer(2*coeff)):
+                    if ask(Q.even(coeff)):
+                        return S.One
+                    elif ask(Q.odd(coeff)):
+                        return S.NegativeOne
+                    elif ask(Q.even(coeff + S.Half)):
+                        return -I
+                    elif ask(Q.odd(coeff + S.Half)):
+                        return I
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus import AccumBounds
+        from sympy.matrices.matrices import MatrixBase
+        from sympy.sets.setexpr import SetExpr
+        from sympy.simplify.simplify import logcombine
+        if isinstance(arg, MatrixBase):
+            return arg.exp()
+        elif global_parameters.exp_is_pow:
+            return Pow(S.Exp1, arg)
+        elif arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.One
+            elif arg is S.One:
+                return S.Exp1
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif isinstance(arg, log):
+            return arg.args[0]
+        elif isinstance(arg, AccumBounds):
+            return AccumBounds(exp(arg.min), exp(arg.max))
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+        elif arg.is_Mul:
+            coeff = arg.as_coefficient(pi*I)
+            if coeff:
+                if (2*coeff).is_integer:
+                    if coeff.is_even:
+                        return S.One
+                    elif coeff.is_odd:
+                        return S.NegativeOne
+                    elif (coeff + S.Half).is_even:
+                        return -I
+                    elif (coeff + S.Half).is_odd:
+                        return I
+                elif coeff.is_Rational:
+                    ncoeff = coeff % 2 # restrict to [0, 2pi)
+                    if ncoeff > 1: # restrict to (-pi, pi]
+                        ncoeff -= 2
+                    if ncoeff != coeff:
+                        return cls(ncoeff*pi*I)
+
+            # Warning: code in risch.py will be very sensitive to changes
+            # in this (see DifferentialExtension).
+
+            # look for a single log factor
+
+            coeff, terms = arg.as_coeff_Mul()
+
+            # but it can't be multiplied by oo
+            if coeff in [S.NegativeInfinity, S.Infinity]:
+                if terms.is_number:
+                    if coeff is S.NegativeInfinity:
+                        terms = -terms
+                    if re(terms).is_zero and terms is not S.Zero:
+                        return S.NaN
+                    if re(terms).is_positive and im(terms) is not S.Zero:
+                        return S.ComplexInfinity
+                    if re(terms).is_negative:
+                        return S.Zero
+                return None
+
+            coeffs, log_term = [coeff], None
+            for term in Mul.make_args(terms):
+                term_ = logcombine(term)
+                if isinstance(term_, log):
+                    if log_term is None:
+                        log_term = term_.args[0]
+                    else:
+                        return None
+                elif term.is_comparable:
+                    coeffs.append(term)
+                else:
+                    return None
+
+            return log_term**Mul(*coeffs) if log_term else None
+
+        elif arg.is_Add:
+            out = []
+            add = []
+            argchanged = False
+            for a in arg.args:
+                if a is S.One:
+                    add.append(a)
+                    continue
+                newa = cls(a)
+                if isinstance(newa, cls):
+                    if newa.args[0] != a:
+                        add.append(newa.args[0])
+                        argchanged = True
+                    else:
+                        add.append(a)
+                else:
+                    out.append(newa)
+            if out or argchanged:
+                return Mul(*out)*cls(Add(*add), evaluate=False)
+
+        if arg.is_zero:
+            return S.One
+
+    @property
+    def base(self):
+        """
+        Returns the base of the exponential function.
+        """
+        return S.Exp1
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Calculates the next term in the Taylor series expansion.
+        """
+        if n < 0:
+            return S.Zero
+        if n == 0:
+            return S.One
+        x = sympify(x)
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return p * x / n
+        return x**n/factorial(n)
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a 2-tuple representing a complex number.
+
+        Examples
+        ========
+
+        >>> from sympy import exp, I
+        >>> from sympy.abc import x
+        >>> exp(x).as_real_imag()
+        (exp(re(x))*cos(im(x)), exp(re(x))*sin(im(x)))
+        >>> exp(1).as_real_imag()
+        (E, 0)
+        >>> exp(I).as_real_imag()
+        (cos(1), sin(1))
+        >>> exp(1+I).as_real_imag()
+        (E*cos(1), E*sin(1))
+
+        See Also
+        ========
+
+        sympy.functions.elementary.complexes.re
+        sympy.functions.elementary.complexes.im
+        """
+        from sympy.functions.elementary.trigonometric import cos, sin
+        re, im = self.args[0].as_real_imag()
+        if deep:
+            re = re.expand(deep, **hints)
+            im = im.expand(deep, **hints)
+        cos, sin = cos(im), sin(im)
+        return (exp(re)*cos, exp(re)*sin)
+
+    def _eval_subs(self, old, new):
+        # keep processing of power-like args centralized in Pow
+        if old.is_Pow:  # handle (exp(3*log(x))).subs(x**2, z) -> z**(3/2)
+            old = exp(old.exp*log(old.base))
+        elif old is S.Exp1 and new.is_Function:
+            old = exp
+        if isinstance(old, exp) or old is S.Exp1:
+            f = lambda a: Pow(*a.as_base_exp(), evaluate=False) if (
+                a.is_Pow or isinstance(a, exp)) else a
+            return Pow._eval_subs(f(self), f(old), new)
+
+        if old is exp and not new.is_Function:
+            return new**self.exp._subs(old, new)
+        return Function._eval_subs(self, old, new)
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+        elif self.args[0].is_imaginary:
+            arg2 = -S(2) * I * self.args[0] / pi
+            return arg2.is_even
+
+    def _eval_is_complex(self):
+        def complex_extended_negative(arg):
+            yield arg.is_complex
+            yield arg.is_extended_negative
+        return fuzzy_or(complex_extended_negative(self.args[0]))
+
+    def _eval_is_algebraic(self):
+        if (self.exp / pi / I).is_rational:
+            return True
+        if fuzzy_not(self.exp.is_zero):
+            if self.exp.is_algebraic:
+                return False
+            elif (self.exp / pi).is_rational:
+                return False
+
+    def _eval_is_extended_positive(self):
+        if self.exp.is_extended_real:
+            return self.args[0] is not S.NegativeInfinity
+        elif self.exp.is_imaginary:
+            arg2 = -I * self.args[0] / pi
+            return arg2.is_even
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE Please see the comment at the beginning of this file, labelled
+        #      IMPORTANT.
+        from sympy.functions.elementary.complexes import sign
+        from sympy.functions.elementary.integers import ceiling
+        from sympy.series.limits import limit
+        from sympy.series.order import Order
+        from sympy.simplify.powsimp import powsimp
+        arg = self.exp
+        arg_series = arg._eval_nseries(x, n=n, logx=logx)
+        if arg_series.is_Order:
+            return 1 + arg_series
+        arg0 = limit(arg_series.removeO(), x, 0)
+        if arg0 is S.NegativeInfinity:
+            return Order(x**n, x)
+        if arg0 is S.Infinity:
+            return self
+        # checking for indecisiveness/ sign terms in arg0
+        if any(isinstance(arg, (sign, ImaginaryUnit)) for arg in arg0.args):
+            return self
+        t = Dummy("t")
+        nterms = n
+        try:
+            cf = Order(arg.as_leading_term(x, logx=logx), x).getn()
+        except (NotImplementedError, PoleError):
+            cf = 0
+        if cf and cf > 0:
+            nterms = ceiling(n/cf)
+        exp_series = exp(t)._taylor(t, nterms)
+        r = exp(arg0)*exp_series.subs(t, arg_series - arg0)
+        rep = {logx: log(x)} if logx is not None else {}
+        if r.subs(rep) == self:
+            return r
+        if cf and cf > 1:
+            r += Order((arg_series - arg0)**n, x)/x**((cf-1)*n)
+        else:
+            r += Order((arg_series - arg0)**n, x)
+        r = r.expand()
+        r = powsimp(r, deep=True, combine='exp')
+        # powsimp may introduce unexpanded (-1)**Rational; see PR #17201
+        simplerat = lambda x: x.is_Rational and x.q in [3, 4, 6]
+        w = Wild('w', properties=[simplerat])
+        r = r.replace(S.NegativeOne**w, expand_complex(S.NegativeOne**w))
+        return r
+
+    def _taylor(self, x, n):
+        l = []
+        g = None
+        for i in range(n):
+            g = self.taylor_term(i, self.args[0], g)
+            g = g.nseries(x, n=n)
+            l.append(g.removeO())
+        return Add(*l)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.util import AccumBounds
+        arg = self.args[0].cancel().as_leading_term(x, logx=logx)
+        arg0 = arg.subs(x, 0)
+        if arg is S.NaN:
+            return S.NaN
+        if isinstance(arg0, AccumBounds):
+            # This check addresses a corner case involving AccumBounds.
+            # if isinstance(arg, AccumBounds) is True, then arg0 can either be 0,
+            # AccumBounds(-oo, 0) or AccumBounds(-oo, oo).
+            # Check out function: test_issue_18473() in test_exponential.py and
+            # test_limits.py for more information.
+            if re(cdir) < S.Zero:
+                return exp(-arg0)
+            return exp(arg0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0)
+        if arg0.is_infinite is False:
+            return exp(arg0)
+        raise PoleError("Cannot expand %s around 0" % (self))
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin
+        return sin(I*arg + pi/2) - I*sin(I*arg)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import cos
+        return cos(I*arg) + I*cos(I*arg + pi/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        from sympy.functions.elementary.hyperbolic import tanh
+        return (1 + tanh(arg/2))/(1 - tanh(arg/2))
+
+    def _eval_rewrite_as_sqrt(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin, cos
+        if arg.is_Mul:
+            coeff = arg.coeff(pi*I)
+            if coeff and coeff.is_number:
+                cosine, sine = cos(pi*coeff), sin(pi*coeff)
+                if not isinstance(cosine, cos) and not isinstance (sine, sin):
+                    return cosine + I*sine
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        if arg.is_Mul:
+            logs = [a for a in arg.args if isinstance(a, log) and len(a.args) == 1]
+            if logs:
+                return Pow(logs[0].args[0], arg.coeff(logs[0]))
+
+
+def match_real_imag(expr):
+    r"""
+    Try to match expr with $a + Ib$ for real $a$ and $b$.
+
+    ``match_real_imag`` returns a tuple containing the real and imaginary
+    parts of expr or ``(None, None)`` if direct matching is not possible. Contrary
+    to :func:`~.re()`, :func:`~.im()``, and ``as_real_imag()``, this helper will not force things
+    by returning expressions themselves containing ``re()`` or ``im()`` and it
+    does not expand its argument either.
+
+    """
+    r_, i_ = expr.as_independent(I, as_Add=True)
+    if i_ == 0 and r_.is_real:
+        return (r_, i_)
+    i_ = i_.as_coefficient(I)
+    if i_ and i_.is_real and r_.is_real:
+        return (r_, i_)
+    else:
+        return (None, None) # simpler to check for than None
+
+
+class log(Function):
+    r"""
+    The natural logarithm function `\ln(x)` or `\log(x)`.
+
+    Explanation
+    ===========
+
+    Logarithms are taken with the natural base, `e`. To get
+    a logarithm of a different base ``b``, use ``log(x, b)``,
+    which is essentially short-hand for ``log(x)/log(b)``.
+
+    ``log`` represents the principal branch of the natural
+    logarithm. As such it has a branch cut along the negative
+    real axis and returns values having a complex argument in
+    `(-\pi, \pi]`.
+
+    Examples
+    ========
+
+    >>> from sympy import log, sqrt, S, I
+    >>> log(8, 2)
+    3
+    >>> log(S(8)/3, 2)
+    -log(3)/log(2) + 3
+    >>> log(-1 + I*sqrt(3))
+    log(2) + 2*I*pi/3
+
+    See Also
+    ========
+
+    exp
+
+    """
+
+    args: tTuple[Expr]
+
+    _singularities = (S.Zero, S.ComplexInfinity)
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of the function.
+        """
+        if argindex == 1:
+            return 1/self.args[0]
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        r"""
+        Returns `e^x`, the inverse function of `\log(x)`.
+        """
+        return exp
+
+    @classmethod
+    def eval(cls, arg, base=None):
+        from sympy.calculus import AccumBounds
+        from sympy.sets.setexpr import SetExpr
+
+        arg = sympify(arg)
+
+        if base is not None:
+            base = sympify(base)
+            if base == 1:
+                if arg == 1:
+                    return S.NaN
+                else:
+                    return S.ComplexInfinity
+            try:
+                # handle extraction of powers of the base now
+                # or else expand_log in Mul would have to handle this
+                n = multiplicity(base, arg)
+                if n:
+                    return n + log(arg / base**n) / log(base)
+                else:
+                    return log(arg)/log(base)
+            except ValueError:
+                pass
+            if base is not S.Exp1:
+                return cls(arg)/cls(base)
+            else:
+                return cls(arg)
+
+        if arg.is_Number:
+            if arg.is_zero:
+                return S.ComplexInfinity
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg is S.NaN:
+                return S.NaN
+            elif arg.is_Rational and arg.p == 1:
+                return -cls(arg.q)
+
+        if arg.is_Pow and arg.base is S.Exp1 and arg.exp.is_extended_real:
+            return arg.exp
+        if isinstance(arg, exp) and arg.exp.is_extended_real:
+            return arg.exp
+        elif isinstance(arg, exp) and arg.exp.is_number:
+            r_, i_ = match_real_imag(arg.exp)
+            if i_ and i_.is_comparable:
+                i_ %= 2*pi
+                if i_ > pi:
+                    i_ -= 2*pi
+                return r_ + expand_mul(i_ * I, deep=False)
+        elif isinstance(arg, exp_polar):
+            return unpolarify(arg.exp)
+        elif isinstance(arg, AccumBounds):
+            if arg.min.is_positive:
+                return AccumBounds(log(arg.min), log(arg.max))
+            elif arg.min.is_zero:
+                return AccumBounds(S.NegativeInfinity, log(arg.max))
+            else:
+                return S.NaN
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+
+        if arg.is_number:
+            if arg.is_negative:
+                return pi * I + cls(-arg)
+            elif arg is S.ComplexInfinity:
+                return S.ComplexInfinity
+            elif arg is S.Exp1:
+                return S.One
+
+        if arg.is_zero:
+            return S.ComplexInfinity
+
+        # don't autoexpand Pow or Mul (see the issue 3351):
+        if not arg.is_Add:
+            coeff = arg.as_coefficient(I)
+
+            if coeff is not None:
+                if coeff is S.Infinity:
+                    return S.Infinity
+                elif coeff is S.NegativeInfinity:
+                    return S.Infinity
+                elif coeff.is_Rational:
+                    if coeff.is_nonnegative:
+                        return pi * I * S.Half + cls(coeff)
+                    else:
+                        return -pi * I * S.Half + cls(-coeff)
+
+        if arg.is_number and arg.is_algebraic:
+            # Match arg = coeff*(r_ + i_*I) with coeff>0, r_ and i_ real.
+            coeff, arg_ = arg.as_independent(I, as_Add=False)
+            if coeff.is_negative:
+                coeff *= -1
+                arg_ *= -1
+            arg_ = expand_mul(arg_, deep=False)
+            r_, i_ = arg_.as_independent(I, as_Add=True)
+            i_ = i_.as_coefficient(I)
+            if coeff.is_real and i_ and i_.is_real and r_.is_real:
+                if r_.is_zero:
+                    if i_.is_positive:
+                        return pi * I * S.Half + cls(coeff * i_)
+                    elif i_.is_negative:
+                        return -pi * I * S.Half + cls(coeff * -i_)
+                else:
+                    from sympy.simplify import ratsimp
+                    # Check for arguments involving rational multiples of pi
+                    t = (i_/r_).cancel()
+                    t1 = (-t).cancel()
+                    atan_table = _log_atan_table()
+                    if t in atan_table:
+                        modulus = ratsimp(coeff * Abs(arg_))
+                        if r_.is_positive:
+                            return cls(modulus) + I * atan_table[t]
+                        else:
+                            return cls(modulus) + I * (atan_table[t] - pi)
+                    elif t1 in atan_table:
+                        modulus = ratsimp(coeff * Abs(arg_))
+                        if r_.is_positive:
+                            return cls(modulus) + I * (-atan_table[t1])
+                        else:
+                            return cls(modulus) + I * (pi - atan_table[t1])
+
+    def as_base_exp(self):
+        """
+        Returns this function in the form (base, exponent).
+        """
+        return self, S.One
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):  # of log(1+x)
+        r"""
+        Returns the next term in the Taylor series expansion of `\log(1+x)`.
+        """
+        from sympy.simplify.powsimp import powsimp
+        if n < 0:
+            return S.Zero
+        x = sympify(x)
+        if n == 0:
+            return x
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return powsimp((-n) * p * x / (n + 1), deep=True, combine='exp')
+        return (1 - 2*(n % 2)) * x**(n + 1)/(n + 1)
+
+    def _eval_expand_log(self, deep=True, **hints):
+        from sympy.concrete import Sum, Product
+        force = hints.get('force', False)
+        factor = hints.get('factor', False)
+        if (len(self.args) == 2):
+            return expand_log(self.func(*self.args), deep=deep, force=force)
+        arg = self.args[0]
+        if arg.is_Integer:
+            # remove perfect powers
+            p = perfect_power(arg)
+            logarg = None
+            coeff = 1
+            if p is not False:
+                arg, coeff = p
+                logarg = self.func(arg)
+            # expand as product of its prime factors if factor=True
+            if factor:
+                p = factorint(arg)
+                if arg not in p.keys():
+                    logarg = sum(n*log(val) for val, n in p.items())
+            if logarg is not None:
+                return coeff*logarg
+        elif arg.is_Rational:
+            return log(arg.p) - log(arg.q)
+        elif arg.is_Mul:
+            expr = []
+            nonpos = []
+            for x in arg.args:
+                if force or x.is_positive or x.is_polar:
+                    a = self.func(x)
+                    if isinstance(a, log):
+                        expr.append(self.func(x)._eval_expand_log(**hints))
+                    else:
+                        expr.append(a)
+                elif x.is_negative:
+                    a = self.func(-x)
+                    expr.append(a)
+                    nonpos.append(S.NegativeOne)
+                else:
+                    nonpos.append(x)
+            return Add(*expr) + log(Mul(*nonpos))
+        elif arg.is_Pow or isinstance(arg, exp):
+            if force or (arg.exp.is_extended_real and (arg.base.is_positive or ((arg.exp+1)
+                .is_positive and (arg.exp-1).is_nonpositive))) or arg.base.is_polar:
+                b = arg.base
+                e = arg.exp
+                a = self.func(b)
+                if isinstance(a, log):
+                    return unpolarify(e) * a._eval_expand_log(**hints)
+                else:
+                    return unpolarify(e) * a
+        elif isinstance(arg, Product):
+            if force or arg.function.is_positive:
+                return Sum(log(arg.function), *arg.limits)
+
+        return self.func(arg)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import expand_log, simplify, inversecombine
+        if len(self.args) == 2:  # it's unevaluated
+            return simplify(self.func(*self.args), **kwargs)
+
+        expr = self.func(simplify(self.args[0], **kwargs))
+        if kwargs['inverse']:
+            expr = inversecombine(expr)
+        expr = expand_log(expr, deep=True)
+        return min([expr, self], key=kwargs['measure'])
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a complex coordinate.
+
+        Examples
+        ========
+
+        >>> from sympy import I, log
+        >>> from sympy.abc import x
+        >>> log(x).as_real_imag()
+        (log(Abs(x)), arg(x))
+        >>> log(I).as_real_imag()
+        (0, pi/2)
+        >>> log(1 + I).as_real_imag()
+        (log(sqrt(2)), pi/4)
+        >>> log(I*x).as_real_imag()
+        (log(Abs(x)), arg(I*x))
+
+        """
+        sarg = self.args[0]
+        if deep:
+            sarg = self.args[0].expand(deep, **hints)
+        sarg_abs = Abs(sarg)
+        if sarg_abs == sarg:
+            return self, S.Zero
+        sarg_arg = arg(sarg)
+        if hints.get('log', False):  # Expand the log
+            hints['complex'] = False
+            return (log(sarg_abs).expand(deep, **hints), sarg_arg)
+        else:
+            return log(sarg_abs), sarg_arg
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if (self.args[0] - 1).is_zero:
+                return True
+            if s.args[0].is_rational and fuzzy_not((self.args[0] - 1).is_zero):
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_algebraic(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if (self.args[0] - 1).is_zero:
+                return True
+            elif fuzzy_not((self.args[0] - 1).is_zero):
+                if self.args[0].is_algebraic:
+                    return False
+        else:
+            return s.is_algebraic
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_positive
+
+    def _eval_is_complex(self):
+        z = self.args[0]
+        return fuzzy_and([z.is_complex, fuzzy_not(z.is_zero)])
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        if arg.is_zero:
+            return False
+        return arg.is_finite
+
+    def _eval_is_extended_positive(self):
+        return (self.args[0] - 1).is_extended_positive
+
+    def _eval_is_zero(self):
+        return (self.args[0] - 1).is_zero
+
+    def _eval_is_extended_nonnegative(self):
+        return (self.args[0] - 1).is_extended_nonnegative
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE Please see the comment at the beginning of this file, labelled
+        #      IMPORTANT.
+        from sympy.series.order import Order
+        from sympy.simplify.simplify import logcombine
+        from sympy.core.symbol import Dummy
+
+        if self.args[0] == x:
+            return log(x) if logx is None else logx
+        arg = self.args[0]
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg.subs(x, cdir*t)
+
+        k, l = Wild("k"), Wild("l")
+        r = z.match(k*t**l)
+        if r is not None:
+            k, l = r[k], r[l]
+            if l != 0 and not l.has(t) and not k.has(t):
+                r = l*log(x) if logx is None else l*logx
+                r += log(k) - l*log(cdir) # XXX true regardless of assumptions?
+                return r
+
+        def coeff_exp(term, x):
+            coeff, exp = S.One, S.Zero
+            for factor in Mul.make_args(term):
+                if factor.has(x):
+                    base, exp = factor.as_base_exp()
+                    if base != x:
+                        try:
+                            return term.leadterm(x)
+                        except ValueError:
+                            return term, S.Zero
+                else:
+                    coeff *= factor
+            return coeff, exp
+
+        # TODO new and probably slow
+        try:
+            a, b = z.leadterm(t, logx=logx, cdir=1)
+        except (ValueError, NotImplementedError, PoleError):
+            s = z._eval_nseries(t, n=n, logx=logx, cdir=1)
+            while s.is_Order:
+                n += 1
+                s = z._eval_nseries(t, n=n, logx=logx, cdir=1)
+            try:
+                a, b = s.removeO().leadterm(t, cdir=1)
+            except ValueError:
+                a, b = s.removeO().as_leading_term(t, cdir=1), S.Zero
+
+        p = (z/(a*t**b) - 1)._eval_nseries(t, n=n, logx=logx, cdir=1)
+        if p.has(exp):
+            p = logcombine(p)
+        if isinstance(p, Order):
+            n = p.getn()
+        _, d = coeff_exp(p, t)
+        logx = log(x) if logx is None else logx
+
+        if not d.is_positive:
+            res = log(a) - b*log(cdir) + b*logx
+            _res = res
+            logflags = {"deep": True, "log": True, "mul": False, "power_exp": False,
+                "power_base": False, "multinomial": False, "basic": False, "force": True,
+                "factor": False}
+            expr = self.expand(**logflags)
+            if (not a.could_extract_minus_sign() and
+                logx.could_extract_minus_sign()):
+                _res = _res.subs(-logx, -log(x)).expand(**logflags)
+            else:
+                _res = _res.subs(logx, log(x)).expand(**logflags)
+            if _res == expr:
+                return res
+            return res + Order(x**n, x)
+
+        def mul(d1, d2):
+            res = {}
+            for e1, e2 in product(d1, d2):
+                ex = e1 + e2
+                if ex < n:
+                    res[ex] = res.get(ex, S.Zero) + d1[e1]*d2[e2]
+            return res
+
+        pterms = {}
+
+        for term in Add.make_args(p.removeO()):
+            co1, e1 = coeff_exp(term, t)
+            pterms[e1] = pterms.get(e1, S.Zero) + co1
+
+        k = S.One
+        terms = {}
+        pk = pterms
+
+        while k*d < n:
+            coeff = -S.NegativeOne**k/k
+            for ex in pk:
+                _ = terms.get(ex, S.Zero) + coeff*pk[ex]
+                terms[ex] = _.nsimplify()
+            pk = mul(pk, pterms)
+            k += S.One
+
+        res = log(a) - b*log(cdir) + b*logx
+        for ex in terms:
+            res += terms[ex]*t**(ex)
+
+        if a.is_negative and im(z) != 0:
+            from sympy.functions.special.delta_functions import Heaviside
+            for i, term in enumerate(z.lseries(t)):
+                if not term.is_real or i == 5:
+                    break
+            if i < 5:
+                coeff, _ = term.as_coeff_exponent(t)
+                res += -2*I*pi*Heaviside(-im(coeff), 0)
+
+        res = res.subs(t, x/cdir)
+        return res + Order(x**n, x)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        # NOTE
+        # Refer https://github.com/sympy/sympy/pull/23592 for more information
+        # on each of the following steps involved in this method.
+        arg0 = self.args[0].together()
+
+        # STEP 1
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg0.subs(x, cdir*t)
+
+        # STEP 2
+        try:
+            c, e = z.leadterm(t, logx=logx, cdir=1)
+        except ValueError:
+            arg = arg0.as_leading_term(x, logx=logx, cdir=cdir)
+            return log(arg)
+        if c.has(t):
+            c = c.subs(t, x/cdir)
+            if e != 0:
+                raise PoleError("Cannot expand %s around 0" % (self))
+            return log(c)
+
+        # STEP 3
+        if c == S.One and e == S.Zero:
+            return (arg0 - S.One).as_leading_term(x, logx=logx)
+
+        # STEP 4
+        res = log(c) - e*log(cdir)
+        logx = log(x) if logx is None else logx
+        res += e*logx
+
+        # STEP 5
+        if c.is_negative and im(z) != 0:
+            from sympy.functions.special.delta_functions import Heaviside
+            for i, term in enumerate(z.lseries(t)):
+                if not term.is_real or i == 5:
+                    break
+            if i < 5:
+                coeff, _ = term.as_coeff_exponent(t)
+                res += -2*I*pi*Heaviside(-im(coeff), 0)
+        return res
+
+
+class LambertW(Function):
+    r"""
+    The Lambert W function $W(z)$ is defined as the inverse
+    function of $w \exp(w)$ [1]_.
+
+    Explanation
+    ===========
+
+    In other words, the value of $W(z)$ is such that $z = W(z) \exp(W(z))$
+    for any complex number $z$.  The Lambert W function is a multivalued
+    function with infinitely many branches $W_k(z)$, indexed by
+    $k \in \mathbb{Z}$.  Each branch gives a different solution $w$
+    of the equation $z = w \exp(w)$.
+
+    The Lambert W function has two partially real branches: the
+    principal branch ($k = 0$) is real for real $z > -1/e$, and the
+    $k = -1$ branch is real for $-1/e < z < 0$. All branches except
+    $k = 0$ have a logarithmic singularity at $z = 0$.
+
+    Examples
+    ========
+
+    >>> from sympy import LambertW
+    >>> LambertW(1.2)
+    0.635564016364870
+    >>> LambertW(1.2, -1).n()
+    -1.34747534407696 - 4.41624341514535*I
+    >>> LambertW(-1).is_real
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lambert_W_function
+    """
+    _singularities = (-Pow(S.Exp1, -1, evaluate=False), S.ComplexInfinity)
+
+    @classmethod
+    def eval(cls, x, k=None):
+        if k == S.Zero:
+            return cls(x)
+        elif k is None:
+            k = S.Zero
+
+        if k.is_zero:
+            if x.is_zero:
+                return S.Zero
+            if x is S.Exp1:
+                return S.One
+            if x == -1/S.Exp1:
+                return S.NegativeOne
+            if x == -log(2)/2:
+                return -log(2)
+            if x == 2*log(2):
+                return log(2)
+            if x == -pi/2:
+                return I*pi/2
+            if x == exp(1 + S.Exp1):
+                return S.Exp1
+            if x is S.Infinity:
+                return S.Infinity
+            if x.is_zero:
+                return S.Zero
+
+        if fuzzy_not(k.is_zero):
+            if x.is_zero:
+                return S.NegativeInfinity
+        if k is S.NegativeOne:
+            if x == -pi/2:
+                return -I*pi/2
+            elif x == -1/S.Exp1:
+                return S.NegativeOne
+            elif x == -2*exp(-2):
+                return -Integer(2)
+
+    def fdiff(self, argindex=1):
+        """
+        Return the first derivative of this function.
+        """
+        x = self.args[0]
+
+        if len(self.args) == 1:
+            if argindex == 1:
+                return LambertW(x)/(x*(1 + LambertW(x)))
+        else:
+            k = self.args[1]
+            if argindex == 1:
+                return LambertW(x, k)/(x*(1 + LambertW(x, k)))
+
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_extended_real(self):
+        x = self.args[0]
+        if len(self.args) == 1:
+            k = S.Zero
+        else:
+            k = self.args[1]
+        if k.is_zero:
+            if (x + 1/S.Exp1).is_positive:
+                return True
+            elif (x + 1/S.Exp1).is_nonpositive:
+                return False
+        elif (k + 1).is_zero:
+            if x.is_negative and (x + 1/S.Exp1).is_positive:
+                return True
+            elif x.is_nonpositive or (x + 1/S.Exp1).is_nonnegative:
+                return False
+        elif fuzzy_not(k.is_zero) and fuzzy_not((k + 1).is_zero):
+            if x.is_extended_real:
+                return False
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+    def _eval_is_algebraic(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if fuzzy_not(self.args[0].is_zero) and self.args[0].is_algebraic:
+                return False
+        else:
+            return s.is_algebraic
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        if len(self.args) == 1:
+            arg = self.args[0]
+            arg0 = arg.subs(x, 0).cancel()
+            if not arg0.is_zero:
+                return self.func(arg0)
+            return arg.as_leading_term(x)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        if len(self.args) == 1:
+            from sympy.functions.elementary.integers import ceiling
+            from sympy.series.order import Order
+            arg = self.args[0].nseries(x, n=n, logx=logx)
+            lt = arg.as_leading_term(x, logx=logx)
+            lte = 1
+            if lt.is_Pow:
+                lte = lt.exp
+            if ceiling(n/lte) >= 1:
+                s = Add(*[(-S.One)**(k - 1)*Integer(k)**(k - 2)/
+                          factorial(k - 1)*arg**k for k in range(1, ceiling(n/lte))])
+                s = expand_multinomial(s)
+            else:
+                s = S.Zero
+
+            return s + Order(x**n, x)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_is_zero(self):
+        x = self.args[0]
+        if len(self.args) == 1:
+            return x.is_zero
+        else:
+            return fuzzy_and([x.is_zero, self.args[1].is_zero])
+
+
+@cacheit
+def _log_atan_table():
+    return {
+        # first quadrant only
+        sqrt(3): pi / 3,
+        1: pi / 4,
+        sqrt(5 - 2 * sqrt(5)): pi / 5,
+        sqrt(2) * sqrt(5 - sqrt(5)) / (1 + sqrt(5)): pi / 5,
+        sqrt(5 + 2 * sqrt(5)): pi * Rational(2, 5),
+        sqrt(2) * sqrt(sqrt(5) + 5) / (-1 + sqrt(5)): pi * Rational(2, 5),
+        sqrt(3) / 3: pi / 6,
+        sqrt(2) - 1: pi / 8,
+        sqrt(2 - sqrt(2)) / sqrt(sqrt(2) + 2): pi / 8,
+        sqrt(2) + 1: pi * Rational(3, 8),
+        sqrt(sqrt(2) + 2) / sqrt(2 - sqrt(2)): pi * Rational(3, 8),
+        sqrt(1 - 2 * sqrt(5) / 5): pi / 10,
+        (-sqrt(2) + sqrt(10)) / (2 * sqrt(sqrt(5) + 5)): pi / 10,
+        sqrt(1 + 2 * sqrt(5) / 5): pi * Rational(3, 10),
+        (sqrt(2) + sqrt(10)) / (2 * sqrt(5 - sqrt(5))): pi * Rational(3, 10),
+        2 - sqrt(3): pi / 12,
+        (-1 + sqrt(3)) / (1 + sqrt(3)): pi / 12,
+        2 + sqrt(3): pi * Rational(5, 12),
+        (1 + sqrt(3)) / (-1 + sqrt(3)): pi * Rational(5, 12)
+    }

venv/lib/python3.10/site-packages/sympy/functions/elementary/hyperbolic.py

@@ -0,0 +1,2203 @@
+from sympy.core import S, sympify, cacheit
+from sympy.core.add import Add
+from sympy.core.function import Function, ArgumentIndexError
+from sympy.core.logic import fuzzy_or, fuzzy_and, FuzzyBool
+from sympy.core.numbers import I, pi, Rational
+from sympy.core.symbol import Dummy
+from sympy.functions.combinatorial.factorials import (binomial, factorial,
+                                                      RisingFactorial)
+from sympy.functions.combinatorial.numbers import bernoulli, euler, nC
+from sympy.functions.elementary.complexes import Abs, im, re
+from sympy.functions.elementary.exponential import exp, log, match_real_imag
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (
+    acos, acot, asin, atan, cos, cot, csc, sec, sin, tan,
+    _imaginary_unit_as_coefficient)
+from sympy.polys.specialpolys import symmetric_poly
+
+
+def _rewrite_hyperbolics_as_exp(expr):
+    return expr.xreplace({h: h.rewrite(exp)
+        for h in expr.atoms(HyperbolicFunction)})
+
+
+@cacheit
+def _acosh_table():
+    return {
+        I: log(I*(1 + sqrt(2))),
+        -I: log(-I*(1 + sqrt(2))),
+        S.Half: pi/3,
+        Rational(-1, 2): pi*Rational(2, 3),
+        sqrt(2)/2: pi/4,
+        -sqrt(2)/2: pi*Rational(3, 4),
+        1/sqrt(2): pi/4,
+        -1/sqrt(2): pi*Rational(3, 4),
+        sqrt(3)/2: pi/6,
+        -sqrt(3)/2: pi*Rational(5, 6),
+        (sqrt(3) - 1)/sqrt(2**3): pi*Rational(5, 12),
+        -(sqrt(3) - 1)/sqrt(2**3): pi*Rational(7, 12),
+        sqrt(2 + sqrt(2))/2: pi/8,
+        -sqrt(2 + sqrt(2))/2: pi*Rational(7, 8),
+        sqrt(2 - sqrt(2))/2: pi*Rational(3, 8),
+        -sqrt(2 - sqrt(2))/2: pi*Rational(5, 8),
+        (1 + sqrt(3))/(2*sqrt(2)): pi/12,
+        -(1 + sqrt(3))/(2*sqrt(2)): pi*Rational(11, 12),
+        (sqrt(5) + 1)/4: pi/5,
+        -(sqrt(5) + 1)/4: pi*Rational(4, 5)
+    }
+
+
+@cacheit
+def _acsch_table():
+    return {
+            I: -pi / 2,
+            I*(sqrt(2) + sqrt(6)): -pi / 12,
+            I*(1 + sqrt(5)): -pi / 10,
+            I*2 / sqrt(2 - sqrt(2)): -pi / 8,
+            I*2: -pi / 6,
+            I*sqrt(2 + 2/sqrt(5)): -pi / 5,
+            I*sqrt(2): -pi / 4,
+            I*(sqrt(5)-1): -3*pi / 10,
+            I*2 / sqrt(3): -pi / 3,
+            I*2 / sqrt(2 + sqrt(2)): -3*pi / 8,
+            I*sqrt(2 - 2/sqrt(5)): -2*pi / 5,
+            I*(sqrt(6) - sqrt(2)): -5*pi / 12,
+            S(2): -I*log((1+sqrt(5))/2),
+        }
+
+
+@cacheit
+def _asech_table():
+        return {
+            I: - (pi*I / 2) + log(1 + sqrt(2)),
+            -I: (pi*I / 2) + log(1 + sqrt(2)),
+            (sqrt(6) - sqrt(2)): pi / 12,
+            (sqrt(2) - sqrt(6)): 11*pi / 12,
+            sqrt(2 - 2/sqrt(5)): pi / 10,
+            -sqrt(2 - 2/sqrt(5)): 9*pi / 10,
+            2 / sqrt(2 + sqrt(2)): pi / 8,
+            -2 / sqrt(2 + sqrt(2)): 7*pi / 8,
+            2 / sqrt(3): pi / 6,
+            -2 / sqrt(3): 5*pi / 6,
+            (sqrt(5) - 1): pi / 5,
+            (1 - sqrt(5)): 4*pi / 5,
+            sqrt(2): pi / 4,
+            -sqrt(2): 3*pi / 4,
+            sqrt(2 + 2/sqrt(5)): 3*pi / 10,
+            -sqrt(2 + 2/sqrt(5)): 7*pi / 10,
+            S(2): pi / 3,
+            -S(2): 2*pi / 3,
+            sqrt(2*(2 + sqrt(2))): 3*pi / 8,
+            -sqrt(2*(2 + sqrt(2))): 5*pi / 8,
+            (1 + sqrt(5)): 2*pi / 5,
+            (-1 - sqrt(5)): 3*pi / 5,
+            (sqrt(6) + sqrt(2)): 5*pi / 12,
+            (-sqrt(6) - sqrt(2)): 7*pi / 12,
+            I*S.Infinity: -pi*I / 2,
+            I*S.NegativeInfinity: pi*I / 2,
+        }
+
+###############################################################################
+########################### HYPERBOLIC FUNCTIONS ##############################
+###############################################################################
+
+
+class HyperbolicFunction(Function):
+    """
+    Base class for hyperbolic functions.
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, coth
+    """
+
+    unbranched = True
+
+
+def _peeloff_ipi(arg):
+    r"""
+    Split ARG into two parts, a "rest" and a multiple of $I\pi$.
+    This assumes ARG to be an ``Add``.
+    The multiple of $I\pi$ returned in the second position is always a ``Rational``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.hyperbolic import _peeloff_ipi as peel
+    >>> from sympy import pi, I
+    >>> from sympy.abc import x, y
+    >>> peel(x + I*pi/2)
+    (x, 1/2)
+    >>> peel(x + I*2*pi/3 + I*pi*y)
+    (x + I*pi*y + I*pi/6, 1/2)
+    """
+    ipi = pi*I
+    for a in Add.make_args(arg):
+        if a == ipi:
+            K = S.One
+            break
+        elif a.is_Mul:
+            K, p = a.as_two_terms()
+            if p == ipi and K.is_Rational:
+                break
+    else:
+        return arg, S.Zero
+
+    m1 = (K % S.Half)
+    m2 = K - m1
+    return arg - m2*ipi, m2
+
+
+class sinh(HyperbolicFunction):
+    r"""
+    ``sinh(x)`` is the hyperbolic sine of ``x``.
+
+    The hyperbolic sine function is $\frac{e^x - e^{-x}}{2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import sinh
+    >>> from sympy.abc import x
+    >>> sinh(x)
+    sinh(x)
+
+    See Also
+    ========
+
+    cosh, tanh, asinh
+    """
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return cosh(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return asinh
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.NegativeInfinity
+            elif arg.is_zero:
+                return S.Zero
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * sin(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    m = m*pi*I
+                    return sinh(m)*cosh(x) + cosh(m)*sinh(x)
+
+            if arg.is_zero:
+                return S.Zero
+
+            if arg.func == asinh:
+                return arg.args[0]
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return sqrt(x - 1) * sqrt(x + 1)
+
+            if arg.func == atanh:
+                x = arg.args[0]
+                return x/sqrt(1 - x**2)
+
+            if arg.func == acoth:
+                x = arg.args[0]
+                return 1/(sqrt(x - 1) * sqrt(x + 1))
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Returns the next term in the Taylor series expansion.
+        """
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return p * x**2 / (n*(n - 1))
+            else:
+                return x**(n) / factorial(n)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a complex coordinate.
+        """
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        return (sinh(re)*cos(im), cosh(re)*sin(im))
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*I
+
+    def _eval_expand_trig(self, deep=True, **hints):
+        if deep:
+            arg = self.args[0].expand(deep, **hints)
+        else:
+            arg = self.args[0]
+        x = None
+        if arg.is_Add: # TODO, implement more if deep stuff here
+            x, y = arg.as_two_terms()
+        else:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff is not S.One and coeff.is_Integer and terms is not S.One:
+                x = terms
+                y = (coeff - 1)*x
+        if x is not None:
+            return (sinh(x)*cosh(y) + sinh(y)*cosh(x)).expand(trig=True)
+        return sinh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return (exp(arg) - exp(-arg)) / 2
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return (exp(arg) - exp(-arg)) / 2
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return -I * sin(I * arg)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return -I / csc(I * arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return -I*cosh(arg + pi*I/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        tanh_half = tanh(S.Half*arg)
+        return 2*tanh_half/(1 - tanh_half**2)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        coth_half = coth(S.Half*arg)
+        return 2*coth_half/(coth_half**2 - 1)
+
+    def _eval_rewrite_as_csch(self, arg, **kwargs):
+        return 1 / csch(arg)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if cdir.is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real:
+            return True
+
+        # if `im` is of the form n*pi
+        # else, check if it is a number
+        re, im = arg.as_real_imag()
+        return (im%pi).is_zero
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        return arg.is_finite
+
+    def _eval_is_zero(self):
+        rest, ipi_mult = _peeloff_ipi(self.args[0])
+        if rest.is_zero:
+            return ipi_mult.is_integer
+
+
+class cosh(HyperbolicFunction):
+    r"""
+    ``cosh(x)`` is the hyperbolic cosine of ``x``.
+
+    The hyperbolic cosine function is $\frac{e^x + e^{-x}}{2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import cosh
+    >>> from sympy.abc import x
+    >>> cosh(x)
+    cosh(x)
+
+    See Also
+    ========
+
+    sinh, tanh, acosh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return sinh(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.functions.elementary.trigonometric import cos
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg.is_zero:
+                return S.One
+            elif arg.is_negative:
+                return cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return cos(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    m = m*pi*I
+                    return cosh(m)*cosh(x) + sinh(m)*sinh(x)
+
+            if arg.is_zero:
+                return S.One
+
+            if arg.func == asinh:
+                return sqrt(1 + arg.args[0]**2)
+
+            if arg.func == acosh:
+                return arg.args[0]
+
+            if arg.func == atanh:
+                return 1/sqrt(1 - arg.args[0]**2)
+
+            if arg.func == acoth:
+                x = arg.args[0]
+                return x/(sqrt(x - 1) * sqrt(x + 1))
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return p * x**2 / (n*(n - 1))
+            else:
+                return x**(n)/factorial(n)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+
+        return (cosh(re)*cos(im), sinh(re)*sin(im))
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*I
+
+    def _eval_expand_trig(self, deep=True, **hints):
+        if deep:
+            arg = self.args[0].expand(deep, **hints)
+        else:
+            arg = self.args[0]
+        x = None
+        if arg.is_Add: # TODO, implement more if deep stuff here
+            x, y = arg.as_two_terms()
+        else:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff is not S.One and coeff.is_Integer and terms is not S.One:
+                x = terms
+                y = (coeff - 1)*x
+        if x is not None:
+            return (cosh(x)*cosh(y) + sinh(x)*sinh(y)).expand(trig=True)
+        return cosh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return (exp(arg) + exp(-arg)) / 2
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return (exp(arg) + exp(-arg)) / 2
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return cos(I * arg)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return 1 / sec(I * arg)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return -I*sinh(arg + pi*I/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        tanh_half = tanh(S.Half*arg)**2
+        return (1 + tanh_half)/(1 - tanh_half)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        coth_half = coth(S.Half*arg)**2
+        return (coth_half + 1)/(coth_half - 1)
+
+    def _eval_rewrite_as_sech(self, arg, **kwargs):
+        return 1 / sech(arg)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if cdir.is_negative else '+')
+        if arg0.is_zero:
+            return S.One
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+
+        # `cosh(x)` is real for real OR purely imaginary `x`
+        if arg.is_real or arg.is_imaginary:
+            return True
+
+        # cosh(a+ib) = cos(b)*cosh(a) + i*sin(b)*sinh(a)
+        # the imaginary part can be an expression like n*pi
+        # if not, check if the imaginary part is a number
+        re, im = arg.as_real_imag()
+        return (im%pi).is_zero
+
+    def _eval_is_positive(self):
+        # cosh(x+I*y) = cos(y)*cosh(x) + I*sin(y)*sinh(x)
+        # cosh(z) is positive iff it is real and the real part is positive.
+        # So we need sin(y)*sinh(x) = 0 which gives x=0 or y=n*pi
+        # Case 1 (y=n*pi): cosh(z) = (-1)**n * cosh(x) -> positive for n even
+        # Case 2 (x=0): cosh(z) = cos(y) -> positive when cos(y) is positive
+        z = self.args[0]
+
+        x, y = z.as_real_imag()
+        ymod = y % (2*pi)
+
+        yzero = ymod.is_zero
+        # shortcut if ymod is zero
+        if yzero:
+            return True
+
+        xzero = x.is_zero
+        # shortcut x is not zero
+        if xzero is False:
+            return yzero
+
+        return fuzzy_or([
+                # Case 1:
+                yzero,
+                # Case 2:
+                fuzzy_and([
+                    xzero,
+                    fuzzy_or([ymod < pi/2, ymod > 3*pi/2])
+                ])
+            ])
+
+
+    def _eval_is_nonnegative(self):
+        z = self.args[0]
+
+        x, y = z.as_real_imag()
+        ymod = y % (2*pi)
+
+        yzero = ymod.is_zero
+        # shortcut if ymod is zero
+        if yzero:
+            return True
+
+        xzero = x.is_zero
+        # shortcut x is not zero
+        if xzero is False:
+            return yzero
+
+        return fuzzy_or([
+                # Case 1:
+                yzero,
+                # Case 2:
+                fuzzy_and([
+                    xzero,
+                    fuzzy_or([ymod <= pi/2, ymod >= 3*pi/2])
+                ])
+            ])
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        return arg.is_finite
+
+    def _eval_is_zero(self):
+        rest, ipi_mult = _peeloff_ipi(self.args[0])
+        if ipi_mult and rest.is_zero:
+            return (ipi_mult - S.Half).is_integer
+
+
+class tanh(HyperbolicFunction):
+    r"""
+    ``tanh(x)`` is the hyperbolic tangent of ``x``.
+
+    The hyperbolic tangent function is $\frac{\sinh(x)}{\cosh(x)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import tanh
+    >>> from sympy.abc import x
+    >>> tanh(x)
+    tanh(x)
+
+    See Also
+    ========
+
+    sinh, cosh, atanh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return S.One - tanh(self.args[0])**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return atanh
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.One
+            elif arg is S.NegativeInfinity:
+                return S.NegativeOne
+            elif arg.is_zero:
+                return S.Zero
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                if i_coeff.could_extract_minus_sign():
+                    return -I * tan(-i_coeff)
+                return I * tan(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    tanhm = tanh(m*pi*I)
+                    if tanhm is S.ComplexInfinity:
+                        return coth(x)
+                    else: # tanhm == 0
+                        return tanh(x)
+
+            if arg.is_zero:
+                return S.Zero
+
+            if arg.func == asinh:
+                x = arg.args[0]
+                return x/sqrt(1 + x**2)
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return sqrt(x - 1) * sqrt(x + 1) / x
+
+            if arg.func == atanh:
+                return arg.args[0]
+
+            if arg.func == acoth:
+                return 1/arg.args[0]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            a = 2**(n + 1)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return a*(a - 1) * B/F * x**n
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        denom = sinh(re)**2 + cos(im)**2
+        return (sinh(re)*cosh(re)/denom, sin(im)*cos(im)/denom)
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        if arg.is_Add:
+            n = len(arg.args)
+            TX = [tanh(x, evaluate=False)._eval_expand_trig()
+                for x in arg.args]
+            p = [0, 0]  # [den, num]
+            for i in range(n + 1):
+                p[i % 2] += symmetric_poly(i, TX)
+            return p[1]/p[0]
+        elif arg.is_Mul:
+            coeff, terms = arg.as_coeff_Mul()
+            if coeff.is_Integer and coeff > 1:
+                T = tanh(terms)
+                n = [nC(range(coeff), k)*T**k for k in range(1, coeff + 1, 2)]
+                d = [nC(range(coeff), k)*T**k for k in range(0, coeff + 1, 2)]
+                return Add(*n)/Add(*d)
+        return tanh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp - neg_exp)/(pos_exp + neg_exp)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp - neg_exp)/(pos_exp + neg_exp)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        return -I * tan(I * arg)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        return -I / cot(I * arg)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I*sinh(arg)/sinh(pi*I/2 - arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I*cosh(pi*I/2 - arg)/cosh(arg)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        return 1/coth(arg)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x)
+
+        if x in arg.free_symbols and Order(1, x).contains(arg):
+            return arg
+        else:
+            return self.func(arg)
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real:
+            return True
+
+        re, im = arg.as_real_imag()
+
+        # if denom = 0, tanh(arg) = zoo
+        if re == 0 and im % pi == pi/2:
+            return None
+
+        # check if im is of the form n*pi/2 to make sin(2*im) = 0
+        # if not, im could be a number, return False in that case
+        return (im % (pi/2)).is_zero
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+
+        re, im = arg.as_real_imag()
+        denom = cos(im)**2 + sinh(re)**2
+        if denom == 0:
+            return False
+        elif denom.is_number:
+            return True
+        if arg.is_extended_real:
+            return True
+
+    def _eval_is_zero(self):
+        arg = self.args[0]
+        if arg.is_zero:
+            return True
+
+
+class coth(HyperbolicFunction):
+    r"""
+    ``coth(x)`` is the hyperbolic cotangent of ``x``.
+
+    The hyperbolic cotangent function is $\frac{\cosh(x)}{\sinh(x)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import coth
+    >>> from sympy.abc import x
+    >>> coth(x)
+    coth(x)
+
+    See Also
+    ========
+
+    sinh, cosh, acoth
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -1/sinh(self.args[0])**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return acoth
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.One
+            elif arg is S.NegativeInfinity:
+                return S.NegativeOne
+            elif arg.is_zero:
+                return S.ComplexInfinity
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                if i_coeff.could_extract_minus_sign():
+                    return I * cot(-i_coeff)
+                return -I * cot(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    cothm = coth(m*pi*I)
+                    if cothm is S.ComplexInfinity:
+                        return coth(x)
+                    else: # cothm == 0
+                        return tanh(x)
+
+            if arg.is_zero:
+                return S.ComplexInfinity
+
+            if arg.func == asinh:
+                x = arg.args[0]
+                return sqrt(1 + x**2)/x
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return x/(sqrt(x - 1) * sqrt(x + 1))
+
+            if arg.func == atanh:
+                return 1/arg.args[0]
+
+            if arg.func == acoth:
+                return arg.args[0]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return 1 / sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return 2**(n + 1) * B/F * x**n
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        from sympy.functions.elementary.trigonometric import (cos, sin)
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        denom = sinh(re)**2 + sin(im)**2
+        return (sinh(re)*cosh(re)/denom, -sin(im)*cos(im)/denom)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp + neg_exp)/(pos_exp - neg_exp)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp + neg_exp)/(pos_exp - neg_exp)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return -I*sinh(pi*I/2 - arg)/sinh(arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return -I*cosh(arg)/cosh(pi*I/2 - arg)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        return 1/tanh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x)
+
+        if x in arg.free_symbols and Order(1, x).contains(arg):
+            return 1/arg
+        else:
+            return self.func(arg)
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        if arg.is_Add:
+            CX = [coth(x, evaluate=False)._eval_expand_trig() for x in arg.args]
+            p = [[], []]
+            n = len(arg.args)
+            for i in range(n, -1, -1):
+                p[(n - i) % 2].append(symmetric_poly(i, CX))
+            return Add(*p[0])/Add(*p[1])
+        elif arg.is_Mul:
+            coeff, x = arg.as_coeff_Mul(rational=True)
+            if coeff.is_Integer and coeff > 1:
+                c = coth(x, evaluate=False)
+                p = [[], []]
+                for i in range(coeff, -1, -1):
+                    p[(coeff - i) % 2].append(binomial(coeff, i)*c**i)
+                return Add(*p[0])/Add(*p[1])
+        return coth(arg)
+
+
+class ReciprocalHyperbolicFunction(HyperbolicFunction):
+    """Base class for reciprocal functions of hyperbolic functions. """
+
+    #To be defined in class
+    _reciprocal_of = None
+    _is_even: FuzzyBool = None
+    _is_odd: FuzzyBool = None
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.could_extract_minus_sign():
+            if cls._is_even:
+                return cls(-arg)
+            if cls._is_odd:
+                return -cls(-arg)
+
+        t = cls._reciprocal_of.eval(arg)
+        if hasattr(arg, 'inverse') and arg.inverse() == cls:
+            return arg.args[0]
+        return 1/t if t is not None else t
+
+    def _call_reciprocal(self, method_name, *args, **kwargs):
+        # Calls method_name on _reciprocal_of
+        o = self._reciprocal_of(self.args[0])
+        return getattr(o, method_name)(*args, **kwargs)
+
+    def _calculate_reciprocal(self, method_name, *args, **kwargs):
+        # If calling method_name on _reciprocal_of returns a value != None
+        # then return the reciprocal of that value
+        t = self._call_reciprocal(method_name, *args, **kwargs)
+        return 1/t if t is not None else t
+
+    def _rewrite_reciprocal(self, method_name, arg):
+        # Special handling for rewrite functions. If reciprocal rewrite returns
+        # unmodified expression, then return None
+        t = self._call_reciprocal(method_name, arg)
+        if t is not None and t != self._reciprocal_of(arg):
+            return 1/t
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_exp", arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_tractable", arg)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_tanh", arg)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_coth", arg)
+
+    def as_real_imag(self, deep = True, **hints):
+        return (1 / self._reciprocal_of(self.args[0])).as_real_imag(deep, **hints)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=True, **hints)
+        return re_part + I*im_part
+
+    def _eval_expand_trig(self, **hints):
+        return self._calculate_reciprocal("_eval_expand_trig", **hints)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        return (1/self._reciprocal_of(self.args[0]))._eval_as_leading_term(x)
+
+    def _eval_is_extended_real(self):
+        return self._reciprocal_of(self.args[0]).is_extended_real
+
+    def _eval_is_finite(self):
+        return (1/self._reciprocal_of(self.args[0])).is_finite
+
+
+class csch(ReciprocalHyperbolicFunction):
+    r"""
+    ``csch(x)`` is the hyperbolic cosecant of ``x``.
+
+    The hyperbolic cosecant function is $\frac{2}{e^x - e^{-x}}$
+
+    Examples
+    ========
+
+    >>> from sympy import csch
+    >>> from sympy.abc import x
+    >>> csch(x)
+    csch(x)
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, sech, asinh, acosh
+    """
+
+    _reciprocal_of = sinh
+    _is_odd = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function
+        """
+        if argindex == 1:
+            return -coth(self.args[0]) * csch(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Returns the next term in the Taylor series expansion
+        """
+        if n == 0:
+            return 1/sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return 2 * (1 - 2**n) * B/F * x**n
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return I / sin(I * arg)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return I * csc(I * arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I / cosh(arg + I * pi / 2)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return 1 / sinh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+
+class sech(ReciprocalHyperbolicFunction):
+    r"""
+    ``sech(x)`` is the hyperbolic secant of ``x``.
+
+    The hyperbolic secant function is $\frac{2}{e^x + e^{-x}}$
+
+    Examples
+    ========
+
+    >>> from sympy import sech
+    >>> from sympy.abc import x
+    >>> sech(x)
+    sech(x)
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, coth, csch, asinh, acosh
+    """
+
+    _reciprocal_of = cosh
+    _is_even = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return - tanh(self.args[0])*sech(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return euler(n) / factorial(n) * x**(n)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return 1 / cos(I * arg)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return sec(I * arg)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I / sinh(arg + I * pi /2)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return 1 / cosh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return True
+
+
+###############################################################################
+############################# HYPERBOLIC INVERSES #############################
+###############################################################################
+
+class InverseHyperbolicFunction(Function):
+    """Base class for inverse hyperbolic functions."""
+
+    pass
+
+
+class asinh(InverseHyperbolicFunction):
+    """
+    ``asinh(x)`` is the inverse hyperbolic sine of ``x``.
+
+    The inverse hyperbolic sine function.
+
+    Examples
+    ========
+
+    >>> from sympy import asinh
+    >>> from sympy.abc import x
+    >>> asinh(x).diff(x)
+    1/sqrt(x**2 + 1)
+    >>> asinh(1)
+    log(1 + sqrt(2))
+
+    See Also
+    ========
+
+    acosh, atanh, sinh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/sqrt(self.args[0]**2 + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.NegativeInfinity
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return log(sqrt(2) + 1)
+            elif arg is S.NegativeOne:
+                return log(sqrt(2) - 1)
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.ComplexInfinity
+
+            if arg.is_zero:
+                return S.Zero
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * asin(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if isinstance(arg, sinh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return z
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor((i + pi/2)/pi)
+                m = z - I*pi*f
+                even = f.is_even
+                if even is True:
+                    return m
+                elif even is False:
+                    return -m
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return -p * (n - 2)**2/(n*(n - 1)) * x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return S.NegativeOne**k * R / F * x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # asinh
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+        # Handling branch points
+        if x0 in (-I, I, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(x0).is_negative:
+                    return -self.func(x0) - I*pi
+            elif re(ndir).is_negative:
+                if im(x0).is_positive:
+                    return -self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asinh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (I, -I):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + arg0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(arg0).is_negative:
+                    return -res - I*pi
+            elif re(ndir).is_negative:
+                if im(arg0).is_positive:
+                    return -res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return log(x + sqrt(x**2 + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return atanh(x/sqrt(1 + x**2))
+
+    def _eval_rewrite_as_acosh(self, x, **kwargs):
+        ix = I*x
+        return I*(sqrt(1 - ix)/sqrt(ix - 1) * acosh(ix) - pi/2)
+
+    def _eval_rewrite_as_asin(self, x, **kwargs):
+        return -I * asin(I * x)
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return I * acos(I * x) - I*pi/2
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sinh
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+
+class acosh(InverseHyperbolicFunction):
+    """
+    ``acosh(x)`` is the inverse hyperbolic cosine of ``x``.
+
+    The inverse hyperbolic cosine function.
+
+    Examples
+    ========
+
+    >>> from sympy import acosh
+    >>> from sympy.abc import x
+    >>> acosh(x).diff(x)
+    1/(sqrt(x - 1)*sqrt(x + 1))
+    >>> acosh(1)
+    0
+
+    See Also
+    ========
+
+    asinh, atanh, cosh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            arg = self.args[0]
+            return 1/(sqrt(arg - 1)*sqrt(arg + 1))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg.is_zero:
+                return pi*I / 2
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi*I
+
+        if arg.is_number:
+            cst_table = _acosh_table()
+
+            if arg in cst_table:
+                if arg.is_extended_real:
+                    return cst_table[arg]*I
+                return cst_table[arg]
+
+        if arg is S.ComplexInfinity:
+            return S.ComplexInfinity
+        if arg == I*S.Infinity:
+            return S.Infinity + I*pi/2
+        if arg == -I*S.Infinity:
+            return S.Infinity - I*pi/2
+
+        if arg.is_zero:
+            return pi*I*S.Half
+
+        if isinstance(arg, cosh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return Abs(z)
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor(i/pi)
+                m = z - I*pi*f
+                even = f.is_even
+                if even is True:
+                    if r.is_nonnegative:
+                        return m
+                    elif r.is_negative:
+                        return -m
+                elif even is False:
+                    m -= I*pi
+                    if r.is_nonpositive:
+                        return -m
+                    elif r.is_positive:
+                        return m
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return I*pi/2
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return p * (n - 2)**2/(n*(n - 1)) * x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return -R / F * I * x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # acosh
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-S.One, S.Zero, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, 1)
+        if (x0 - 1).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if (x0 + 1).is_negative:
+                    return self.func(x0) - 2*I*pi
+                return -self.func(x0)
+            elif not im(ndir).is_positive:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acosh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, 1)
+        if (arg0 - 1).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if (arg0 + 1).is_negative:
+                    return res - 2*I*pi
+                return -res
+            elif not im(ndir).is_positive:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return log(x + sqrt(x + 1) * sqrt(x - 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * acos(x)
+
+    def _eval_rewrite_as_asin(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * (pi/2 - asin(x))
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * (pi/2 + I*asinh(I*x))
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        sxm1 = sqrt(x - 1)
+        s1mx = sqrt(1 - x)
+        sx2m1 = sqrt(x**2 - 1)
+        return (pi/2*sxm1/s1mx*(1 - x * sqrt(1/x**2)) +
+                sxm1*sqrt(x + 1)/sx2m1 * atanh(sx2m1/x))
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return cosh
+
+    def _eval_is_zero(self):
+        if (self.args[0] - 1).is_zero:
+            return True
+
+
+class atanh(InverseHyperbolicFunction):
+    """
+    ``atanh(x)`` is the inverse hyperbolic tangent of ``x``.
+
+    The inverse hyperbolic tangent function.
+
+    Examples
+    ========
+
+    >>> from sympy import atanh
+    >>> from sympy.abc import x
+    >>> atanh(x).diff(x)
+    1/(1 - x**2)
+
+    See Also
+    ========
+
+    asinh, acosh, tanh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return S.Infinity
+            elif arg is S.NegativeOne:
+                return S.NegativeInfinity
+            elif arg is S.Infinity:
+                return -I * atan(arg)
+            elif arg is S.NegativeInfinity:
+                return I * atan(-arg)
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                from sympy.calculus.accumulationbounds import AccumBounds
+                return I*AccumBounds(-pi/2, pi/2)
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * atan(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if arg.is_zero:
+            return S.Zero
+
+        if isinstance(arg, tanh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return z
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor(2*i/pi)
+                even = f.is_even
+                m = z - I*f*pi/2
+                if even is True:
+                    return m
+                elif even is False:
+                    return m - I*pi/2
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # atanh
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, -1] U [1, oo)
+        if (1 - x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_negative:
+                    return self.func(x0) - I*pi
+            elif im(ndir).is_positive:
+                if x0.is_positive:
+                    return self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # atanh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, -1] U [1, oo)
+        if (1 - arg0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_negative:
+                    return res - I*pi
+            elif im(ndir).is_positive:
+                if arg0.is_positive:
+                    return res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return (log(1 + x) - log(1 - x)) / 2
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        f = sqrt(1/(x**2 - 1))
+        return (pi*x/(2*sqrt(-x**2)) -
+                sqrt(-x)*sqrt(1 - x**2)/sqrt(x)*f*asinh(f))
+
+    def _eval_is_zero(self):
+        if self.args[0].is_zero:
+            return True
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return tanh
+
+
+class acoth(InverseHyperbolicFunction):
+    """
+    ``acoth(x)`` is the inverse hyperbolic cotangent of ``x``.
+
+    The inverse hyperbolic cotangent function.
+
+    Examples
+    ========
+
+    >>> from sympy import acoth
+    >>> from sympy.abc import x
+    >>> acoth(x).diff(x)
+    1/(1 - x**2)
+
+    See Also
+    ========
+
+    asinh, acosh, coth
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return pi*I / 2
+            elif arg is S.One:
+                return S.Infinity
+            elif arg is S.NegativeOne:
+                return S.NegativeInfinity
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.Zero
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return -I * acot(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if arg.is_zero:
+            return pi*I*S.Half
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return -I*pi/2
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return x**n / n
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # acoth
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts [-1, 1]
+        if x0.is_real and (1 - x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_positive:
+                    return self.func(x0) + I*pi
+            elif im(ndir).is_positive:
+                if x0.is_negative:
+                    return self.func(x0) - I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acoth
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts [-1, 1]
+        if arg0.is_real and (1 - arg0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_positive:
+                    return res + I*pi
+            elif im(ndir).is_positive:
+                if arg0.is_negative:
+                    return res - I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return (log(1 + 1/x) - log(1 - 1/x)) / 2
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return atanh(1/x)
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        return (pi*I/2*(sqrt((x - 1)/x)*sqrt(x/(x - 1)) - sqrt(1 + 1/x)*sqrt(x/(x + 1))) +
+                x*sqrt(1/x**2)*asinh(sqrt(1/(x**2 - 1))))
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return coth
+
+
+class asech(InverseHyperbolicFunction):
+    """
+    ``asech(x)`` is the inverse hyperbolic secant of ``x``.
+
+    The inverse hyperbolic secant function.
+
+    Examples
+    ========
+
+    >>> from sympy import asech, sqrt, S
+    >>> from sympy.abc import x
+    >>> asech(x).diff(x)
+    -1/(x*sqrt(1 - x**2))
+    >>> asech(1).diff(x)
+    0
+    >>> asech(1)
+    0
+    >>> asech(S(2))
+    I*pi/3
+    >>> asech(-sqrt(2))
+    3*I*pi/4
+    >>> asech((sqrt(6) - sqrt(2)))
+    I*pi/12
+
+    See Also
+    ========
+
+    asinh, atanh, cosh, acoth
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [2] https://dlmf.nist.gov/4.37
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcSech/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -1/(z*sqrt(1 - z**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return pi*I / 2
+            elif arg is S.NegativeInfinity:
+                return pi*I / 2
+            elif arg.is_zero:
+                return S.Infinity
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi*I
+
+        if arg.is_number:
+            cst_table = _asech_table()
+
+            if arg in cst_table:
+                if arg.is_extended_real:
+                    return cst_table[arg]*I
+                return cst_table[arg]
+
+        if arg is S.ComplexInfinity:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            return I*AccumBounds(-pi/2, pi/2)
+
+        if arg.is_zero:
+            return S.Infinity
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return log(2 / x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) * n
+                F = factorial(k) * n // 2 * n // 2
+                return -1 * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # asech
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-S.One, S.Zero, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, 0] U (1, oo)
+        if x0.is_negative or (1 - x0).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_positive:
+                if x0.is_positive or (x0 + 1).is_negative:
+                    return -self.func(x0)
+                return self.func(x0) - 2*I*pi
+            elif not im(ndir).is_negative:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asech
+        from sympy.series.order import O
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 is S.One:
+            t = Dummy('t', positive=True)
+            ser = asech(S.One - t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One - self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        if arg0 is S.NegativeOne:
+            t = Dummy('t', positive=True)
+            ser = asech(S.NegativeOne + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else I*pi + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, 0] U (1, oo)
+        if arg0.is_negative or (1 - arg0).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_positive:
+                if arg0.is_positive or (arg0 + 1).is_negative:
+                    return -res
+                return res - 2*I*pi
+            elif not im(ndir).is_negative:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sech
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return log(1/arg + sqrt(1/arg - 1) * sqrt(1/arg + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_acosh(self, arg, **kwargs):
+        return acosh(1/arg)
+
+    def _eval_rewrite_as_asinh(self, arg, **kwargs):
+        return sqrt(1/arg - 1)/sqrt(1 - 1/arg)*(I*asinh(I/arg)
+                                                + pi*S.Half)
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return (I*pi*(1 - sqrt(x)*sqrt(1/x) - I/2*sqrt(-x)/sqrt(x) - I/2*sqrt(x**2)/sqrt(-x**2))
+                + sqrt(1/(x + 1))*sqrt(x + 1)*atanh(sqrt(1 - x**2)))
+
+    def _eval_rewrite_as_acsch(self, x, **kwargs):
+        return sqrt(1/x - 1)/sqrt(1 - 1/x)*(pi/2 - I*acsch(I*x))
+
+
+class acsch(InverseHyperbolicFunction):
+    """
+    ``acsch(x)`` is the inverse hyperbolic cosecant of ``x``.
+
+    The inverse hyperbolic cosecant function.
+
+    Examples
+    ========
+
+    >>> from sympy import acsch, sqrt, I
+    >>> from sympy.abc import x
+    >>> acsch(x).diff(x)
+    -1/(x**2*sqrt(1 + x**(-2)))
+    >>> acsch(1).diff(x)
+    0
+    >>> acsch(1)
+    log(1 + sqrt(2))
+    >>> acsch(I)
+    -I*pi/2
+    >>> acsch(-2*I)
+    I*pi/6
+    >>> acsch(I*(sqrt(6) - sqrt(2)))
+    -5*I*pi/12
+
+    See Also
+    ========
+
+    asinh
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [2] https://dlmf.nist.gov/4.37
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcCsch/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -1/(z**2*sqrt(1 + 1/z**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return S.ComplexInfinity
+            elif arg is S.One:
+                return log(1 + sqrt(2))
+            elif arg is S.NegativeOne:
+                return - log(1 + sqrt(2))
+
+        if arg.is_number:
+            cst_table = _acsch_table()
+
+            if arg in cst_table:
+                return cst_table[arg]*I
+
+        if arg is S.ComplexInfinity:
+            return S.Zero
+
+        if arg.is_infinite:
+            return S.Zero
+
+        if arg.is_zero:
+            return S.ComplexInfinity
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return log(2 / x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return -p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) *  n
+                F = factorial(k) * n // 2 * n // 2
+                return S.NegativeOne**(k +1) * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):  # acsch
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-I, I, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        # Handling points lying on branch cuts (-I, I)
+        if x0.is_imaginary and (1 + x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(x0).is_positive:
+                    return -self.func(x0) - I*pi
+            elif re(ndir).is_negative:
+                if im(x0).is_negative:
+                    return -self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acsch
+        from sympy.series.order import O
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 is I:
+            t = Dummy('t', positive=True)
+            ser = acsch(I + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = -I + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else -I*pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            res = ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+            return res
+
+        if arg0 == S.NegativeOne*I:
+            t = Dummy('t', positive=True)
+            ser = acsch(-I + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = I + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else I*pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = Function._eval_nseries(self, x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-I, I)
+        if arg0.is_imaginary and (1 + arg0**2).is_positive:
+            ndir = self.args[0].dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(arg0).is_positive:
+                    return -res - I*pi
+            elif re(ndir).is_negative:
+                if im(arg0).is_negative:
+                    return -res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return csch
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return log(1/arg + sqrt(1/arg**2 + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asinh(self, arg, **kwargs):
+        return asinh(1/arg)
+
+    def _eval_rewrite_as_acosh(self, arg, **kwargs):
+        return I*(sqrt(1 - I/arg)/sqrt(I/arg - 1)*
+                                acosh(I/arg) - pi*S.Half)
+
+    def _eval_rewrite_as_atanh(self, arg, **kwargs):
+        arg2 = arg**2
+        arg2p1 = arg2 + 1
+        return sqrt(-arg2)/arg*(pi*S.Half -
+                                sqrt(-arg2p1**2)/arg2p1*atanh(sqrt(arg2p1)))
+
+    def _eval_is_zero(self):
+        return self.args[0].is_infinite

venv/lib/python3.10/site-packages/sympy/functions/elementary/integers.py

@@ -0,0 +1,625 @@
+from typing import Tuple as tTuple
+
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+
+from sympy.core import Add, S
+from sympy.core.evalf import get_integer_part, PrecisionExhausted
+from sympy.core.function import Function
+from sympy.core.logic import fuzzy_or
+from sympy.core.numbers import Integer
+from sympy.core.relational import Gt, Lt, Ge, Le, Relational, is_eq
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.complexes import im, re
+from sympy.multipledispatch import dispatch
+
+###############################################################################
+######################### FLOOR and CEILING FUNCTIONS #########################
+###############################################################################
+
+
+class RoundFunction(Function):
+    """Abstract base class for rounding functions."""
+
+    args: tTuple[Expr]
+
+    @classmethod
+    def eval(cls, arg):
+        v = cls._eval_number(arg)
+        if v is not None:
+            return v
+
+        if arg.is_integer or arg.is_finite is False:
+            return arg
+        if arg.is_imaginary or (S.ImaginaryUnit*arg).is_real:
+            i = im(arg)
+            if not i.has(S.ImaginaryUnit):
+                return cls(i)*S.ImaginaryUnit
+            return cls(arg, evaluate=False)
+
+        # Integral, numerical, symbolic part
+        ipart = npart = spart = S.Zero
+
+        # Extract integral (or complex integral) terms
+        terms = Add.make_args(arg)
+
+        for t in terms:
+            if t.is_integer or (t.is_imaginary and im(t).is_integer):
+                ipart += t
+            elif t.has(Symbol):
+                spart += t
+            else:
+                npart += t
+
+        if not (npart or spart):
+            return ipart
+
+        # Evaluate npart numerically if independent of spart
+        if npart and (
+            not spart or
+            npart.is_real and (spart.is_imaginary or (S.ImaginaryUnit*spart).is_real) or
+                npart.is_imaginary and spart.is_real):
+            try:
+                r, i = get_integer_part(
+                    npart, cls._dir, {}, return_ints=True)
+                ipart += Integer(r) + Integer(i)*S.ImaginaryUnit
+                npart = S.Zero
+            except (PrecisionExhausted, NotImplementedError):
+                pass
+
+        spart += npart
+        if not spart:
+            return ipart
+        elif spart.is_imaginary or (S.ImaginaryUnit*spart).is_real:
+            return ipart + cls(im(spart), evaluate=False)*S.ImaginaryUnit
+        elif isinstance(spart, (floor, ceiling)):
+            return ipart + spart
+        else:
+            return ipart + cls(spart, evaluate=False)
+
+    @classmethod
+    def _eval_number(cls, arg):
+        raise NotImplementedError()
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+    def _eval_is_real(self):
+        return self.args[0].is_real
+
+    def _eval_is_integer(self):
+        return self.args[0].is_real
+
+
+class floor(RoundFunction):
+    """
+    Floor is a univariate function which returns the largest integer
+    value not greater than its argument. This implementation
+    generalizes floor to complex numbers by taking the floor of the
+    real and imaginary parts separately.
+
+    Examples
+    ========
+
+    >>> from sympy import floor, E, I, S, Float, Rational
+    >>> floor(17)
+    17
+    >>> floor(Rational(23, 10))
+    2
+    >>> floor(2*E)
+    5
+    >>> floor(-Float(0.567))
+    -1
+    >>> floor(-I/2)
+    -I
+    >>> floor(S(5)/2 + 5*I/2)
+    2 + 2*I
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.ceiling
+
+    References
+    ==========
+
+    .. [1] "Concrete mathematics" by Graham, pp. 87
+    .. [2] https://mathworld.wolfram.com/FloorFunction.html
+
+    """
+    _dir = -1
+
+    @classmethod
+    def _eval_number(cls, arg):
+        if arg.is_Number:
+            return arg.floor()
+        elif any(isinstance(i, j)
+                for i in (arg, -arg) for j in (floor, ceiling)):
+            return arg
+        if arg.is_NumberSymbol:
+            return arg.approximation_interval(Integer)[0]
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN or isinstance(arg0, AccumBounds):
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = floor(arg0)
+        if arg0.is_finite:
+            if arg0 == r:
+                ndir = arg.dir(x, cdir=cdir)
+                return r - 1 if ndir.is_negative else r
+            else:
+                return r
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = floor(arg0)
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            from sympy.series.order import Order
+            s = arg._eval_nseries(x, n, logx, cdir)
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(-1, 0)
+            return s + o
+        if arg0 == r:
+            ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+            return r - 1 if ndir.is_negative else r
+        else:
+            return r
+
+    def _eval_is_negative(self):
+        return self.args[0].is_negative
+
+    def _eval_is_nonnegative(self):
+        return self.args[0].is_nonnegative
+
+    def _eval_rewrite_as_ceiling(self, arg, **kwargs):
+        return -ceiling(-arg)
+
+    def _eval_rewrite_as_frac(self, arg, **kwargs):
+        return arg - frac(arg)
+
+    def __le__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] < other + 1
+            if other.is_number and other.is_real:
+                return self.args[0] < ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.true
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Le(self, other, evaluate=False)
+
+    def __ge__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] >= other
+            if other.is_number and other.is_real:
+                return self.args[0] >= ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Ge(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] >= other + 1
+            if other.is_number and other.is_real:
+                return self.args[0] >= ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Gt(self, other, evaluate=False)
+
+    def __lt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] < other
+            if other.is_number and other.is_real:
+                return self.args[0] < ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Lt(self, other, evaluate=False)
+
+
+@dispatch(floor, Expr)
+def _eval_is_eq(lhs, rhs): # noqa:F811
+   return is_eq(lhs.rewrite(ceiling), rhs) or \
+        is_eq(lhs.rewrite(frac),rhs)
+
+
+class ceiling(RoundFunction):
+    """
+    Ceiling is a univariate function which returns the smallest integer
+    value not less than its argument. This implementation
+    generalizes ceiling to complex numbers by taking the ceiling of the
+    real and imaginary parts separately.
+
+    Examples
+    ========
+
+    >>> from sympy import ceiling, E, I, S, Float, Rational
+    >>> ceiling(17)
+    17
+    >>> ceiling(Rational(23, 10))
+    3
+    >>> ceiling(2*E)
+    6
+    >>> ceiling(-Float(0.567))
+    0
+    >>> ceiling(I/2)
+    I
+    >>> ceiling(S(5)/2 + 5*I/2)
+    3 + 3*I
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.floor
+
+    References
+    ==========
+
+    .. [1] "Concrete mathematics" by Graham, pp. 87
+    .. [2] https://mathworld.wolfram.com/CeilingFunction.html
+
+    """
+    _dir = 1
+
+    @classmethod
+    def _eval_number(cls, arg):
+        if arg.is_Number:
+            return arg.ceiling()
+        elif any(isinstance(i, j)
+                for i in (arg, -arg) for j in (floor, ceiling)):
+            return arg
+        if arg.is_NumberSymbol:
+            return arg.approximation_interval(Integer)[1]
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN or isinstance(arg0, AccumBounds):
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = ceiling(arg0)
+        if arg0.is_finite:
+            if arg0 == r:
+                ndir = arg.dir(x, cdir=cdir)
+                return r if ndir.is_negative else r + 1
+            else:
+                return r
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = ceiling(arg0)
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            from sympy.series.order import Order
+            s = arg._eval_nseries(x, n, logx, cdir)
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(0, 1)
+            return s + o
+        if arg0 == r:
+            ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+            return r if ndir.is_negative else r + 1
+        else:
+            return r
+
+    def _eval_rewrite_as_floor(self, arg, **kwargs):
+        return -floor(-arg)
+
+    def _eval_rewrite_as_frac(self, arg, **kwargs):
+        return arg + frac(-arg)
+
+    def _eval_is_positive(self):
+        return self.args[0].is_positive
+
+    def _eval_is_nonpositive(self):
+        return self.args[0].is_nonpositive
+
+    def __lt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] <= other - 1
+            if other.is_number and other.is_real:
+                return self.args[0] <= floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Lt(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] > other
+            if other.is_number and other.is_real:
+                return self.args[0] > floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Gt(self, other, evaluate=False)
+
+    def __ge__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] > other - 1
+            if other.is_number and other.is_real:
+                return self.args[0] > floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.true
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Ge(self, other, evaluate=False)
+
+    def __le__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] <= other
+            if other.is_number and other.is_real:
+                return self.args[0] <= floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Le(self, other, evaluate=False)
+
+
+@dispatch(ceiling, Basic)  # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    return is_eq(lhs.rewrite(floor), rhs) or is_eq(lhs.rewrite(frac),rhs)
+
+
+class frac(Function):
+    r"""Represents the fractional part of x
+
+    For real numbers it is defined [1]_ as
+
+    .. math::
+        x - \left\lfloor{x}\right\rfloor
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, frac, Rational, floor, I
+    >>> frac(Rational(4, 3))
+    1/3
+    >>> frac(-Rational(4, 3))
+    2/3
+
+    returns zero for integer arguments
+
+    >>> n = Symbol('n', integer=True)
+    >>> frac(n)
+    0
+
+    rewrite as floor
+
+    >>> x = Symbol('x')
+    >>> frac(x).rewrite(floor)
+    x - floor(x)
+
+    for complex arguments
+
+    >>> r = Symbol('r', real=True)
+    >>> t = Symbol('t', real=True)
+    >>> frac(t + I*r)
+    I*frac(r) + frac(t)
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.floor
+    sympy.functions.elementary.integers.ceiling
+
+    References
+    ===========
+
+    .. [1] https://en.wikipedia.org/wiki/Fractional_part
+    .. [2] https://mathworld.wolfram.com/FractionalPart.html
+
+    """
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus.accumulationbounds import AccumBounds
+
+        def _eval(arg):
+            if arg in (S.Infinity, S.NegativeInfinity):
+                return AccumBounds(0, 1)
+            if arg.is_integer:
+                return S.Zero
+            if arg.is_number:
+                if arg is S.NaN:
+                    return S.NaN
+                elif arg is S.ComplexInfinity:
+                    return S.NaN
+                else:
+                    return arg - floor(arg)
+            return cls(arg, evaluate=False)
+
+        terms = Add.make_args(arg)
+        real, imag = S.Zero, S.Zero
+        for t in terms:
+            # Two checks are needed for complex arguments
+            # see issue-7649 for details
+            if t.is_imaginary or (S.ImaginaryUnit*t).is_real:
+                i = im(t)
+                if not i.has(S.ImaginaryUnit):
+                    imag += i
+                else:
+                    real += t
+            else:
+                real += t
+
+        real = _eval(real)
+        imag = _eval(imag)
+        return real + S.ImaginaryUnit*imag
+
+    def _eval_rewrite_as_floor(self, arg, **kwargs):
+        return arg - floor(arg)
+
+    def _eval_rewrite_as_ceiling(self, arg, **kwargs):
+        return arg + ceiling(-arg)
+
+    def _eval_is_finite(self):
+        return True
+
+    def _eval_is_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def _eval_is_integer(self):
+        return self.args[0].is_integer
+
+    def _eval_is_zero(self):
+        return fuzzy_or([self.args[0].is_zero, self.args[0].is_integer])
+
+    def _eval_is_negative(self):
+        return False
+
+    def __ge__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other <= 0
+            if other.is_extended_nonpositive:
+                return S.true
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return not(res)
+        return Ge(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other < 0
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return not(res)
+            # Check if other >= 1
+            if other.is_extended_negative:
+                return S.true
+        return Gt(self, other, evaluate=False)
+
+    def __le__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other < 0
+            if other.is_extended_negative:
+                return S.false
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return res
+        return Le(self, other, evaluate=False)
+
+    def __lt__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other <= 0
+            if other.is_extended_nonpositive:
+                return S.false
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return res
+        return Lt(self, other, evaluate=False)
+
+    def _value_one_or_more(self, other):
+        if other.is_extended_real:
+            if other.is_number:
+                res = other >= 1
+                if res and not isinstance(res, Relational):
+                    return S.true
+            if other.is_integer and other.is_positive:
+                return S.true
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+
+        if arg0.is_finite:
+            if r.is_zero:
+                ndir = arg.dir(x, cdir=cdir)
+                if ndir.is_negative:
+                    return S.One
+                return (arg - arg0).as_leading_term(x, logx=logx, cdir=cdir)
+            else:
+                return r
+        elif arg0 in (S.ComplexInfinity, S.Infinity, S.NegativeInfinity):
+            return AccumBounds(0, 1)
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(0, 1) + Order(x**n, (x, 0))
+            return o
+        else:
+            res = (arg - arg0)._eval_nseries(x, n, logx=logx, cdir=cdir)
+            if r.is_zero:
+                ndir = arg.dir(x, cdir=cdir)
+                res += S.One if ndir.is_negative else S.Zero
+            else:
+                res += r
+            return res
+
+
+@dispatch(frac, Basic)  # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    if (lhs.rewrite(floor) == rhs) or \
+        (lhs.rewrite(ceiling) == rhs):
+        return True
+    # Check if other < 0
+    if rhs.is_extended_negative:
+        return False
+    # Check if other >= 1
+    res = lhs._value_one_or_more(rhs)
+    if res is not None:
+        return False

venv/lib/python3.10/site-packages/sympy/functions/elementary/miscellaneous.py

@@ -0,0 +1,915 @@
+from sympy.core import Function, S, sympify, NumberKind
+from sympy.utilities.iterables import sift
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.operations import LatticeOp, ShortCircuit
+from sympy.core.function import (Application, Lambda,
+    ArgumentIndexError)
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational
+from sympy.core.power import Pow
+from sympy.core.relational import Eq, Relational
+from sympy.core.singleton import Singleton
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.core.rules import Transform
+from sympy.core.logic import fuzzy_and, fuzzy_or, _torf
+from sympy.core.traversal import walk
+from sympy.core.numbers import Integer
+from sympy.logic.boolalg import And, Or
+
+
+def _minmax_as_Piecewise(op, *args):
+    # helper for Min/Max rewrite as Piecewise
+    from sympy.functions.elementary.piecewise import Piecewise
+    ec = []
+    for i, a in enumerate(args):
+        c = [Relational(a, args[j], op) for j in range(i + 1, len(args))]
+        ec.append((a, And(*c)))
+    return Piecewise(*ec)
+
+
+class IdentityFunction(Lambda, metaclass=Singleton):
+    """
+    The identity function
+
+    Examples
+    ========
+
+    >>> from sympy import Id, Symbol
+    >>> x = Symbol('x')
+    >>> Id(x)
+    x
+
+    """
+
+    _symbol = Dummy('x')
+
+    @property
+    def signature(self):
+        return Tuple(self._symbol)
+
+    @property
+    def expr(self):
+        return self._symbol
+
+
+Id = S.IdentityFunction
+
+###############################################################################
+############################# ROOT and SQUARE ROOT FUNCTION ###################
+###############################################################################
+
+
+def sqrt(arg, evaluate=None):
+    """Returns the principal square root.
+
+    Parameters
+    ==========
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, Symbol, S
+    >>> x = Symbol('x')
+
+    >>> sqrt(x)
+    sqrt(x)
+
+    >>> sqrt(x)**2
+    x
+
+    Note that sqrt(x**2) does not simplify to x.
+
+    >>> sqrt(x**2)
+    sqrt(x**2)
+
+    This is because the two are not equal to each other in general.
+    For example, consider x == -1:
+
+    >>> from sympy import Eq
+    >>> Eq(sqrt(x**2), x).subs(x, -1)
+    False
+
+    This is because sqrt computes the principal square root, so the square may
+    put the argument in a different branch.  This identity does hold if x is
+    positive:
+
+    >>> y = Symbol('y', positive=True)
+    >>> sqrt(y**2)
+    y
+
+    You can force this simplification by using the powdenest() function with
+    the force option set to True:
+
+    >>> from sympy import powdenest
+    >>> sqrt(x**2)
+    sqrt(x**2)
+    >>> powdenest(sqrt(x**2), force=True)
+    x
+
+    To get both branches of the square root you can use the rootof function:
+
+    >>> from sympy import rootof
+
+    >>> [rootof(x**2-3,i) for i in (0,1)]
+    [-sqrt(3), sqrt(3)]
+
+    Although ``sqrt`` is printed, there is no ``sqrt`` function so looking for
+    ``sqrt`` in an expression will fail:
+
+    >>> from sympy.utilities.misc import func_name
+    >>> func_name(sqrt(x))
+    'Pow'
+    >>> sqrt(x).has(sqrt)
+    False
+
+    To find ``sqrt`` look for ``Pow`` with an exponent of ``1/2``:
+
+    >>> (x + 1/sqrt(x)).find(lambda i: i.is_Pow and abs(i.exp) is S.Half)
+    {1/sqrt(x)}
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof, root, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_root
+    .. [2] https://en.wikipedia.org/wiki/Principal_value
+    """
+    # arg = sympify(arg) is handled by Pow
+    return Pow(arg, S.Half, evaluate=evaluate)
+
+
+def cbrt(arg, evaluate=None):
+    """Returns the principal cube root.
+
+    Parameters
+    ==========
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import cbrt, Symbol
+    >>> x = Symbol('x')
+
+    >>> cbrt(x)
+    x**(1/3)
+
+    >>> cbrt(x)**3
+    x
+
+    Note that cbrt(x**3) does not simplify to x.
+
+    >>> cbrt(x**3)
+    (x**3)**(1/3)
+
+    This is because the two are not equal to each other in general.
+    For example, consider `x == -1`:
+
+    >>> from sympy import Eq
+    >>> Eq(cbrt(x**3), x).subs(x, -1)
+    False
+
+    This is because cbrt computes the principal cube root, this
+    identity does hold if `x` is positive:
+
+    >>> y = Symbol('y', positive=True)
+    >>> cbrt(y**3)
+    y
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof, root, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cube_root
+    .. [2] https://en.wikipedia.org/wiki/Principal_value
+
+    """
+    return Pow(arg, Rational(1, 3), evaluate=evaluate)
+
+
+def root(arg, n, k=0, evaluate=None):
+    r"""Returns the *k*-th *n*-th root of ``arg``.
+
+    Parameters
+    ==========
+
+    k : int, optional
+        Should be an integer in $\{0, 1, ..., n-1\}$.
+        Defaults to the principal root if $0$.
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import root, Rational
+    >>> from sympy.abc import x, n
+
+    >>> root(x, 2)
+    sqrt(x)
+
+    >>> root(x, 3)
+    x**(1/3)
+
+    >>> root(x, n)
+    x**(1/n)
+
+    >>> root(x, -Rational(2, 3))
+    x**(-3/2)
+
+    To get the k-th n-th root, specify k:
+
+    >>> root(-2, 3, 2)
+    -(-1)**(2/3)*2**(1/3)
+
+    To get all n n-th roots you can use the rootof function.
+    The following examples show the roots of unity for n
+    equal 2, 3 and 4:
+
+    >>> from sympy import rootof
+
+    >>> [rootof(x**2 - 1, i) for i in range(2)]
+    [-1, 1]
+
+    >>> [rootof(x**3 - 1,i) for i in range(3)]
+    [1, -1/2 - sqrt(3)*I/2, -1/2 + sqrt(3)*I/2]
+
+    >>> [rootof(x**4 - 1,i) for i in range(4)]
+    [-1, 1, -I, I]
+
+    SymPy, like other symbolic algebra systems, returns the
+    complex root of negative numbers. This is the principal
+    root and differs from the text-book result that one might
+    be expecting. For example, the cube root of -8 does not
+    come back as -2:
+
+    >>> root(-8, 3)
+    2*(-1)**(1/3)
+
+    The real_root function can be used to either make the principal
+    result real (or simply to return the real root directly):
+
+    >>> from sympy import real_root
+    >>> real_root(_)
+    -2
+    >>> real_root(-32, 5)
+    -2
+
+    Alternatively, the n//2-th n-th root of a negative number can be
+    computed with root:
+
+    >>> root(-32, 5, 5//2)
+    -2
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof
+    sympy.core.power.integer_nthroot
+    sqrt, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_root
+    .. [2] https://en.wikipedia.org/wiki/Real_root
+    .. [3] https://en.wikipedia.org/wiki/Root_of_unity
+    .. [4] https://en.wikipedia.org/wiki/Principal_value
+    .. [5] https://mathworld.wolfram.com/CubeRoot.html
+
+    """
+    n = sympify(n)
+    if k:
+        return Mul(Pow(arg, S.One/n, evaluate=evaluate), S.NegativeOne**(2*k/n), evaluate=evaluate)
+    return Pow(arg, 1/n, evaluate=evaluate)
+
+
+def real_root(arg, n=None, evaluate=None):
+    r"""Return the real *n*'th-root of *arg* if possible.
+
+    Parameters
+    ==========
+
+    n : int or None, optional
+        If *n* is ``None``, then all instances of
+        $(-n)^{1/\text{odd}}$ will be changed to $-n^{1/\text{odd}}$.
+        This will only create a real root of a principal root.
+        The presence of other factors may cause the result to not be
+        real.
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import root, real_root
+
+    >>> real_root(-8, 3)
+    -2
+    >>> root(-8, 3)
+    2*(-1)**(1/3)
+    >>> real_root(_)
+    -2
+
+    If one creates a non-principal root and applies real_root, the
+    result will not be real (so use with caution):
+
+    >>> root(-8, 3, 2)
+    -2*(-1)**(2/3)
+    >>> real_root(_)
+    -2*(-1)**(2/3)
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof
+    sympy.core.power.integer_nthroot
+    root, sqrt
+    """
+    from sympy.functions.elementary.complexes import Abs, im, sign
+    from sympy.functions.elementary.piecewise import Piecewise
+    if n is not None:
+        return Piecewise(
+            (root(arg, n, evaluate=evaluate), Or(Eq(n, S.One), Eq(n, S.NegativeOne))),
+            (Mul(sign(arg), root(Abs(arg), n, evaluate=evaluate), evaluate=evaluate),
+            And(Eq(im(arg), S.Zero), Eq(Mod(n, 2), S.One))),
+            (root(arg, n, evaluate=evaluate), True))
+    rv = sympify(arg)
+    n1pow = Transform(lambda x: -(-x.base)**x.exp,
+                      lambda x:
+                      x.is_Pow and
+                      x.base.is_negative and
+                      x.exp.is_Rational and
+                      x.exp.p == 1 and x.exp.q % 2)
+    return rv.xreplace(n1pow)
+
+###############################################################################
+############################# MINIMUM and MAXIMUM #############################
+###############################################################################
+
+
+class MinMaxBase(Expr, LatticeOp):
+    def __new__(cls, *args, **assumptions):
+        from sympy.core.parameters import global_parameters
+        evaluate = assumptions.pop('evaluate', global_parameters.evaluate)
+        args = (sympify(arg) for arg in args)
+
+        # first standard filter, for cls.zero and cls.identity
+        # also reshape Max(a, Max(b, c)) to Max(a, b, c)
+
+        if evaluate:
+            try:
+                args = frozenset(cls._new_args_filter(args))
+            except ShortCircuit:
+                return cls.zero
+            # remove redundant args that are easily identified
+            args = cls._collapse_arguments(args, **assumptions)
+            # find local zeros
+            args = cls._find_localzeros(args, **assumptions)
+        args = frozenset(args)
+
+        if not args:
+            return cls.identity
+
+        if len(args) == 1:
+            return list(args).pop()
+
+        # base creation
+        obj = Expr.__new__(cls, *ordered(args), **assumptions)
+        obj._argset = args
+        return obj
+
+    @classmethod
+    def _collapse_arguments(cls, args, **assumptions):
+        """Remove redundant args.
+
+        Examples
+        ========
+
+        >>> from sympy import Min, Max
+        >>> from sympy.abc import a, b, c, d, e
+
+        Any arg in parent that appears in any
+        parent-like function in any of the flat args
+        of parent can be removed from that sub-arg:
+
+        >>> Min(a, Max(b, Min(a, c, d)))
+        Min(a, Max(b, Min(c, d)))
+
+        If the arg of parent appears in an opposite-than parent
+        function in any of the flat args of parent that function
+        can be replaced with the arg:
+
+        >>> Min(a, Max(b, Min(c, d, Max(a, e))))
+        Min(a, Max(b, Min(a, c, d)))
+        """
+        if not args:
+            return args
+        args = list(ordered(args))
+        if cls == Min:
+            other = Max
+        else:
+            other = Min
+
+        # find global comparable max of Max and min of Min if a new
+        # value is being introduced in these args at position 0 of
+        # the ordered args
+        if args[0].is_number:
+            sifted = mins, maxs = [], []
+            for i in args:
+                for v in walk(i, Min, Max):
+                    if v.args[0].is_comparable:
+                        sifted[isinstance(v, Max)].append(v)
+            small = Min.identity
+            for i in mins:
+                v = i.args[0]
+                if v.is_number and (v < small) == True:
+                    small = v
+            big = Max.identity
+            for i in maxs:
+                v = i.args[0]
+                if v.is_number and (v > big) == True:
+                    big = v
+            # at the point when this function is called from __new__,
+            # there may be more than one numeric arg present since
+            # local zeros have not been handled yet, so look through
+            # more than the first arg
+            if cls == Min:
+                for arg in args:
+                    if not arg.is_number:
+                        break
+                    if (arg < small) == True:
+                        small = arg
+            elif cls == Max:
+                for arg in args:
+                    if not arg.is_number:
+                        break
+                    if (arg > big) == True:
+                        big = arg
+            T = None
+            if cls == Min:
+                if small != Min.identity:
+                    other = Max
+                    T = small
+            elif big != Max.identity:
+                other = Min
+                T = big
+            if T is not None:
+                # remove numerical redundancy
+                for i in range(len(args)):
+                    a = args[i]
+                    if isinstance(a, other):
+                        a0 = a.args[0]
+                        if ((a0 > T) if other == Max else (a0 < T)) == True:
+                            args[i] = cls.identity
+
+        # remove redundant symbolic args
+        def do(ai, a):
+            if not isinstance(ai, (Min, Max)):
+                return ai
+            cond = a in ai.args
+            if not cond:
+                return ai.func(*[do(i, a) for i in ai.args],
+                    evaluate=False)
+            if isinstance(ai, cls):
+                return ai.func(*[do(i, a) for i in ai.args if i != a],
+                    evaluate=False)
+            return a
+        for i, a in enumerate(args):
+            args[i + 1:] = [do(ai, a) for ai in args[i + 1:]]
+
+        # factor out common elements as for
+        # Min(Max(x, y), Max(x, z)) -> Max(x, Min(y, z))
+        # and vice versa when swapping Min/Max -- do this only for the
+        # easy case where all functions contain something in common;
+        # trying to find some optimal subset of args to modify takes
+        # too long
+
+        def factor_minmax(args):
+            is_other = lambda arg: isinstance(arg, other)
+            other_args, remaining_args = sift(args, is_other, binary=True)
+            if not other_args:
+                return args
+
+            # Min(Max(x, y, z), Max(x, y, u, v)) -> {x,y}, ({z}, {u,v})
+            arg_sets = [set(arg.args) for arg in other_args]
+            common = set.intersection(*arg_sets)
+            if not common:
+                return args
+
+            new_other_args = list(common)
+            arg_sets_diff = [arg_set - common for arg_set in arg_sets]
+
+            # If any set is empty after removing common then all can be
+            # discarded e.g. Min(Max(a, b, c), Max(a, b)) -> Max(a, b)
+            if all(arg_sets_diff):
+                other_args_diff = [other(*s, evaluate=False) for s in arg_sets_diff]
+                new_other_args.append(cls(*other_args_diff, evaluate=False))
+
+            other_args_factored = other(*new_other_args, evaluate=False)
+            return remaining_args + [other_args_factored]
+
+        if len(args) > 1:
+            args = factor_minmax(args)
+
+        return args
+
+    @classmethod
+    def _new_args_filter(cls, arg_sequence):
+        """
+        Generator filtering args.
+
+        first standard filter, for cls.zero and cls.identity.
+        Also reshape ``Max(a, Max(b, c))`` to ``Max(a, b, c)``,
+        and check arguments for comparability
+        """
+        for arg in arg_sequence:
+            # pre-filter, checking comparability of arguments
+            if not isinstance(arg, Expr) or arg.is_extended_real is False or (
+                    arg.is_number and
+                    not arg.is_comparable):
+                raise ValueError("The argument '%s' is not comparable." % arg)
+
+            if arg == cls.zero:
+                raise ShortCircuit(arg)
+            elif arg == cls.identity:
+                continue
+            elif arg.func == cls:
+                yield from arg.args
+            else:
+                yield arg
+
+    @classmethod
+    def _find_localzeros(cls, values, **options):
+        """
+        Sequentially allocate values to localzeros.
+
+        When a value is identified as being more extreme than another member it
+        replaces that member; if this is never true, then the value is simply
+        appended to the localzeros.
+        """
+        localzeros = set()
+        for v in values:
+            is_newzero = True
+            localzeros_ = list(localzeros)
+            for z in localzeros_:
+                if id(v) == id(z):
+                    is_newzero = False
+                else:
+                    con = cls._is_connected(v, z)
+                    if con:
+                        is_newzero = False
+                        if con is True or con == cls:
+                            localzeros.remove(z)
+                            localzeros.update([v])
+            if is_newzero:
+                localzeros.update([v])
+        return localzeros
+
+    @classmethod
+    def _is_connected(cls, x, y):
+        """
+        Check if x and y are connected somehow.
+        """
+        for i in range(2):
+            if x == y:
+                return True
+            t, f = Max, Min
+            for op in "><":
+                for j in range(2):
+                    try:
+                        if op == ">":
+                            v = x >= y
+                        else:
+                            v = x <= y
+                    except TypeError:
+                        return False  # non-real arg
+                    if not v.is_Relational:
+                        return t if v else f
+                    t, f = f, t
+                    x, y = y, x
+                x, y = y, x  # run next pass with reversed order relative to start
+            # simplification can be expensive, so be conservative
+            # in what is attempted
+            x = factor_terms(x - y)
+            y = S.Zero
+
+        return False
+
+    def _eval_derivative(self, s):
+        # f(x).diff(s) -> x.diff(s) * f.fdiff(1)(s)
+        i = 0
+        l = []
+        for a in self.args:
+            i += 1
+            da = a.diff(s)
+            if da.is_zero:
+                continue
+            try:
+                df = self.fdiff(i)
+            except ArgumentIndexError:
+                df = Function.fdiff(self, i)
+            l.append(df * da)
+        return Add(*l)
+
+    def _eval_rewrite_as_Abs(self, *args, **kwargs):
+        from sympy.functions.elementary.complexes import Abs
+        s = (args[0] + self.func(*args[1:]))/2
+        d = abs(args[0] - self.func(*args[1:]))/2
+        return (s + d if isinstance(self, Max) else s - d).rewrite(Abs)
+
+    def evalf(self, n=15, **options):
+        return self.func(*[a.evalf(n, **options) for a in self.args])
+
+    def n(self, *args, **kwargs):
+        return self.evalf(*args, **kwargs)
+
+    _eval_is_algebraic = lambda s: _torf(i.is_algebraic for i in s.args)
+    _eval_is_antihermitian = lambda s: _torf(i.is_antihermitian for i in s.args)
+    _eval_is_commutative = lambda s: _torf(i.is_commutative for i in s.args)
+    _eval_is_complex = lambda s: _torf(i.is_complex for i in s.args)
+    _eval_is_composite = lambda s: _torf(i.is_composite for i in s.args)
+    _eval_is_even = lambda s: _torf(i.is_even for i in s.args)
+    _eval_is_finite = lambda s: _torf(i.is_finite for i in s.args)
+    _eval_is_hermitian = lambda s: _torf(i.is_hermitian for i in s.args)
+    _eval_is_imaginary = lambda s: _torf(i.is_imaginary for i in s.args)
+    _eval_is_infinite = lambda s: _torf(i.is_infinite for i in s.args)
+    _eval_is_integer = lambda s: _torf(i.is_integer for i in s.args)
+    _eval_is_irrational = lambda s: _torf(i.is_irrational for i in s.args)
+    _eval_is_negative = lambda s: _torf(i.is_negative for i in s.args)
+    _eval_is_noninteger = lambda s: _torf(i.is_noninteger for i in s.args)
+    _eval_is_nonnegative = lambda s: _torf(i.is_nonnegative for i in s.args)
+    _eval_is_nonpositive = lambda s: _torf(i.is_nonpositive for i in s.args)
+    _eval_is_nonzero = lambda s: _torf(i.is_nonzero for i in s.args)
+    _eval_is_odd = lambda s: _torf(i.is_odd for i in s.args)
+    _eval_is_polar = lambda s: _torf(i.is_polar for i in s.args)
+    _eval_is_positive = lambda s: _torf(i.is_positive for i in s.args)
+    _eval_is_prime = lambda s: _torf(i.is_prime for i in s.args)
+    _eval_is_rational = lambda s: _torf(i.is_rational for i in s.args)
+    _eval_is_real = lambda s: _torf(i.is_real for i in s.args)
+    _eval_is_extended_real = lambda s: _torf(i.is_extended_real for i in s.args)
+    _eval_is_transcendental = lambda s: _torf(i.is_transcendental for i in s.args)
+    _eval_is_zero = lambda s: _torf(i.is_zero for i in s.args)
+
+
+class Max(MinMaxBase, Application):
+    r"""
+    Return, if possible, the maximum value of the list.
+
+    When number of arguments is equal one, then
+    return this argument.
+
+    When number of arguments is equal two, then
+    return, if possible, the value from (a, b) that is $\ge$ the other.
+
+    In common case, when the length of list greater than 2, the task
+    is more complicated. Return only the arguments, which are greater
+    than others, if it is possible to determine directional relation.
+
+    If is not possible to determine such a relation, return a partially
+    evaluated result.
+
+    Assumptions are used to make the decision too.
+
+    Also, only comparable arguments are permitted.
+
+    It is named ``Max`` and not ``max`` to avoid conflicts
+    with the built-in function ``max``.
+
+
+    Examples
+    ========
+
+    >>> from sympy import Max, Symbol, oo
+    >>> from sympy.abc import x, y, z
+    >>> p = Symbol('p', positive=True)
+    >>> n = Symbol('n', negative=True)
+
+    >>> Max(x, -2)
+    Max(-2, x)
+    >>> Max(x, -2).subs(x, 3)
+    3
+    >>> Max(p, -2)
+    p
+    >>> Max(x, y)
+    Max(x, y)
+    >>> Max(x, y) == Max(y, x)
+    True
+    >>> Max(x, Max(y, z))
+    Max(x, y, z)
+    >>> Max(n, 8, p, 7, -oo)
+    Max(8, p)
+    >>> Max (1, x, oo)
+    oo
+
+    * Algorithm
+
+    The task can be considered as searching of supremums in the
+    directed complete partial orders [1]_.
+
+    The source values are sequentially allocated by the isolated subsets
+    in which supremums are searched and result as Max arguments.
+
+    If the resulted supremum is single, then it is returned.
+
+    The isolated subsets are the sets of values which are only the comparable
+    with each other in the current set. E.g. natural numbers are comparable with
+    each other, but not comparable with the `x` symbol. Another example: the
+    symbol `x` with negative assumption is comparable with a natural number.
+
+    Also there are "least" elements, which are comparable with all others,
+    and have a zero property (maximum or minimum for all elements).
+    For example, in case of $\infty$, the allocation operation is terminated
+    and only this value is returned.
+
+    Assumption:
+       - if $A > B > C$ then $A > C$
+       - if $A = B$ then $B$ can be removed
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Directed_complete_partial_order
+    .. [2] https://en.wikipedia.org/wiki/Lattice_%28order%29
+
+    See Also
+    ========
+
+    Min : find minimum values
+    """
+    zero = S.Infinity
+    identity = S.NegativeInfinity
+
+    def fdiff( self, argindex ):
+        from sympy.functions.special.delta_functions import Heaviside
+        n = len(self.args)
+        if 0 < argindex and argindex <= n:
+            argindex -= 1
+            if n == 2:
+                return Heaviside(self.args[argindex] - self.args[1 - argindex])
+            newargs = tuple([self.args[i] for i in range(n) if i != argindex])
+            return Heaviside(self.args[argindex] - Max(*newargs))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        return Add(*[j*Mul(*[Heaviside(j - i) for i in args if i!=j]) \
+                for j in args])
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        return _minmax_as_Piecewise('>=', *args)
+
+    def _eval_is_positive(self):
+        return fuzzy_or(a.is_positive for a in self.args)
+
+    def _eval_is_nonnegative(self):
+        return fuzzy_or(a.is_nonnegative for a in self.args)
+
+    def _eval_is_negative(self):
+        return fuzzy_and(a.is_negative for a in self.args)
+
+
+class Min(MinMaxBase, Application):
+    """
+    Return, if possible, the minimum value of the list.
+    It is named ``Min`` and not ``min`` to avoid conflicts
+    with the built-in function ``min``.
+
+    Examples
+    ========
+
+    >>> from sympy import Min, Symbol, oo
+    >>> from sympy.abc import x, y
+    >>> p = Symbol('p', positive=True)
+    >>> n = Symbol('n', negative=True)
+
+    >>> Min(x, -2)
+    Min(-2, x)
+    >>> Min(x, -2).subs(x, 3)
+    -2
+    >>> Min(p, -3)
+    -3
+    >>> Min(x, y)
+    Min(x, y)
+    >>> Min(n, 8, p, -7, p, oo)
+    Min(-7, n)
+
+    See Also
+    ========
+
+    Max : find maximum values
+    """
+    zero = S.NegativeInfinity
+    identity = S.Infinity
+
+    def fdiff( self, argindex ):
+        from sympy.functions.special.delta_functions import Heaviside
+        n = len(self.args)
+        if 0 < argindex and argindex <= n:
+            argindex -= 1
+            if n == 2:
+                return Heaviside( self.args[1-argindex] - self.args[argindex] )
+            newargs = tuple([ self.args[i] for i in range(n) if i != argindex])
+            return Heaviside( Min(*newargs) - self.args[argindex] )
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        return Add(*[j*Mul(*[Heaviside(i-j) for i in args if i!=j]) \
+                for j in args])
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        return _minmax_as_Piecewise('<=', *args)
+
+    def _eval_is_positive(self):
+        return fuzzy_and(a.is_positive for a in self.args)
+
+    def _eval_is_nonnegative(self):
+        return fuzzy_and(a.is_nonnegative for a in self.args)
+
+    def _eval_is_negative(self):
+        return fuzzy_or(a.is_negative for a in self.args)
+
+
+class Rem(Function):
+    """Returns the remainder when ``p`` is divided by ``q`` where ``p`` is finite
+    and ``q`` is not equal to zero. The result, ``p - int(p/q)*q``, has the same sign
+    as the divisor.
+
+    Parameters
+    ==========
+
+    p : Expr
+        Dividend.
+
+    q : Expr
+        Divisor.
+
+    Notes
+    =====
+
+    ``Rem`` corresponds to the ``%`` operator in C.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import Rem
+    >>> Rem(x**3, y)
+    Rem(x**3, y)
+    >>> Rem(x**3, y).subs({x: -5, y: 3})
+    -2
+
+    See Also
+    ========
+
+    Mod
+    """
+    kind = NumberKind
+
+    @classmethod
+    def eval(cls, p, q):
+        """Return the function remainder if both p, q are numbers and q is not
+        zero.
+        """
+
+        if q.is_zero:
+            raise ZeroDivisionError("Division by zero")
+        if p is S.NaN or q is S.NaN or p.is_finite is False or q.is_finite is False:
+            return S.NaN
+        if p is S.Zero or p in (q, -q) or (p.is_integer and q == 1):
+            return S.Zero
+
+        if q.is_Number:
+            if p.is_Number:
+                return p - Integer(p/q)*q

venv/lib/python3.10/site-packages/sympy/functions/elementary/piecewise.py

@@ -0,0 +1,1506 @@
+from sympy.core import S, Function, diff, Tuple, Dummy, Mul
+from sympy.core.basic import Basic, as_Basic
+from sympy.core.numbers import Rational, NumberSymbol, _illegal
+from sympy.core.parameters import global_parameters
+from sympy.core.relational import (Lt, Gt, Eq, Ne, Relational,
+    _canonical, _canonical_coeff)
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.miscellaneous import Max, Min
+from sympy.logic.boolalg import (And, Boolean, distribute_and_over_or, Not,
+    true, false, Or, ITE, simplify_logic, to_cnf, distribute_or_over_and)
+from sympy.utilities.iterables import uniq, sift, common_prefix
+from sympy.utilities.misc import filldedent, func_name
+
+from itertools import product
+
+Undefined = S.NaN  # Piecewise()
+
+class ExprCondPair(Tuple):
+    """Represents an expression, condition pair."""
+
+    def __new__(cls, expr, cond):
+        expr = as_Basic(expr)
+        if cond == True:
+            return Tuple.__new__(cls, expr, true)
+        elif cond == False:
+            return Tuple.__new__(cls, expr, false)
+        elif isinstance(cond, Basic) and cond.has(Piecewise):
+            cond = piecewise_fold(cond)
+            if isinstance(cond, Piecewise):
+                cond = cond.rewrite(ITE)
+
+        if not isinstance(cond, Boolean):
+            raise TypeError(filldedent('''
+                Second argument must be a Boolean,
+                not `%s`''' % func_name(cond)))
+        return Tuple.__new__(cls, expr, cond)
+
+    @property
+    def expr(self):
+        """
+        Returns the expression of this pair.
+        """
+        return self.args[0]
+
+    @property
+    def cond(self):
+        """
+        Returns the condition of this pair.
+        """
+        return self.args[1]
+
+    @property
+    def is_commutative(self):
+        return self.expr.is_commutative
+
+    def __iter__(self):
+        yield self.expr
+        yield self.cond
+
+    def _eval_simplify(self, **kwargs):
+        return self.func(*[a.simplify(**kwargs) for a in self.args])
+
+
+class Piecewise(Function):
+    """
+    Represents a piecewise function.
+
+    Usage:
+
+      Piecewise( (expr,cond), (expr,cond), ... )
+        - Each argument is a 2-tuple defining an expression and condition
+        - The conds are evaluated in turn returning the first that is True.
+          If any of the evaluated conds are not explicitly False,
+          e.g. ``x < 1``, the function is returned in symbolic form.
+        - If the function is evaluated at a place where all conditions are False,
+          nan will be returned.
+        - Pairs where the cond is explicitly False, will be removed and no pair
+          appearing after a True condition will ever be retained. If a single
+          pair with a True condition remains, it will be returned, even when
+          evaluation is False.
+
+    Examples
+    ========
+
+    >>> from sympy import Piecewise, log, piecewise_fold
+    >>> from sympy.abc import x, y
+    >>> f = x**2
+    >>> g = log(x)
+    >>> p = Piecewise((0, x < -1), (f, x <= 1), (g, True))
+    >>> p.subs(x,1)
+    1
+    >>> p.subs(x,5)
+    log(5)
+
+    Booleans can contain Piecewise elements:
+
+    >>> cond = (x < y).subs(x, Piecewise((2, x < 0), (3, True))); cond
+    Piecewise((2, x < 0), (3, True)) < y
+
+    The folded version of this results in a Piecewise whose
+    expressions are Booleans:
+
+    >>> folded_cond = piecewise_fold(cond); folded_cond
+    Piecewise((2 < y, x < 0), (3 < y, True))
+
+    When a Boolean containing Piecewise (like cond) or a Piecewise
+    with Boolean expressions (like folded_cond) is used as a condition,
+    it is converted to an equivalent :class:`~.ITE` object:
+
+    >>> Piecewise((1, folded_cond))
+    Piecewise((1, ITE(x < 0, y > 2, y > 3)))
+
+    When a condition is an ``ITE``, it will be converted to a simplified
+    Boolean expression:
+
+    >>> piecewise_fold(_)
+    Piecewise((1, ((x >= 0) | (y > 2)) & ((y > 3) | (x < 0))))
+
+    See Also
+    ========
+
+    piecewise_fold
+    piecewise_exclusive
+    ITE
+    """
+
+    nargs = None
+    is_Piecewise = True
+
+    def __new__(cls, *args, **options):
+        if len(args) == 0:
+            raise TypeError("At least one (expr, cond) pair expected.")
+        # (Try to) sympify args first
+        newargs = []
+        for ec in args:
+            # ec could be a ExprCondPair or a tuple
+            pair = ExprCondPair(*getattr(ec, 'args', ec))
+            cond = pair.cond
+            if cond is false:
+                continue
+            newargs.append(pair)
+            if cond is true:
+                break
+
+        eval = options.pop('evaluate', global_parameters.evaluate)
+        if eval:
+            r = cls.eval(*newargs)
+            if r is not None:
+                return r
+        elif len(newargs) == 1 and newargs[0].cond == True:
+            return newargs[0].expr
+
+        return Basic.__new__(cls, *newargs, **options)
+
+    @classmethod
+    def eval(cls, *_args):
+        """Either return a modified version of the args or, if no
+        modifications were made, return None.
+
+        Modifications that are made here:
+
+        1. relationals are made canonical
+        2. any False conditions are dropped
+        3. any repeat of a previous condition is ignored
+        4. any args past one with a true condition are dropped
+
+        If there are no args left, nan will be returned.
+        If there is a single arg with a True condition, its
+        corresponding expression will be returned.
+
+        EXAMPLES
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> cond = -x < -1
+        >>> args = [(1, cond), (4, cond), (3, False), (2, True), (5, x < 1)]
+        >>> Piecewise(*args, evaluate=False)
+        Piecewise((1, -x < -1), (4, -x < -1), (2, True))
+        >>> Piecewise(*args)
+        Piecewise((1, x > 1), (2, True))
+        """
+        if not _args:
+            return Undefined
+
+        if len(_args) == 1 and _args[0][-1] == True:
+            return _args[0][0]
+
+        newargs = _piecewise_collapse_arguments(_args)
+
+        # some conditions may have been redundant
+        missing = len(newargs) != len(_args)
+        # some conditions may have changed
+        same = all(a == b for a, b in zip(newargs, _args))
+        # if either change happened we return the expr with the
+        # updated args
+        if not newargs:
+            raise ValueError(filldedent('''
+                There are no conditions (or none that
+                are not trivially false) to define an
+                expression.'''))
+        if missing or not same:
+            return cls(*newargs)
+
+    def doit(self, **hints):
+        """
+        Evaluate this piecewise function.
+        """
+        newargs = []
+        for e, c in self.args:
+            if hints.get('deep', True):
+                if isinstance(e, Basic):
+                    newe = e.doit(**hints)
+                    if newe != self:
+                        e = newe
+                if isinstance(c, Basic):
+                    c = c.doit(**hints)
+            newargs.append((e, c))
+        return self.func(*newargs)
+
+    def _eval_simplify(self, **kwargs):
+        return piecewise_simplify(self, **kwargs)
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        for e, c in self.args:
+            if c == True or c.subs(x, 0) == True:
+                return e.as_leading_term(x)
+
+    def _eval_adjoint(self):
+        return self.func(*[(e.adjoint(), c) for e, c in self.args])
+
+    def _eval_conjugate(self):
+        return self.func(*[(e.conjugate(), c) for e, c in self.args])
+
+    def _eval_derivative(self, x):
+        return self.func(*[(diff(e, x), c) for e, c in self.args])
+
+    def _eval_evalf(self, prec):
+        return self.func(*[(e._evalf(prec), c) for e, c in self.args])
+
+    def _eval_is_meromorphic(self, x, a):
+        # Conditions often implicitly assume that the argument is real.
+        # Hence, there needs to be some check for as_set.
+        if not a.is_real:
+            return None
+
+        # Then, scan ExprCondPairs in the given order to find a piece that would contain a,
+        # possibly as a boundary point.
+        for e, c in self.args:
+            cond = c.subs(x, a)
+
+            if cond.is_Relational:
+                return None
+            if a in c.as_set().boundary:
+                return None
+            # Apply expression if a is an interior point of the domain of e.
+            if cond:
+                return e._eval_is_meromorphic(x, a)
+
+    def piecewise_integrate(self, x, **kwargs):
+        """Return the Piecewise with each expression being
+        replaced with its antiderivative. To obtain a continuous
+        antiderivative, use the :func:`~.integrate` function or method.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
+        >>> p.piecewise_integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x, True))
+
+        Note that this does not give a continuous function, e.g.
+        at x = 1 the 3rd condition applies and the antiderivative
+        there is 2*x so the value of the antiderivative is 2:
+
+        >>> anti = _
+        >>> anti.subs(x, 1)
+        2
+
+        The continuous derivative accounts for the integral *up to*
+        the point of interest, however:
+
+        >>> p.integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
+        >>> _.subs(x, 1)
+        1
+
+        See Also
+        ========
+        Piecewise._eval_integral
+        """
+        from sympy.integrals import integrate
+        return self.func(*[(integrate(e, x, **kwargs), c) for e, c in self.args])
+
+    def _handle_irel(self, x, handler):
+        """Return either None (if the conditions of self depend only on x) else
+        a Piecewise expression whose expressions (handled by the handler that
+        was passed) are paired with the governing x-independent relationals,
+        e.g. Piecewise((A, a(x) & b(y)), (B, c(x) | c(y)) ->
+        Piecewise(
+            (handler(Piecewise((A, a(x) & True), (B, c(x) | True)), b(y) & c(y)),
+            (handler(Piecewise((A, a(x) & True), (B, c(x) | False)), b(y)),
+            (handler(Piecewise((A, a(x) & False), (B, c(x) | True)), c(y)),
+            (handler(Piecewise((A, a(x) & False), (B, c(x) | False)), True))
+        """
+        # identify governing relationals
+        rel = self.atoms(Relational)
+        irel = list(ordered([r for r in rel if x not in r.free_symbols
+            and r not in (S.true, S.false)]))
+        if irel:
+            args = {}
+            exprinorder = []
+            for truth in product((1, 0), repeat=len(irel)):
+                reps = dict(zip(irel, truth))
+                # only store the true conditions since the false are implied
+                # when they appear lower in the Piecewise args
+                if 1 not in truth:
+                    cond = None  # flag this one so it doesn't get combined
+                else:
+                    andargs = Tuple(*[i for i in reps if reps[i]])
+                    free = list(andargs.free_symbols)
+                    if len(free) == 1:
+                        from sympy.solvers.inequalities import (
+                            reduce_inequalities, _solve_inequality)
+                        try:
+                            t = reduce_inequalities(andargs, free[0])
+                            # ValueError when there are potentially
+                            # nonvanishing imaginary parts
+                        except (ValueError, NotImplementedError):
+                            # at least isolate free symbol on left
+                            t = And(*[_solve_inequality(
+                                a, free[0], linear=True)
+                                for a in andargs])
+                    else:
+                        t = And(*andargs)
+                    if t is S.false:
+                        continue  # an impossible combination
+                    cond = t
+                expr = handler(self.xreplace(reps))
+                if isinstance(expr, self.func) and len(expr.args) == 1:
+                    expr, econd = expr.args[0]
+                    cond = And(econd, True if cond is None else cond)
+                # the ec pairs are being collected since all possibilities
+                # are being enumerated, but don't put the last one in since
+                # its expr might match a previous expression and it
+                # must appear last in the args
+                if cond is not None:
+                    args.setdefault(expr, []).append(cond)
+                    # but since we only store the true conditions we must maintain
+                    # the order so that the expression with the most true values
+                    # comes first
+                    exprinorder.append(expr)
+            # convert collected conditions as args of Or
+            for k in args:
+                args[k] = Or(*args[k])
+            # take them in the order obtained
+            args = [(e, args[e]) for e in uniq(exprinorder)]
+            # add in the last arg
+            args.append((expr, True))
+            return Piecewise(*args)
+
+    def _eval_integral(self, x, _first=True, **kwargs):
+        """Return the indefinite integral of the
+        Piecewise such that subsequent substitution of x with a
+        value will give the value of the integral (not including
+        the constant of integration) up to that point. To only
+        integrate the individual parts of Piecewise, use the
+        ``piecewise_integrate`` method.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
+        >>> p.integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
+        >>> p.piecewise_integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x, True))
+
+        See Also
+        ========
+        Piecewise.piecewise_integrate
+        """
+        from sympy.integrals.integrals import integrate
+
+        if _first:
+            def handler(ipw):
+                if isinstance(ipw, self.func):
+                    return ipw._eval_integral(x, _first=False, **kwargs)
+                else:
+                    return ipw.integrate(x, **kwargs)
+            irv = self._handle_irel(x, handler)
+            if irv is not None:
+                return irv
+
+        # handle a Piecewise from -oo to oo with and no x-independent relationals
+        # -----------------------------------------------------------------------
+        ok, abei = self._intervals(x)
+        if not ok:
+            from sympy.integrals.integrals import Integral
+            return Integral(self, x)  # unevaluated
+
+        pieces = [(a, b) for a, b, _, _ in abei]
+        oo = S.Infinity
+        done = [(-oo, oo, -1)]
+        for k, p in enumerate(pieces):
+            if p == (-oo, oo):
+                # all undone intervals will get this key
+                for j, (a, b, i) in enumerate(done):
+                    if i == -1:
+                        done[j] = a, b, k
+                break  # nothing else to consider
+            N = len(done) - 1
+            for j, (a, b, i) in enumerate(reversed(done)):
+                if i == -1:
+                    j = N - j
+                    done[j: j + 1] = _clip(p, (a, b), k)
+        done = [(a, b, i) for a, b, i in done if a != b]
+
+        # append an arg if there is a hole so a reference to
+        # argument -1 will give Undefined
+        if any(i == -1 for (a, b, i) in done):
+            abei.append((-oo, oo, Undefined, -1))
+
+        # return the sum of the intervals
+        args = []
+        sum = None
+        for a, b, i in done:
+            anti = integrate(abei[i][-2], x, **kwargs)
+            if sum is None:
+                sum = anti
+            else:
+                sum = sum.subs(x, a)
+                e = anti._eval_interval(x, a, x)
+                if sum.has(*_illegal) or e.has(*_illegal):
+                    sum = anti
+                else:
+                    sum += e
+            # see if we know whether b is contained in original
+            # condition
+            if b is S.Infinity:
+                cond = True
+            elif self.args[abei[i][-1]].cond.subs(x, b) == False:
+                cond = (x < b)
+            else:
+                cond = (x <= b)
+            args.append((sum, cond))
+        return Piecewise(*args)
+
+    def _eval_interval(self, sym, a, b, _first=True):
+        """Evaluates the function along the sym in a given interval [a, b]"""
+        # FIXME: Currently complex intervals are not supported.  A possible
+        # replacement algorithm, discussed in issue 5227, can be found in the
+        # following papers;
+        #     http://portal.acm.org/citation.cfm?id=281649
+        #     http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.70.4127&rep=rep1&type=pdf
+
+        if a is None or b is None:
+            # In this case, it is just simple substitution
+            return super()._eval_interval(sym, a, b)
+        else:
+            x, lo, hi = map(as_Basic, (sym, a, b))
+
+        if _first:  # get only x-dependent relationals
+            def handler(ipw):
+                if isinstance(ipw, self.func):
+                    return ipw._eval_interval(x, lo, hi, _first=None)
+                else:
+                    return ipw._eval_interval(x, lo, hi)
+            irv = self._handle_irel(x, handler)
+            if irv is not None:
+                return irv
+
+            if (lo < hi) is S.false or (
+                    lo is S.Infinity or hi is S.NegativeInfinity):
+                rv = self._eval_interval(x, hi, lo, _first=False)
+                if isinstance(rv, Piecewise):
+                    rv = Piecewise(*[(-e, c) for e, c in rv.args])
+                else:
+                    rv = -rv
+                return rv
+
+            if (lo < hi) is S.true or (
+                    hi is S.Infinity or lo is S.NegativeInfinity):
+                pass
+            else:
+                _a = Dummy('lo')
+                _b = Dummy('hi')
+                a = lo if lo.is_comparable else _a
+                b = hi if hi.is_comparable else _b
+                pos = self._eval_interval(x, a, b, _first=False)
+                if a == _a and b == _b:
+                    # it's purely symbolic so just swap lo and hi and
+                    # change the sign to get the value for when lo > hi
+                    neg, pos = (-pos.xreplace({_a: hi, _b: lo}),
+                        pos.xreplace({_a: lo, _b: hi}))
+                else:
+                    # at least one of the bounds was comparable, so allow
+                    # _eval_interval to use that information when computing
+                    # the interval with lo and hi reversed
+                    neg, pos = (-self._eval_interval(x, hi, lo, _first=False),
+                        pos.xreplace({_a: lo, _b: hi}))
+
+                # allow simplification based on ordering of lo and hi
+                p = Dummy('', positive=True)
+                if lo.is_Symbol:
+                    pos = pos.xreplace({lo: hi - p}).xreplace({p: hi - lo})
+                    neg = neg.xreplace({lo: hi + p}).xreplace({p: lo - hi})
+                elif hi.is_Symbol:
+                    pos = pos.xreplace({hi: lo + p}).xreplace({p: hi - lo})
+                    neg = neg.xreplace({hi: lo - p}).xreplace({p: lo - hi})
+                # evaluate limits that may have unevaluate Min/Max
+                touch = lambda _: _.replace(
+                    lambda x: isinstance(x, (Min, Max)),
+                    lambda x: x.func(*x.args))
+                neg = touch(neg)
+                pos = touch(pos)
+                # assemble return expression; make the first condition be Lt
+                # b/c then the first expression will look the same whether
+                # the lo or hi limit is symbolic
+                if a == _a:  # the lower limit was symbolic
+                    rv = Piecewise(
+                        (pos,
+                            lo < hi),
+                        (neg,
+                            True))
+                else:
+                    rv = Piecewise(
+                        (neg,
+                            hi < lo),
+                        (pos,
+                            True))
+
+                if rv == Undefined:
+                    raise ValueError("Can't integrate across undefined region.")
+                if any(isinstance(i, Piecewise) for i in (pos, neg)):
+                    rv = piecewise_fold(rv)
+                return rv
+
+        # handle a Piecewise with lo <= hi and no x-independent relationals
+        # -----------------------------------------------------------------
+        ok, abei = self._intervals(x)
+        if not ok:
+            from sympy.integrals.integrals import Integral
+            # not being able to do the interval of f(x) can
+            # be stated as not being able to do the integral
+            # of f'(x) over the same range
+            return Integral(self.diff(x), (x, lo, hi))  # unevaluated
+
+        pieces = [(a, b) for a, b, _, _ in abei]
+        done = [(lo, hi, -1)]
+        oo = S.Infinity
+        for k, p in enumerate(pieces):
+            if p[:2] == (-oo, oo):
+                # all undone intervals will get this key
+                for j, (a, b, i) in enumerate(done):
+                    if i == -1:
+                        done[j] = a, b, k
+                break  # nothing else to consider
+            N = len(done) - 1
+            for j, (a, b, i) in enumerate(reversed(done)):
+                if i == -1:
+                    j = N - j
+                    done[j: j + 1] = _clip(p, (a, b), k)
+        done = [(a, b, i) for a, b, i in done if a != b]
+
+        # return the sum of the intervals
+        sum = S.Zero
+        upto = None
+        for a, b, i in done:
+            if i == -1:
+                if upto is None:
+                    return Undefined
+                # TODO simplify hi <= upto
+                return Piecewise((sum, hi <= upto), (Undefined, True))
+            sum += abei[i][-2]._eval_interval(x, a, b)
+            upto = b
+        return sum
+
+    def _intervals(self, sym, err_on_Eq=False):
+        r"""Return a bool and a message (when bool is False), else a
+        list of unique tuples, (a, b, e, i), where a and b
+        are the lower and upper bounds in which the expression e of
+        argument i in self is defined and $a < b$ (when involving
+        numbers) or $a \le b$ when involving symbols.
+
+        If there are any relationals not involving sym, or any
+        relational cannot be solved for sym, the bool will be False
+        a message be given as the second return value. The calling
+        routine should have removed such relationals before calling
+        this routine.
+
+        The evaluated conditions will be returned as ranges.
+        Discontinuous ranges will be returned separately with
+        identical expressions. The first condition that evaluates to
+        True will be returned as the last tuple with a, b = -oo, oo.
+        """
+        from sympy.solvers.inequalities import _solve_inequality
+
+        assert isinstance(self, Piecewise)
+
+        def nonsymfail(cond):
+            return False, filldedent('''
+                A condition not involving
+                %s appeared: %s''' % (sym, cond))
+
+        def _solve_relational(r):
+            if sym not in r.free_symbols:
+                return nonsymfail(r)
+            try:
+                rv = _solve_inequality(r, sym)
+            except NotImplementedError:
+                return False, 'Unable to solve relational %s for %s.' % (r, sym)
+            if isinstance(rv, Relational):
+                free = rv.args[1].free_symbols
+                if rv.args[0] != sym or sym in free:
+                    return False, 'Unable to solve relational %s for %s.' % (r, sym)
+                if rv.rel_op == '==':
+                    # this equality has been affirmed to have the form
+                    # Eq(sym, rhs) where rhs is sym-free; it represents
+                    # a zero-width interval which will be ignored
+                    # whether it is an isolated condition or contained
+                    # within an And or an Or
+                    rv = S.false
+                elif rv.rel_op == '!=':
+                    try:
+                        rv = Or(sym < rv.rhs, sym > rv.rhs)
+                    except TypeError:
+                        # e.g. x != I ==> all real x satisfy
+                        rv = S.true
+            elif rv == (S.NegativeInfinity < sym) & (sym < S.Infinity):
+                rv = S.true
+            return True, rv
+
+        args = list(self.args)
+        # make self canonical wrt Relationals
+        keys = self.atoms(Relational)
+        reps = {}
+        for r in keys:
+            ok, s = _solve_relational(r)
+            if ok != True:
+                return False, ok
+            reps[r] = s
+        # process args individually so if any evaluate, their position
+        # in the original Piecewise will be known
+        args = [i.xreplace(reps) for i in self.args]
+
+        # precondition args
+        expr_cond = []
+        default = idefault = None
+        for i, (expr, cond) in enumerate(args):
+            if cond is S.false:
+                continue
+            if cond is S.true:
+                default = expr
+                idefault = i
+                break
+            if isinstance(cond, Eq):
+                # unanticipated condition, but it is here in case a
+                # replacement caused an Eq to appear
+                if err_on_Eq:
+                    return False, 'encountered Eq condition: %s' % cond
+                continue  # zero width interval
+
+            cond = to_cnf(cond)
+            if isinstance(cond, And):
+                cond = distribute_or_over_and(cond)
+
+            if isinstance(cond, Or):
+                expr_cond.extend(
+                    [(i, expr, o) for o in cond.args
+                    if not isinstance(o, Eq)])
+            elif cond is not S.false:
+                expr_cond.append((i, expr, cond))
+            elif cond is S.true:
+                default = expr
+                idefault = i
+                break
+
+        # determine intervals represented by conditions
+        int_expr = []
+        for iarg, expr, cond in expr_cond:
+            if isinstance(cond, And):
+                lower = S.NegativeInfinity
+                upper = S.Infinity
+                exclude = []
+                for cond2 in cond.args:
+                    if not isinstance(cond2, Relational):
+                        return False, 'expecting only Relationals'
+                    if isinstance(cond2, Eq):
+                        lower = upper  # ignore
+                        if err_on_Eq:
+                            return False, 'encountered secondary Eq condition'
+                        break
+                    elif isinstance(cond2, Ne):
+                        l, r = cond2.args
+                        if l == sym:
+                            exclude.append(r)
+                        elif r == sym:
+                            exclude.append(l)
+                        else:
+                            return nonsymfail(cond2)
+                        continue
+                    elif cond2.lts == sym:
+                        upper = Min(cond2.gts, upper)
+                    elif cond2.gts == sym:
+                        lower = Max(cond2.lts, lower)
+                    else:
+                        return nonsymfail(cond2)  # should never get here
+                if exclude:
+                    exclude = list(ordered(exclude))
+                    newcond = []
+                    for i, e in enumerate(exclude):
+                        if e < lower == True or e > upper == True:
+                            continue
+                        if not newcond:
+                            newcond.append((None, lower))  # add a primer
+                        newcond.append((newcond[-1][1], e))
+                    newcond.append((newcond[-1][1], upper))
+                    newcond.pop(0)  # remove the primer
+                    expr_cond.extend([(iarg, expr, And(i[0] < sym, sym < i[1])) for i in newcond])
+                    continue
+            elif isinstance(cond, Relational) and cond.rel_op != '!=':
+                lower, upper = cond.lts, cond.gts  # part 1: initialize with givens
+                if cond.lts == sym:                # part 1a: expand the side ...
+                    lower = S.NegativeInfinity   # e.g. x <= 0 ---> -oo <= 0
+                elif cond.gts == sym:            # part 1a: ... that can be expanded
+                    upper = S.Infinity           # e.g. x >= 0 --->  oo >= 0
+                else:
+                    return nonsymfail(cond)
+            else:
+                return False, 'unrecognized condition: %s' % cond
+
+            lower, upper = lower, Max(lower, upper)
+            if err_on_Eq and lower == upper:
+                return False, 'encountered Eq condition'
+            if (lower >= upper) is not S.true:
+                int_expr.append((lower, upper, expr, iarg))
+
+        if default is not None:
+            int_expr.append(
+                (S.NegativeInfinity, S.Infinity, default, idefault))
+
+        return True, list(uniq(int_expr))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        args = [(ec.expr._eval_nseries(x, n, logx), ec.cond) for ec in self.args]
+        return self.func(*args)
+
+    def _eval_power(self, s):
+        return self.func(*[(e**s, c) for e, c in self.args])
+
+    def _eval_subs(self, old, new):
+        # this is strictly not necessary, but we can keep track
+        # of whether True or False conditions arise and be
+        # somewhat more efficient by avoiding other substitutions
+        # and avoiding invalid conditions that appear after a
+        # True condition
+        args = list(self.args)
+        args_exist = False
+        for i, (e, c) in enumerate(args):
+            c = c._subs(old, new)
+            if c != False:
+                args_exist = True
+                e = e._subs(old, new)
+            args[i] = (e, c)
+            if c == True:
+                break
+        if not args_exist:
+            args = ((Undefined, True),)
+        return self.func(*args)
+
+    def _eval_transpose(self):
+        return self.func(*[(e.transpose(), c) for e, c in self.args])
+
+    def _eval_template_is_attr(self, is_attr):
+        b = None
+        for expr, _ in self.args:
+            a = getattr(expr, is_attr)
+            if a is None:
+                return
+            if b is None:
+                b = a
+            elif b is not a:
+                return
+        return b
+
+    _eval_is_finite = lambda self: self._eval_template_is_attr(
+        'is_finite')
+    _eval_is_complex = lambda self: self._eval_template_is_attr('is_complex')
+    _eval_is_even = lambda self: self._eval_template_is_attr('is_even')
+    _eval_is_imaginary = lambda self: self._eval_template_is_attr(
+        'is_imaginary')
+    _eval_is_integer = lambda self: self._eval_template_is_attr('is_integer')
+    _eval_is_irrational = lambda self: self._eval_template_is_attr(
+        'is_irrational')
+    _eval_is_negative = lambda self: self._eval_template_is_attr('is_negative')
+    _eval_is_nonnegative = lambda self: self._eval_template_is_attr(
+        'is_nonnegative')
+    _eval_is_nonpositive = lambda self: self._eval_template_is_attr(
+        'is_nonpositive')
+    _eval_is_nonzero = lambda self: self._eval_template_is_attr(
+        'is_nonzero')
+    _eval_is_odd = lambda self: self._eval_template_is_attr('is_odd')
+    _eval_is_polar = lambda self: self._eval_template_is_attr('is_polar')
+    _eval_is_positive = lambda self: self._eval_template_is_attr('is_positive')
+    _eval_is_extended_real = lambda self: self._eval_template_is_attr(
+            'is_extended_real')
+    _eval_is_extended_positive = lambda self: self._eval_template_is_attr(
+            'is_extended_positive')
+    _eval_is_extended_negative = lambda self: self._eval_template_is_attr(
+            'is_extended_negative')
+    _eval_is_extended_nonzero = lambda self: self._eval_template_is_attr(
+            'is_extended_nonzero')
+    _eval_is_extended_nonpositive = lambda self: self._eval_template_is_attr(
+            'is_extended_nonpositive')
+    _eval_is_extended_nonnegative = lambda self: self._eval_template_is_attr(
+            'is_extended_nonnegative')
+    _eval_is_real = lambda self: self._eval_template_is_attr('is_real')
+    _eval_is_zero = lambda self: self._eval_template_is_attr(
+        'is_zero')
+
+    @classmethod
+    def __eval_cond(cls, cond):
+        """Return the truth value of the condition."""
+        if cond == True:
+            return True
+        if isinstance(cond, Eq):
+            try:
+                diff = cond.lhs - cond.rhs
+                if diff.is_commutative:
+                    return diff.is_zero
+            except TypeError:
+                pass
+
+    def as_expr_set_pairs(self, domain=None):
+        """Return tuples for each argument of self that give
+        the expression and the interval in which it is valid
+        which is contained within the given domain.
+        If a condition cannot be converted to a set, an error
+        will be raised. The variable of the conditions is
+        assumed to be real; sets of real values are returned.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise, Interval
+        >>> from sympy.abc import x
+        >>> p = Piecewise(
+        ...     (1, x < 2),
+        ...     (2,(x > 0) & (x < 4)),
+        ...     (3, True))
+        >>> p.as_expr_set_pairs()
+        [(1, Interval.open(-oo, 2)),
+         (2, Interval.Ropen(2, 4)),
+         (3, Interval(4, oo))]
+        >>> p.as_expr_set_pairs(Interval(0, 3))
+        [(1, Interval.Ropen(0, 2)),
+         (2, Interval(2, 3))]
+        """
+        if domain is None:
+            domain = S.Reals
+        exp_sets = []
+        U = domain
+        complex = not domain.is_subset(S.Reals)
+        cond_free = set()
+        for expr, cond in self.args:
+            cond_free |= cond.free_symbols
+            if len(cond_free) > 1:
+                raise NotImplementedError(filldedent('''
+                    multivariate conditions are not handled.'''))
+            if complex:
+                for i in cond.atoms(Relational):
+                    if not isinstance(i, (Eq, Ne)):
+                        raise ValueError(filldedent('''
+                            Inequalities in the complex domain are
+                            not supported. Try the real domain by
+                            setting domain=S.Reals'''))
+            cond_int = U.intersect(cond.as_set())
+            U = U - cond_int
+            if cond_int != S.EmptySet:
+                exp_sets.append((expr, cond_int))
+        return exp_sets
+
+    def _eval_rewrite_as_ITE(self, *args, **kwargs):
+        byfree = {}
+        args = list(args)
+        default = any(c == True for b, c in args)
+        for i, (b, c) in enumerate(args):
+            if not isinstance(b, Boolean) and b != True:
+                raise TypeError(filldedent('''
+                    Expecting Boolean or bool but got `%s`
+                    ''' % func_name(b)))
+            if c == True:
+                break
+            # loop over independent conditions for this b
+            for c in c.args if isinstance(c, Or) else [c]:
+                free = c.free_symbols
+                x = free.pop()
+                try:
+                    byfree[x] = byfree.setdefault(
+                        x, S.EmptySet).union(c.as_set())
+                except NotImplementedError:
+                    if not default:
+                        raise NotImplementedError(filldedent('''
+                            A method to determine whether a multivariate
+                            conditional is consistent with a complete coverage
+                            of all variables has not been implemented so the
+                            rewrite is being stopped after encountering `%s`.
+                            This error would not occur if a default expression
+                            like `(foo, True)` were given.
+                            ''' % c))
+                if byfree[x] in (S.UniversalSet, S.Reals):
+                    # collapse the ith condition to True and break
+                    args[i] = list(args[i])
+                    c = args[i][1] = True
+                    break
+            if c == True:
+                break
+        if c != True:
+            raise ValueError(filldedent('''
+                Conditions must cover all reals or a final default
+                condition `(foo, True)` must be given.
+                '''))
+        last, _ = args[i]  # ignore all past ith arg
+        for a, c in reversed(args[:i]):
+            last = ITE(c, a, last)
+        return _canonical(last)
+
+    def _eval_rewrite_as_KroneckerDelta(self, *args):
+        from sympy.functions.special.tensor_functions import KroneckerDelta
+
+        rules = {
+            And: [False, False],
+            Or: [True, True],
+            Not: [True, False],
+            Eq: [None, None],
+            Ne: [None, None]
+        }
+
+        class UnrecognizedCondition(Exception):
+            pass
+
+        def rewrite(cond):
+            if isinstance(cond, Eq):
+                return KroneckerDelta(*cond.args)
+            if isinstance(cond, Ne):
+                return 1 - KroneckerDelta(*cond.args)
+
+            cls, args = type(cond), cond.args
+            if cls not in rules:
+                raise UnrecognizedCondition(cls)
+
+            b1, b2 = rules[cls]
+            k = Mul(*[1 - rewrite(c) for c in args]) if b1 else Mul(*[rewrite(c) for c in args])
+
+            if b2:
+                return 1 - k
+            return k
+
+        conditions = []
+        true_value = None
+        for value, cond in args:
+            if type(cond) in rules:
+                conditions.append((value, cond))
+            elif cond is S.true:
+                if true_value is None:
+                    true_value = value
+            else:
+                return
+
+        if true_value is not None:
+            result = true_value
+
+            for value, cond in conditions[::-1]:
+                try:
+                    k = rewrite(cond)
+                    result = k * value + (1 - k) * result
+                except UnrecognizedCondition:
+                    return
+
+            return result
+
+
+def piecewise_fold(expr, evaluate=True):
+    """
+    Takes an expression containing a piecewise function and returns the
+    expression in piecewise form. In addition, any ITE conditions are
+    rewritten in negation normal form and simplified.
+
+    The final Piecewise is evaluated (default) but if the raw form
+    is desired, send ``evaluate=False``; if trivial evaluation is
+    desired, send ``evaluate=None`` and duplicate conditions and
+    processing of True and False will be handled.
+
+    Examples
+    ========
+
+    >>> from sympy import Piecewise, piecewise_fold, S
+    >>> from sympy.abc import x
+    >>> p = Piecewise((x, x < 1), (1, S(1) <= x))
+    >>> piecewise_fold(x*p)
+    Piecewise((x**2, x < 1), (x, True))
+
+    See Also
+    ========
+
+    Piecewise
+    piecewise_exclusive
+    """
+    if not isinstance(expr, Basic) or not expr.has(Piecewise):
+        return expr
+
+    new_args = []
+    if isinstance(expr, (ExprCondPair, Piecewise)):
+        for e, c in expr.args:
+            if not isinstance(e, Piecewise):
+                e = piecewise_fold(e)
+            # we don't keep Piecewise in condition because
+            # it has to be checked to see that it's complete
+            # and we convert it to ITE at that time
+            assert not c.has(Piecewise)  # pragma: no cover
+            if isinstance(c, ITE):
+                c = c.to_nnf()
+                c = simplify_logic(c, form='cnf')
+            if isinstance(e, Piecewise):
+                new_args.extend([(piecewise_fold(ei), And(ci, c))
+                    for ei, ci in e.args])
+            else:
+                new_args.append((e, c))
+    else:
+        # Given
+        #     P1 = Piecewise((e11, c1), (e12, c2), A)
+        #     P2 = Piecewise((e21, c1), (e22, c2), B)
+        #     ...
+        # the folding of f(P1, P2) is trivially
+        # Piecewise(
+        #   (f(e11, e21), c1),
+        #   (f(e12, e22), c2),
+        #   (f(Piecewise(A), Piecewise(B)), True))
+        # Certain objects end up rewriting themselves as thus, so
+        # we do that grouping before the more generic folding.
+        # The following applies this idea when f = Add or f = Mul
+        # (and the expression is commutative).
+        if expr.is_Add or expr.is_Mul and expr.is_commutative:
+            p, args = sift(expr.args, lambda x: x.is_Piecewise, binary=True)
+            pc = sift(p, lambda x: tuple([c for e,c in x.args]))
+            for c in list(ordered(pc)):
+                if len(pc[c]) > 1:
+                    pargs = [list(i.args) for i in pc[c]]
+                    # the first one is the same; there may be more
+                    com = common_prefix(*[
+                        [i.cond for i in j] for j in pargs])
+                    n = len(com)
+                    collected = []
+                    for i in range(n):
+                        collected.append((
+                            expr.func(*[ai[i].expr for ai in pargs]),
+                            com[i]))
+                    remains = []
+                    for a in pargs:
+                        if n == len(a):  # no more args
+                            continue
+                        if a[n].cond == True:  # no longer Piecewise
+                            remains.append(a[n].expr)
+                        else:  # restore the remaining Piecewise
+                            remains.append(
+                                Piecewise(*a[n:], evaluate=False))
+                    if remains:
+                        collected.append((expr.func(*remains), True))
+                    args.append(Piecewise(*collected, evaluate=False))
+                    continue
+                args.extend(pc[c])
+        else:
+            args = expr.args
+        # fold
+        folded = list(map(piecewise_fold, args))
+        for ec in product(*[
+                (i.args if isinstance(i, Piecewise) else
+                 [(i, true)]) for i in folded]):
+            e, c = zip(*ec)
+            new_args.append((expr.func(*e), And(*c)))
+
+    if evaluate is None:
+        # don't return duplicate conditions, otherwise don't evaluate
+        new_args = list(reversed([(e, c) for c, e in {
+            c: e for e, c in reversed(new_args)}.items()]))
+    rv = Piecewise(*new_args, evaluate=evaluate)
+    if evaluate is None and len(rv.args) == 1 and rv.args[0].cond == True:
+        return rv.args[0].expr
+    if any(s.expr.has(Piecewise) for p in rv.atoms(Piecewise) for s in p.args):
+        return piecewise_fold(rv)
+    return rv
+
+
+def _clip(A, B, k):
+    """Return interval B as intervals that are covered by A (keyed
+    to k) and all other intervals of B not covered by A keyed to -1.
+
+    The reference point of each interval is the rhs; if the lhs is
+    greater than the rhs then an interval of zero width interval will
+    result, e.g. (4, 1) is treated like (1, 1).
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.piecewise import _clip
+    >>> from sympy import Tuple
+    >>> A = Tuple(1, 3)
+    >>> B = Tuple(2, 4)
+    >>> _clip(A, B, 0)
+    [(2, 3, 0), (3, 4, -1)]
+
+    Interpretation: interval portion (2, 3) of interval (2, 4) is
+    covered by interval (1, 3) and is keyed to 0 as requested;
+    interval (3, 4) was not covered by (1, 3) and is keyed to -1.
+    """
+    a, b = B
+    c, d = A
+    c, d = Min(Max(c, a), b), Min(Max(d, a), b)
+    a, b = Min(a, b), b
+    p = []
+    if a != c:
+        p.append((a, c, -1))
+    else:
+        pass
+    if c != d:
+        p.append((c, d, k))
+    else:
+        pass
+    if b != d:
+        if d == c and p and p[-1][-1] == -1:
+            p[-1] = p[-1][0], b, -1
+        else:
+            p.append((d, b, -1))
+    else:
+        pass
+
+    return p
+
+
+def piecewise_simplify_arguments(expr, **kwargs):
+    from sympy.simplify.simplify import simplify
+
+    # simplify conditions
+    f1 = expr.args[0].cond.free_symbols
+    args = None
+    if len(f1) == 1 and not expr.atoms(Eq):
+        x = f1.pop()
+        # this won't return intervals involving Eq
+        # and it won't handle symbols treated as
+        # booleans
+        ok, abe_ = expr._intervals(x, err_on_Eq=True)
+        def include(c, x, a):
+            "return True if c.subs(x, a) is True, else False"
+            try:
+                return c.subs(x, a) == True
+            except TypeError:
+                return False
+        if ok:
+            args = []
+            covered = S.EmptySet
+            from sympy.sets.sets import Interval
+            for a, b, e, i in abe_:
+                c = expr.args[i].cond
+                incl_a = include(c, x, a)
+                incl_b = include(c, x, b)
+                iv = Interval(a, b, not incl_a, not incl_b)
+                cset = iv - covered
+                if not cset:
+                    continue
+                if incl_a and incl_b:
+                    if a.is_infinite and b.is_infinite:
+                        c = S.true
+                    elif b.is_infinite:
+                        c = (x >= a)
+                    elif a in covered or a.is_infinite:
+                        c = (x <= b)
+                    else:
+                        c = And(a <= x, x <= b)
+                elif incl_a:
+                    if a in covered or a.is_infinite:
+                        c = (x < b)
+                    else:
+                        c = And(a <= x, x < b)
+                elif incl_b:
+                    if b.is_infinite:
+                        c = (x > a)
+                    else:
+                        c = (x <= b)
+                else:
+                    if a in covered:
+                        c = (x < b)
+                    else:
+                        c = And(a < x, x < b)
+                covered |= iv
+                if a is S.NegativeInfinity and incl_a:
+                    covered |= {S.NegativeInfinity}
+                if b is S.Infinity and incl_b:
+                    covered |= {S.Infinity}
+                args.append((e, c))
+            if not S.Reals.is_subset(covered):
+                args.append((Undefined, True))
+    if args is None:
+        args = list(expr.args)
+        for i in range(len(args)):
+            e, c  = args[i]
+            if isinstance(c, Basic):
+                c = simplify(c, **kwargs)
+            args[i] = (e, c)
+
+    # simplify expressions
+    doit = kwargs.pop('doit', None)
+    for i in range(len(args)):
+        e, c  = args[i]
+        if isinstance(e, Basic):
+            # Skip doit to avoid growth at every call for some integrals
+            # and sums, see sympy/sympy#17165
+            newe = simplify(e, doit=False, **kwargs)
+            if newe != e:
+                e = newe
+        args[i] = (e, c)
+
+    # restore kwargs flag
+    if doit is not None:
+        kwargs['doit'] = doit
+
+    return Piecewise(*args)
+
+
+def _piecewise_collapse_arguments(_args):
+    newargs = []  # the unevaluated conditions
+    current_cond = set()  # the conditions up to a given e, c pair
+    for expr, cond in _args:
+        cond = cond.replace(
+            lambda _: _.is_Relational, _canonical_coeff)
+        # Check here if expr is a Piecewise and collapse if one of
+        # the conds in expr matches cond. This allows the collapsing
+        # of Piecewise((Piecewise((x,x<0)),x<0)) to Piecewise((x,x<0)).
+        # This is important when using piecewise_fold to simplify
+        # multiple Piecewise instances having the same conds.
+        # Eventually, this code should be able to collapse Piecewise's
+        # having different intervals, but this will probably require
+        # using the new assumptions.
+        if isinstance(expr, Piecewise):
+            unmatching = []
+            for i, (e, c) in enumerate(expr.args):
+                if c in current_cond:
+                    # this would already have triggered
+                    continue
+                if c == cond:
+                    if c != True:
+                        # nothing past this condition will ever
+                        # trigger and only those args before this
+                        # that didn't match a previous condition
+                        # could possibly trigger
+                        if unmatching:
+                            expr = Piecewise(*(
+                                unmatching + [(e, c)]))
+                        else:
+                            expr = e
+                    break
+                else:
+                    unmatching.append((e, c))
+
+        # check for condition repeats
+        got = False
+        # -- if an And contains a condition that was
+        #    already encountered, then the And will be
+        #    False: if the previous condition was False
+        #    then the And will be False and if the previous
+        #    condition is True then then we wouldn't get to
+        #    this point. In either case, we can skip this condition.
+        for i in ([cond] +
+                  (list(cond.args) if isinstance(cond, And) else
+                  [])):
+            if i in current_cond:
+                got = True
+                break
+        if got:
+            continue
+
+        # -- if not(c) is already in current_cond then c is
+        #    a redundant condition in an And. This does not
+        #    apply to Or, however: (e1, c), (e2, Or(~c, d))
+        #    is not (e1, c), (e2, d) because if c and d are
+        #    both False this would give no results when the
+        #    true answer should be (e2, True)
+        if isinstance(cond, And):
+            nonredundant = []
+            for c in cond.args:
+                if isinstance(c, Relational):
+                    if c.negated.canonical in current_cond:
+                        continue
+                    # if a strict inequality appears after
+                    # a non-strict one, then the condition is
+                    # redundant
+                    if isinstance(c, (Lt, Gt)) and (
+                        c.weak in current_cond):
+                        cond = False
+                        break
+                nonredundant.append(c)
+            else:
+                cond = cond.func(*nonredundant)
+        elif isinstance(cond, Relational):
+            if cond.negated.canonical in current_cond:
+                cond = S.true
+
+        current_cond.add(cond)
+
+        # collect successive e,c pairs when exprs or cond match
+        if newargs:
+            if newargs[-1].expr == expr:
+                orcond = Or(cond, newargs[-1].cond)
+                if isinstance(orcond, (And, Or)):
+                    orcond = distribute_and_over_or(orcond)
+                newargs[-1] = ExprCondPair(expr, orcond)
+                continue
+            elif newargs[-1].cond == cond:
+                continue
+        newargs.append(ExprCondPair(expr, cond))
+    return newargs
+
+
+_blessed = lambda e: getattr(e.lhs, '_diff_wrt', False) and (
+    getattr(e.rhs, '_diff_wrt', None) or
+    isinstance(e.rhs, (Rational, NumberSymbol)))
+
+
+def piecewise_simplify(expr, **kwargs):
+    expr = piecewise_simplify_arguments(expr, **kwargs)
+    if not isinstance(expr, Piecewise):
+        return expr
+    args = list(expr.args)
+
+    args = _piecewise_simplify_eq_and(args)
+    args = _piecewise_simplify_equal_to_next_segment(args)
+    return Piecewise(*args)
+
+
+def _piecewise_simplify_equal_to_next_segment(args):
+    """
+    See if expressions valid for an Equal expression happens to evaluate
+    to the same function as in the next piecewise segment, see:
+    https://github.com/sympy/sympy/issues/8458
+    """
+    prevexpr = None
+    for i, (expr, cond) in reversed(list(enumerate(args))):
+        if prevexpr is not None:
+            if isinstance(cond, And):
+                eqs, other = sift(cond.args,
+                                  lambda i: isinstance(i, Eq), binary=True)
+            elif isinstance(cond, Eq):
+                eqs, other = [cond], []
+            else:
+                eqs = other = []
+            _prevexpr = prevexpr
+            _expr = expr
+            if eqs and not other:
+                eqs = list(ordered(eqs))
+                for e in eqs:
+                    # allow 2 args to collapse into 1 for any e
+                    # otherwise limit simplification to only simple-arg
+                    # Eq instances
+                    if len(args) == 2 or _blessed(e):
+                        _prevexpr = _prevexpr.subs(*e.args)
+                        _expr = _expr.subs(*e.args)
+            # Did it evaluate to the same?
+            if _prevexpr == _expr:
+                # Set the expression for the Not equal section to the same
+                # as the next. These will be merged when creating the new
+                # Piecewise
+                args[i] = args[i].func(args[i + 1][0], cond)
+            else:
+                # Update the expression that we compare against
+                prevexpr = expr
+        else:
+            prevexpr = expr
+    return args
+
+
+def _piecewise_simplify_eq_and(args):
+    """
+    Try to simplify conditions and the expression for
+    equalities that are part of the condition, e.g.
+    Piecewise((n, And(Eq(n,0), Eq(n + m, 0))), (1, True))
+    -> Piecewise((0, And(Eq(n, 0), Eq(m, 0))), (1, True))
+    """
+    for i, (expr, cond) in enumerate(args):
+        if isinstance(cond, And):
+            eqs, other = sift(cond.args,
+                              lambda i: isinstance(i, Eq), binary=True)
+        elif isinstance(cond, Eq):
+            eqs, other = [cond], []
+        else:
+            eqs = other = []
+        if eqs:
+            eqs = list(ordered(eqs))
+            for j, e in enumerate(eqs):
+                # these blessed lhs objects behave like Symbols
+                # and the rhs are simple replacements for the "symbols"
+                if _blessed(e):
+                    expr = expr.subs(*e.args)
+                    eqs[j + 1:] = [ei.subs(*e.args) for ei in eqs[j + 1:]]
+                    other = [ei.subs(*e.args) for ei in other]
+            cond = And(*(eqs + other))
+            args[i] = args[i].func(expr, cond)
+    return args
+
+
+def piecewise_exclusive(expr, *, skip_nan=False, deep=True):
+    """
+    Rewrite :class:`Piecewise` with mutually exclusive conditions.
+
+    Explanation
+    ===========
+
+    SymPy represents the conditions of a :class:`Piecewise` in an
+    "if-elif"-fashion, allowing more than one condition to be simultaneously
+    True. The interpretation is that the first condition that is True is the
+    case that holds. While this is a useful representation computationally it
+    is not how a piecewise formula is typically shown in a mathematical text.
+    The :func:`piecewise_exclusive` function can be used to rewrite any
+    :class:`Piecewise` with more typical mutually exclusive conditions.
+
+    Note that further manipulation of the resulting :class:`Piecewise`, e.g.
+    simplifying it, will most likely make it non-exclusive. Hence, this is
+    primarily a function to be used in conjunction with printing the Piecewise
+    or if one would like to reorder the expression-condition pairs.
+
+    If it is not possible to determine that all possibilities are covered by
+    the different cases of the :class:`Piecewise` then a final
+    :class:`~sympy.core.numbers.NaN` case will be included explicitly. This
+    can be prevented by passing ``skip_nan=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import piecewise_exclusive, Symbol, Piecewise, S
+    >>> x = Symbol('x', real=True)
+    >>> p = Piecewise((0, x < 0), (S.Half, x <= 0), (1, True))
+    >>> piecewise_exclusive(p)
+    Piecewise((0, x < 0), (1/2, Eq(x, 0)), (1, x > 0))
+    >>> piecewise_exclusive(Piecewise((2, x > 1)))
+    Piecewise((2, x > 1), (nan, x <= 1))
+    >>> piecewise_exclusive(Piecewise((2, x > 1)), skip_nan=True)
+    Piecewise((2, x > 1))
+
+    Parameters
+    ==========
+
+    expr: a SymPy expression.
+        Any :class:`Piecewise` in the expression will be rewritten.
+    skip_nan: ``bool`` (default ``False``)
+        If ``skip_nan`` is set to ``True`` then a final
+        :class:`~sympy.core.numbers.NaN` case will not be included.
+    deep:  ``bool`` (default ``True``)
+        If ``deep`` is ``True`` then :func:`piecewise_exclusive` will rewrite
+        any :class:`Piecewise` subexpressions in ``expr`` rather than just
+        rewriting ``expr`` itself.
+
+    Returns
+    =======
+
+    An expression equivalent to ``expr`` but where all :class:`Piecewise` have
+    been rewritten with mutually exclusive conditions.
+
+    See Also
+    ========
+
+    Piecewise
+    piecewise_fold
+    """
+
+    def make_exclusive(*pwargs):
+
+        cumcond = false
+        newargs = []
+
+        # Handle the first n-1 cases
+        for expr_i, cond_i in pwargs[:-1]:
+            cancond = And(cond_i, Not(cumcond)).simplify()
+            cumcond = Or(cond_i, cumcond).simplify()
+            newargs.append((expr_i, cancond))
+
+        # For the nth case defer simplification of cumcond
+        expr_n, cond_n = pwargs[-1]
+        cancond_n = And(cond_n, Not(cumcond)).simplify()
+        newargs.append((expr_n, cancond_n))
+
+        if not skip_nan:
+            cumcond = Or(cond_n, cumcond).simplify()
+            if cumcond is not true:
+                newargs.append((Undefined, Not(cumcond).simplify()))
+
+        return Piecewise(*newargs, evaluate=False)
+
+    if deep:
+        return expr.replace(Piecewise, make_exclusive)
+    elif isinstance(expr, Piecewise):
+        return make_exclusive(*expr.args)
+    else:
+        return expr

venv/lib/python3.10/site-packages/sympy/functions/elementary/tests/test_complexes.py

@@ -0,0 +1,1018 @@
+from sympy.core.expr import Expr
+from sympy.core.function import (Derivative, Function, Lambda, expand)
+from sympy.core.numbers import (E, I, Rational, comp, nan, oo, pi, zoo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, adjoint, arg, conjugate, im, re, sign, transpose)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, atan, atan2, cos, sin)
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.integrals.integrals import Integral
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.funcmatrix import FunctionMatrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.immutable import (ImmutableMatrix, ImmutableSparseMatrix)
+from sympy.matrices import SparseMatrix
+from sympy.sets.sets import Interval
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import XFAIL, raises, _both_exp_pow
+
+
+def N_equals(a, b):
+    """Check whether two complex numbers are numerically close"""
+    return comp(a.n(), b.n(), 1.e-6)
+
+
+def test_re():
+    x, y = symbols('x,y')
+    a, b = symbols('a,b', real=True)
+
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+
+    assert re(nan) is nan
+
+    assert re(oo) is oo
+    assert re(-oo) is -oo
+
+    assert re(0) == 0
+
+    assert re(1) == 1
+    assert re(-1) == -1
+
+    assert re(E) == E
+    assert re(-E) == -E
+
+    assert unchanged(re, x)
+    assert re(x*I) == -im(x)
+    assert re(r*I) == 0
+    assert re(r) == r
+    assert re(i*I) == I * i
+    assert re(i) == 0
+
+    assert re(x + y) == re(x) + re(y)
+    assert re(x + r) == re(x) + r
+
+    assert re(re(x)) == re(x)
+
+    assert re(2 + I) == 2
+    assert re(x + I) == re(x)
+
+    assert re(x + y*I) == re(x) - im(y)
+    assert re(x + r*I) == re(x)
+
+    assert re(log(2*I)) == log(2)
+
+    assert re((2 + I)**2).expand(complex=True) == 3
+
+    assert re(conjugate(x)) == re(x)
+    assert conjugate(re(x)) == re(x)
+
+    assert re(x).as_real_imag() == (re(x), 0)
+
+    assert re(i*r*x).diff(r) == re(i*x)
+    assert re(i*r*x).diff(i) == I*r*im(x)
+
+    assert re(
+        sqrt(a + b*I)) == (a**2 + b**2)**Rational(1, 4)*cos(atan2(b, a)/2)
+    assert re(a * (2 + b*I)) == 2*a
+
+    assert re((1 + sqrt(a + b*I))/2) == \
+        (a**2 + b**2)**Rational(1, 4)*cos(atan2(b, a)/2)/2 + S.Half
+
+    assert re(x).rewrite(im) == x - S.ImaginaryUnit*im(x)
+    assert (x + re(y)).rewrite(re, im) == x + y - S.ImaginaryUnit*im(y)
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    x = Symbol('x')
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+
+    assert re(S.ComplexInfinity) is S.NaN
+
+    n, m, l = symbols('n m l')
+    A = MatrixSymbol('A',n,m)
+    assert re(A) == (S.Half) * (A + conjugate(A))
+
+    A = Matrix([[1 + 4*I,2],[0, -3*I]])
+    assert re(A) == Matrix([[1, 2],[0, 0]])
+
+    A = ImmutableMatrix([[1 + 3*I, 3-2*I],[0, 2*I]])
+    assert re(A) == ImmutableMatrix([[1, 3],[0, 0]])
+
+    X = SparseMatrix([[2*j + i*I for i in range(5)] for j in range(5)])
+    assert re(X) - Matrix([[0, 0, 0, 0, 0],
+                           [2, 2, 2, 2, 2],
+                           [4, 4, 4, 4, 4],
+                           [6, 6, 6, 6, 6],
+                           [8, 8, 8, 8, 8]]) == Matrix.zeros(5)
+
+    assert im(X) - Matrix([[0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4]]) == Matrix.zeros(5)
+
+    X = FunctionMatrix(3, 3, Lambda((n, m), n + m*I))
+    assert re(X) == Matrix([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
+
+
+def test_im():
+    x, y = symbols('x,y')
+    a, b = symbols('a,b', real=True)
+
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+
+    assert im(nan) is nan
+
+    assert im(oo*I) is oo
+    assert im(-oo*I) is -oo
+
+    assert im(0) == 0
+
+    assert im(1) == 0
+    assert im(-1) == 0
+
+    assert im(E*I) == E
+    assert im(-E*I) == -E
+
+    assert unchanged(im, x)
+    assert im(x*I) == re(x)
+    assert im(r*I) == r
+    assert im(r) == 0
+    assert im(i*I) == 0
+    assert im(i) == -I * i
+
+    assert im(x + y) == im(x) + im(y)
+    assert im(x + r) == im(x)
+    assert im(x + r*I) == im(x) + r
+
+    assert im(im(x)*I) == im(x)
+
+    assert im(2 + I) == 1
+    assert im(x + I) == im(x) + 1
+
+    assert im(x + y*I) == im(x) + re(y)
+    assert im(x + r*I) == im(x) + r
+
+    assert im(log(2*I)) == pi/2
+
+    assert im((2 + I)**2).expand(complex=True) == 4
+
+    assert im(conjugate(x)) == -im(x)
+    assert conjugate(im(x)) == im(x)
+
+    assert im(x).as_real_imag() == (im(x), 0)
+
+    assert im(i*r*x).diff(r) == im(i*x)
+    assert im(i*r*x).diff(i) == -I * re(r*x)
+
+    assert im(
+        sqrt(a + b*I)) == (a**2 + b**2)**Rational(1, 4)*sin(atan2(b, a)/2)
+    assert im(a * (2 + b*I)) == a*b
+
+    assert im((1 + sqrt(a + b*I))/2) == \
+        (a**2 + b**2)**Rational(1, 4)*sin(atan2(b, a)/2)/2
+
+    assert im(x).rewrite(re) == -S.ImaginaryUnit * (x - re(x))
+    assert (x + im(y)).rewrite(im, re) == x - S.ImaginaryUnit * (y - re(y))
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    x = Symbol('x')
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+
+    assert im(S.ComplexInfinity) is S.NaN
+
+    n, m, l = symbols('n m l')
+    A = MatrixSymbol('A',n,m)
+
+    assert im(A) == (S.One/(2*I)) * (A - conjugate(A))
+
+    A = Matrix([[1 + 4*I, 2],[0, -3*I]])
+    assert im(A) == Matrix([[4, 0],[0, -3]])
+
+    A = ImmutableMatrix([[1 + 3*I, 3-2*I],[0, 2*I]])
+    assert im(A) == ImmutableMatrix([[3, -2],[0, 2]])
+
+    X = ImmutableSparseMatrix(
+            [[i*I + i for i in range(5)] for i in range(5)])
+    Y = SparseMatrix([list(range(5)) for i in range(5)])
+    assert im(X).as_immutable() == Y
+
+    X = FunctionMatrix(3, 3, Lambda((n, m), n + m*I))
+    assert im(X) == Matrix([[0, 1, 2], [0, 1, 2], [0, 1, 2]])
+
+def test_sign():
+    assert sign(1.2) == 1
+    assert sign(-1.2) == -1
+    assert sign(3*I) == I
+    assert sign(-3*I) == -I
+    assert sign(0) == 0
+    assert sign(0, evaluate=False).doit() == 0
+    assert sign(oo, evaluate=False).doit() == 1
+    assert sign(nan) is nan
+    assert sign(2 + 2*I).doit() == sqrt(2)*(2 + 2*I)/4
+    assert sign(2 + 3*I).simplify() == sign(2 + 3*I)
+    assert sign(2 + 2*I).simplify() == sign(1 + I)
+    assert sign(im(sqrt(1 - sqrt(3)))) == 1
+    assert sign(sqrt(1 - sqrt(3))) == I
+
+    x = Symbol('x')
+    assert sign(x).is_finite is True
+    assert sign(x).is_complex is True
+    assert sign(x).is_imaginary is None
+    assert sign(x).is_integer is None
+    assert sign(x).is_real is None
+    assert sign(x).is_zero is None
+    assert sign(x).doit() == sign(x)
+    assert sign(1.2*x) == sign(x)
+    assert sign(2*x) == sign(x)
+    assert sign(I*x) == I*sign(x)
+    assert sign(-2*I*x) == -I*sign(x)
+    assert sign(conjugate(x)) == conjugate(sign(x))
+
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    m = Symbol('m', negative=True)
+    assert sign(2*p*x) == sign(x)
+    assert sign(n*x) == -sign(x)
+    assert sign(n*m*x) == sign(x)
+
+    x = Symbol('x', imaginary=True)
+    assert sign(x).is_imaginary is True
+    assert sign(x).is_integer is False
+    assert sign(x).is_real is False
+    assert sign(x).is_zero is False
+    assert sign(x).diff(x) == 2*DiracDelta(-I*x)
+    assert sign(x).doit() == x / Abs(x)
+    assert conjugate(sign(x)) == -sign(x)
+
+    x = Symbol('x', real=True)
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is None
+    assert sign(x).diff(x) == 2*DiracDelta(x)
+    assert sign(x).doit() == sign(x)
+    assert conjugate(sign(x)) == sign(x)
+
+    x = Symbol('x', nonzero=True)
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is False
+    assert sign(x).doit() == x / Abs(x)
+    assert sign(Abs(x)) == 1
+    assert Abs(sign(x)) == 1
+
+    x = Symbol('x', positive=True)
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is False
+    assert sign(x).doit() == x / Abs(x)
+    assert sign(Abs(x)) == 1
+    assert Abs(sign(x)) == 1
+
+    x = 0
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is True
+    assert sign(x).doit() == 0
+    assert sign(Abs(x)) == 0
+    assert Abs(sign(x)) == 0
+
+    nz = Symbol('nz', nonzero=True, integer=True)
+    assert sign(nz).is_imaginary is False
+    assert sign(nz).is_integer is True
+    assert sign(nz).is_real is True
+    assert sign(nz).is_zero is False
+    assert sign(nz)**2 == 1
+    assert (sign(nz)**3).args == (sign(nz), 3)
+
+    assert sign(Symbol('x', nonnegative=True)).is_nonnegative
+    assert sign(Symbol('x', nonnegative=True)).is_nonpositive is None
+    assert sign(Symbol('x', nonpositive=True)).is_nonnegative is None
+    assert sign(Symbol('x', nonpositive=True)).is_nonpositive
+    assert sign(Symbol('x', real=True)).is_nonnegative is None
+    assert sign(Symbol('x', real=True)).is_nonpositive is None
+    assert sign(Symbol('x', real=True, zero=False)).is_nonpositive is None
+
+    x, y = Symbol('x', real=True), Symbol('y')
+    f = Function('f')
+    assert sign(x).rewrite(Piecewise) == \
+        Piecewise((1, x > 0), (-1, x < 0), (0, True))
+    assert sign(y).rewrite(Piecewise) == sign(y)
+    assert sign(x).rewrite(Heaviside) == 2*Heaviside(x, H0=S(1)/2) - 1
+    assert sign(y).rewrite(Heaviside) == sign(y)
+    assert sign(y).rewrite(Abs) == Piecewise((0, Eq(y, 0)), (y/Abs(y), True))
+    assert sign(f(y)).rewrite(Abs) == Piecewise((0, Eq(f(y), 0)), (f(y)/Abs(f(y)), True))
+
+    # evaluate what can be evaluated
+    assert sign(exp_polar(I*pi)*pi) is S.NegativeOne
+
+    eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3))
+    # if there is a fast way to know when and when you cannot prove an
+    # expression like this is zero then the equality to zero is ok
+    assert sign(eq).func is sign or sign(eq) == 0
+    # but sometimes it's hard to do this so it's better not to load
+    # abs down with tests that will be very slow
+    q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6)
+    p = expand(q**3)**Rational(1, 3)
+    d = p - q
+    assert sign(d).func is sign or sign(d) == 0
+
+
+def test_as_real_imag():
+    n = pi**1000
+    # the special code for working out the real
+    # and complex parts of a power with Integer exponent
+    # should not run if there is no imaginary part, hence
+    # this should not hang
+    assert n.as_real_imag() == (n, 0)
+
+    # issue 6261
+    x = Symbol('x')
+    assert sqrt(x).as_real_imag() == \
+        ((re(x)**2 + im(x)**2)**Rational(1, 4)*cos(atan2(im(x), re(x))/2),
+     (re(x)**2 + im(x)**2)**Rational(1, 4)*sin(atan2(im(x), re(x))/2))
+
+    # issue 3853
+    a, b = symbols('a,b', real=True)
+    assert ((1 + sqrt(a + b*I))/2).as_real_imag() == \
+           (
+               (a**2 + b**2)**Rational(
+                   1, 4)*cos(atan2(b, a)/2)/2 + S.Half,
+               (a**2 + b**2)**Rational(1, 4)*sin(atan2(b, a)/2)/2)
+
+    assert sqrt(a**2).as_real_imag() == (sqrt(a**2), 0)
+    i = symbols('i', imaginary=True)
+    assert sqrt(i**2).as_real_imag() == (0, abs(i))
+
+    assert ((1 + I)/(1 - I)).as_real_imag() == (0, 1)
+    assert ((1 + I)**3/(1 - I)).as_real_imag() == (-2, 0)
+
+
+@XFAIL
+def test_sign_issue_3068():
+    n = pi**1000
+    i = int(n)
+    x = Symbol('x')
+    assert (n - i).round() == 1  # doesn't hang
+    assert sign(n - i) == 1
+    # perhaps it's not possible to get the sign right when
+    # only 1 digit is being requested for this situation;
+    # 2 digits works
+    assert (n - x).n(1, subs={x: i}) > 0
+    assert (n - x).n(2, subs={x: i}) > 0
+
+
+def test_Abs():
+    raises(TypeError, lambda: Abs(Interval(2, 3)))  # issue 8717
+
+    x, y = symbols('x,y')
+    assert sign(sign(x)) == sign(x)
+    assert sign(x*y).func is sign
+    assert Abs(0) == 0
+    assert Abs(1) == 1
+    assert Abs(-1) == 1
+    assert Abs(I) == 1
+    assert Abs(-I) == 1
+    assert Abs(nan) is nan
+    assert Abs(zoo) is oo
+    assert Abs(I * pi) == pi
+    assert Abs(-I * pi) == pi
+    assert Abs(I * x) == Abs(x)
+    assert Abs(-I * x) == Abs(x)
+    assert Abs(-2*x) == 2*Abs(x)
+    assert Abs(-2.0*x) == 2.0*Abs(x)
+    assert Abs(2*pi*x*y) == 2*pi*Abs(x*y)
+    assert Abs(conjugate(x)) == Abs(x)
+    assert conjugate(Abs(x)) == Abs(x)
+    assert Abs(x).expand(complex=True) == sqrt(re(x)**2 + im(x)**2)
+
+    a = Symbol('a', positive=True)
+    assert Abs(2*pi*x*a) == 2*pi*a*Abs(x)
+    assert Abs(2*pi*I*x*a) == 2*pi*a*Abs(x)
+
+    x = Symbol('x', real=True)
+    n = Symbol('n', integer=True)
+    assert Abs((-1)**n) == 1
+    assert x**(2*n) == Abs(x)**(2*n)
+    assert Abs(x).diff(x) == sign(x)
+    assert abs(x) == Abs(x)  # Python built-in
+    assert Abs(x)**3 == x**2*Abs(x)
+    assert Abs(x)**4 == x**4
+    assert (
+        Abs(x)**(3*n)).args == (Abs(x), 3*n)  # leave symbolic odd unchanged
+    assert (1/Abs(x)).args == (Abs(x), -1)
+    assert 1/Abs(x)**3 == 1/(x**2*Abs(x))
+    assert Abs(x)**-3 == Abs(x)/(x**4)
+    assert Abs(x**3) == x**2*Abs(x)
+    assert Abs(I**I) == exp(-pi/2)
+    assert Abs((4 + 5*I)**(6 + 7*I)) == 68921*exp(-7*atan(Rational(5, 4)))
+    y = Symbol('y', real=True)
+    assert Abs(I**y) == 1
+    y = Symbol('y')
+    assert Abs(I**y) == exp(-pi*im(y)/2)
+
+    x = Symbol('x', imaginary=True)
+    assert Abs(x).diff(x) == -sign(x)
+
+    eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3))
+    # if there is a fast way to know when you can and when you cannot prove an
+    # expression like this is zero then the equality to zero is ok
+    assert abs(eq).func is Abs or abs(eq) == 0
+    # but sometimes it's hard to do this so it's better not to load
+    # abs down with tests that will be very slow
+    q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6)
+    p = expand(q**3)**Rational(1, 3)
+    d = p - q
+    assert abs(d).func is Abs or abs(d) == 0
+
+    assert Abs(4*exp(pi*I/4)) == 4
+    assert Abs(3**(2 + I)) == 9
+    assert Abs((-3)**(1 - I)) == 3*exp(pi)
+
+    assert Abs(oo) is oo
+    assert Abs(-oo) is oo
+    assert Abs(oo + I) is oo
+    assert Abs(oo + I*oo) is oo
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    x = Symbol('x')
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+    assert Abs(x).fdiff() == sign(x)
+    raises(ArgumentIndexError, lambda: Abs(x).fdiff(2))
+
+    # doesn't have recursion error
+    arg = sqrt(acos(1 - I)*acos(1 + I))
+    assert abs(arg) == arg
+
+    # special handling to put Abs in denom
+    assert abs(1/x) == 1/Abs(x)
+    e = abs(2/x**2)
+    assert e.is_Mul and e == 2/Abs(x**2)
+    assert unchanged(Abs, y/x)
+    assert unchanged(Abs, x/(x + 1))
+    assert unchanged(Abs, x*y)
+    p = Symbol('p', positive=True)
+    assert abs(x/p) == abs(x)/p
+
+    # coverage
+    assert unchanged(Abs, Symbol('x', real=True)**y)
+    # issue 19627
+    f = Function('f', positive=True)
+    assert sqrt(f(x)**2) == f(x)
+    # issue 21625
+    assert unchanged(Abs, S("im(acos(-i + acosh(-g + i)))"))
+
+
+def test_Abs_rewrite():
+    x = Symbol('x', real=True)
+    a = Abs(x).rewrite(Heaviside).expand()
+    assert a == x*Heaviside(x) - x*Heaviside(-x)
+    for i in [-2, -1, 0, 1, 2]:
+        assert a.subs(x, i) == abs(i)
+    y = Symbol('y')
+    assert Abs(y).rewrite(Heaviside) == Abs(y)
+
+    x, y = Symbol('x', real=True), Symbol('y')
+    assert Abs(x).rewrite(Piecewise) == Piecewise((x, x >= 0), (-x, True))
+    assert Abs(y).rewrite(Piecewise) == Abs(y)
+    assert Abs(y).rewrite(sign) == y/sign(y)
+
+    i = Symbol('i', imaginary=True)
+    assert abs(i).rewrite(Piecewise) == Piecewise((I*i, I*i >= 0), (-I*i, True))
+
+
+    assert Abs(y).rewrite(conjugate) == sqrt(y*conjugate(y))
+    assert Abs(i).rewrite(conjugate) == sqrt(-i**2) #  == -I*i
+
+    y = Symbol('y', extended_real=True)
+    assert  (Abs(exp(-I*x)-exp(-I*y))**2).rewrite(conjugate) == \
+        -exp(I*x)*exp(-I*y) + 2 - exp(-I*x)*exp(I*y)
+
+
+def test_Abs_real():
+    # test some properties of abs that only apply
+    # to real numbers
+    x = Symbol('x', complex=True)
+    assert sqrt(x**2) != Abs(x)
+    assert Abs(x**2) != x**2
+
+    x = Symbol('x', real=True)
+    assert sqrt(x**2) == Abs(x)
+    assert Abs(x**2) == x**2
+
+    # if the symbol is zero, the following will still apply
+    nn = Symbol('nn', nonnegative=True, real=True)
+    np = Symbol('np', nonpositive=True, real=True)
+    assert Abs(nn) == nn
+    assert Abs(np) == -np
+
+
+def test_Abs_properties():
+    x = Symbol('x')
+    assert Abs(x).is_real is None
+    assert Abs(x).is_extended_real is True
+    assert Abs(x).is_rational is None
+    assert Abs(x).is_positive is None
+    assert Abs(x).is_nonnegative is None
+    assert Abs(x).is_extended_positive is None
+    assert Abs(x).is_extended_nonnegative is True
+
+    f = Symbol('x', finite=True)
+    assert Abs(f).is_real is True
+    assert Abs(f).is_extended_real is True
+    assert Abs(f).is_rational is None
+    assert Abs(f).is_positive is None
+    assert Abs(f).is_nonnegative is True
+    assert Abs(f).is_extended_positive is None
+    assert Abs(f).is_extended_nonnegative is True
+
+    z = Symbol('z', complex=True, zero=False)
+    assert Abs(z).is_real is True # since complex implies finite
+    assert Abs(z).is_extended_real is True
+    assert Abs(z).is_rational is None
+    assert Abs(z).is_positive is True
+    assert Abs(z).is_extended_positive is True
+    assert Abs(z).is_zero is False
+
+    p = Symbol('p', positive=True)
+    assert Abs(p).is_real is True
+    assert Abs(p).is_extended_real is True
+    assert Abs(p).is_rational is None
+    assert Abs(p).is_positive is True
+    assert Abs(p).is_zero is False
+
+    q = Symbol('q', rational=True)
+    assert Abs(q).is_real is True
+    assert Abs(q).is_rational is True
+    assert Abs(q).is_integer is None
+    assert Abs(q).is_positive is None
+    assert Abs(q).is_nonnegative is True
+
+    i = Symbol('i', integer=True)
+    assert Abs(i).is_real is True
+    assert Abs(i).is_integer is True
+    assert Abs(i).is_positive is None
+    assert Abs(i).is_nonnegative is True
+
+    e = Symbol('n', even=True)
+    ne = Symbol('ne', real=True, even=False)
+    assert Abs(e).is_even is True
+    assert Abs(ne).is_even is False
+    assert Abs(i).is_even is None
+
+    o = Symbol('n', odd=True)
+    no = Symbol('no', real=True, odd=False)
+    assert Abs(o).is_odd is True
+    assert Abs(no).is_odd is False
+    assert Abs(i).is_odd is None
+
+
+def test_abs():
+    # this tests that abs calls Abs; don't rename to
+    # test_Abs since that test is already above
+    a = Symbol('a', positive=True)
+    assert abs(I*(1 + a)**2) == (1 + a)**2
+
+
+def test_arg():
+    assert arg(0) is nan
+    assert arg(1) == 0
+    assert arg(-1) == pi
+    assert arg(I) == pi/2
+    assert arg(-I) == -pi/2
+    assert arg(1 + I) == pi/4
+    assert arg(-1 + I) == pi*Rational(3, 4)
+    assert arg(1 - I) == -pi/4
+    assert arg(exp_polar(4*pi*I)) == 4*pi
+    assert arg(exp_polar(-7*pi*I)) == -7*pi
+    assert arg(exp_polar(5 - 3*pi*I/4)) == pi*Rational(-3, 4)
+    f = Function('f')
+    assert not arg(f(0) + I*f(1)).atoms(re)
+
+    # check nesting
+    x = Symbol('x')
+    assert arg(arg(arg(x))) is not S.NaN
+    assert arg(arg(arg(arg(x)))) is S.NaN
+    r = Symbol('r', extended_real=True)
+    assert arg(arg(r)) is not S.NaN
+    assert arg(arg(arg(r))) is S.NaN
+
+    p = Function('p', extended_positive=True)
+    assert arg(p(x)) == 0
+    assert arg((3 + I)*p(x)) == arg(3  + I)
+
+    p = Symbol('p', positive=True)
+    assert arg(p) == 0
+    assert arg(p*I) == pi/2
+
+    n = Symbol('n', negative=True)
+    assert arg(n) == pi
+    assert arg(n*I) == -pi/2
+
+    x = Symbol('x')
+    assert conjugate(arg(x)) == arg(x)
+
+    e = p + I*p**2
+    assert arg(e) == arg(1 + p*I)
+    # make sure sign doesn't swap
+    e = -2*p + 4*I*p**2
+    assert arg(e) == arg(-1 + 2*p*I)
+    # make sure sign isn't lost
+    x = symbols('x', real=True)  # could be zero
+    e = x + I*x
+    assert arg(e) == arg(x*(1 + I))
+    assert arg(e/p) == arg(x*(1 + I))
+    e = p*cos(p) + I*log(p)*exp(p)
+    assert arg(e).args[0] == e
+    # keep it simple -- let the user do more advanced cancellation
+    e = (p + 1) + I*(p**2 - 1)
+    assert arg(e).args[0] == e
+
+    f = Function('f')
+    e = 2*x*(f(0) - 1) - 2*x*f(0)
+    assert arg(e) == arg(-2*x)
+    assert arg(f(0)).func == arg and arg(f(0)).args == (f(0),)
+
+
+def test_arg_rewrite():
+    assert arg(1 + I) == atan2(1, 1)
+
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    assert arg(x + I*y).rewrite(atan2) == atan2(y, x)
+
+
+def test_adjoint():
+    a = Symbol('a', antihermitian=True)
+    b = Symbol('b', hermitian=True)
+    assert adjoint(a) == -a
+    assert adjoint(I*a) == I*a
+    assert adjoint(b) == b
+    assert adjoint(I*b) == -I*b
+    assert adjoint(a*b) == -b*a
+    assert adjoint(I*a*b) == I*b*a
+
+    x, y = symbols('x y')
+    assert adjoint(adjoint(x)) == x
+    assert adjoint(x + y) == adjoint(x) + adjoint(y)
+    assert adjoint(x - y) == adjoint(x) - adjoint(y)
+    assert adjoint(x * y) == adjoint(x) * adjoint(y)
+    assert adjoint(x / y) == adjoint(x) / adjoint(y)
+    assert adjoint(-x) == -adjoint(x)
+
+    x, y = symbols('x y', commutative=False)
+    assert adjoint(adjoint(x)) == x
+    assert adjoint(x + y) == adjoint(x) + adjoint(y)
+    assert adjoint(x - y) == adjoint(x) - adjoint(y)
+    assert adjoint(x * y) == adjoint(y) * adjoint(x)
+    assert adjoint(x / y) == 1 / adjoint(y) * adjoint(x)
+    assert adjoint(-x) == -adjoint(x)
+
+
+def test_conjugate():
+    a = Symbol('a', real=True)
+    b = Symbol('b', imaginary=True)
+    assert conjugate(a) == a
+    assert conjugate(I*a) == -I*a
+    assert conjugate(b) == -b
+    assert conjugate(I*b) == I*b
+    assert conjugate(a*b) == -a*b
+    assert conjugate(I*a*b) == I*a*b
+
+    x, y = symbols('x y')
+    assert conjugate(conjugate(x)) == x
+    assert conjugate(x).inverse() == conjugate
+    assert conjugate(x + y) == conjugate(x) + conjugate(y)
+    assert conjugate(x - y) == conjugate(x) - conjugate(y)
+    assert conjugate(x * y) == conjugate(x) * conjugate(y)
+    assert conjugate(x / y) == conjugate(x) / conjugate(y)
+    assert conjugate(-x) == -conjugate(x)
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+
+
+def test_conjugate_transpose():
+    x = Symbol('x')
+    assert conjugate(transpose(x)) == adjoint(x)
+    assert transpose(conjugate(x)) == adjoint(x)
+    assert adjoint(transpose(x)) == conjugate(x)
+    assert transpose(adjoint(x)) == conjugate(x)
+    assert adjoint(conjugate(x)) == transpose(x)
+    assert conjugate(adjoint(x)) == transpose(x)
+
+    class Symmetric(Expr):
+        def _eval_adjoint(self):
+            return None
+
+        def _eval_conjugate(self):
+            return None
+
+        def _eval_transpose(self):
+            return self
+    x = Symmetric()
+    assert conjugate(x) == adjoint(x)
+    assert transpose(x) == x
+
+
+def test_transpose():
+    a = Symbol('a', complex=True)
+    assert transpose(a) == a
+    assert transpose(I*a) == I*a
+
+    x, y = symbols('x y')
+    assert transpose(transpose(x)) == x
+    assert transpose(x + y) == transpose(x) + transpose(y)
+    assert transpose(x - y) == transpose(x) - transpose(y)
+    assert transpose(x * y) == transpose(x) * transpose(y)
+    assert transpose(x / y) == transpose(x) / transpose(y)
+    assert transpose(-x) == -transpose(x)
+
+    x, y = symbols('x y', commutative=False)
+    assert transpose(transpose(x)) == x
+    assert transpose(x + y) == transpose(x) + transpose(y)
+    assert transpose(x - y) == transpose(x) - transpose(y)
+    assert transpose(x * y) == transpose(y) * transpose(x)
+    assert transpose(x / y) == 1 / transpose(y) * transpose(x)
+    assert transpose(-x) == -transpose(x)
+
+
+@_both_exp_pow
+def test_polarify():
+    from sympy.functions.elementary.complexes import (polar_lift, polarify)
+    x = Symbol('x')
+    z = Symbol('z', polar=True)
+    f = Function('f')
+    ES = {}
+
+    assert polarify(-1) == (polar_lift(-1), ES)
+    assert polarify(1 + I) == (polar_lift(1 + I), ES)
+
+    assert polarify(exp(x), subs=False) == exp(x)
+    assert polarify(1 + x, subs=False) == 1 + x
+    assert polarify(f(I) + x, subs=False) == f(polar_lift(I)) + x
+
+    assert polarify(x, lift=True) == polar_lift(x)
+    assert polarify(z, lift=True) == z
+    assert polarify(f(x), lift=True) == f(polar_lift(x))
+    assert polarify(1 + x, lift=True) == polar_lift(1 + x)
+    assert polarify(1 + f(x), lift=True) == polar_lift(1 + f(polar_lift(x)))
+
+    newex, subs = polarify(f(x) + z)
+    assert newex.subs(subs) == f(x) + z
+
+    mu = Symbol("mu")
+    sigma = Symbol("sigma", positive=True)
+
+    # Make sure polarify(lift=True) doesn't try to lift the integration
+    # variable
+    assert polarify(
+        Integral(sqrt(2)*x*exp(-(-mu + x)**2/(2*sigma**2))/(2*sqrt(pi)*sigma),
+        (x, -oo, oo)), lift=True) == Integral(sqrt(2)*(sigma*exp_polar(0))**exp_polar(I*pi)*
+        exp((sigma*exp_polar(0))**(2*exp_polar(I*pi))*exp_polar(I*pi)*polar_lift(-mu + x)**
+        (2*exp_polar(0))/2)*exp_polar(0)*polar_lift(x)/(2*sqrt(pi)), (x, -oo, oo))
+
+
+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_issue_4035():
+    x = Symbol('x')
+    assert Abs(x).expand(trig=True) == Abs(x)
+    assert sign(x).expand(trig=True) == sign(x)
+    assert arg(x).expand(trig=True) == arg(x)
+
+
+def test_issue_3206():
+    x = Symbol('x')
+    assert Abs(Abs(x)) == Abs(x)
+
+
+def test_issue_4754_derivative_conjugate():
+    x = Symbol('x', real=True)
+    y = Symbol('y', imaginary=True)
+    f = Function('f')
+    assert (f(x).conjugate()).diff(x) == (f(x).diff(x)).conjugate()
+    assert (f(y).conjugate()).diff(y) == -(f(y).diff(y)).conjugate()
+
+
+def test_derivatives_issue_4757():
+    x = Symbol('x', real=True)
+    y = Symbol('y', imaginary=True)
+    f = Function('f')
+    assert re(f(x)).diff(x) == re(f(x).diff(x))
+    assert im(f(x)).diff(x) == im(f(x).diff(x))
+    assert re(f(y)).diff(y) == -I*im(f(y).diff(y))
+    assert im(f(y)).diff(y) == -I*re(f(y).diff(y))
+    assert Abs(f(x)).diff(x).subs(f(x), 1 + I*x).doit() == x/sqrt(1 + x**2)
+    assert arg(f(x)).diff(x).subs(f(x), 1 + I*x**2).doit() == 2*x/(1 + x**4)
+    assert Abs(f(y)).diff(y).subs(f(y), 1 + y).doit() == -y/sqrt(1 - y**2)
+    assert arg(f(y)).diff(y).subs(f(y), I + y**2).doit() == 2*y/(1 + y**4)
+
+
+def test_issue_11413():
+    from sympy.simplify.simplify import simplify
+    v0 = Symbol('v0')
+    v1 = Symbol('v1')
+    v2 = Symbol('v2')
+    V = Matrix([[v0],[v1],[v2]])
+    U = V.normalized()
+    assert U == Matrix([
+    [v0/sqrt(Abs(v0)**2 + Abs(v1)**2 + Abs(v2)**2)],
+    [v1/sqrt(Abs(v0)**2 + Abs(v1)**2 + Abs(v2)**2)],
+    [v2/sqrt(Abs(v0)**2 + Abs(v1)**2 + Abs(v2)**2)]])
+    U.norm = sqrt(v0**2/(v0**2 + v1**2 + v2**2) + v1**2/(v0**2 + v1**2 + v2**2) + v2**2/(v0**2 + v1**2 + v2**2))
+    assert simplify(U.norm) == 1
+
+
+def test_periodic_argument():
+    from sympy.functions.elementary.complexes import (periodic_argument, polar_lift, principal_branch, unbranched_argument)
+    x = Symbol('x')
+    p = Symbol('p', positive=True)
+
+    assert unbranched_argument(2 + I) == periodic_argument(2 + I, oo)
+    assert unbranched_argument(1 + x) == periodic_argument(1 + x, oo)
+    assert N_equals(unbranched_argument((1 + I)**2), pi/2)
+    assert N_equals(unbranched_argument((1 - I)**2), -pi/2)
+    assert N_equals(periodic_argument((1 + I)**2, 3*pi), pi/2)
+    assert N_equals(periodic_argument((1 - I)**2, 3*pi), -pi/2)
+
+    assert unbranched_argument(principal_branch(x, pi)) == \
+        periodic_argument(x, pi)
+
+    assert unbranched_argument(polar_lift(2 + I)) == unbranched_argument(2 + I)
+    assert periodic_argument(polar_lift(2 + I), 2*pi) == \
+        periodic_argument(2 + I, 2*pi)
+    assert periodic_argument(polar_lift(2 + I), 3*pi) == \
+        periodic_argument(2 + I, 3*pi)
+    assert periodic_argument(polar_lift(2 + I), pi) == \
+        periodic_argument(polar_lift(2 + I), pi)
+
+    assert unbranched_argument(polar_lift(1 + I)) == pi/4
+    assert periodic_argument(2*p, p) == periodic_argument(p, p)
+    assert periodic_argument(pi*p, p) == periodic_argument(p, p)
+
+    assert Abs(polar_lift(1 + I)) == Abs(1 + I)
+
+
+@XFAIL
+def test_principal_branch_fail():
+    # TODO XXX why does abs(x)._eval_evalf() not fall back to global evalf?
+    from sympy.functions.elementary.complexes import principal_branch
+    assert N_equals(principal_branch((1 + I)**2, pi/2), 0)
+
+
+def test_principal_branch():
+    from sympy.functions.elementary.complexes import (polar_lift, principal_branch)
+    p = Symbol('p', positive=True)
+    x = Symbol('x')
+    neg = Symbol('x', negative=True)
+
+    assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
+    assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
+    assert principal_branch(2*x, p) == 2*principal_branch(x, p)
+    assert principal_branch(1, pi) == exp_polar(0)
+    assert principal_branch(-1, 2*pi) == exp_polar(I*pi)
+    assert principal_branch(-1, pi) == exp_polar(0)
+    assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
+        principal_branch(exp_polar(I*pi)*x, 2*pi)
+    assert principal_branch(neg*exp_polar(pi*I), 2*pi) == neg*exp_polar(-I*pi)
+    # related to issue #14692
+    assert principal_branch(exp_polar(-I*pi/2)/polar_lift(neg), 2*pi) == \
+        exp_polar(-I*pi/2)/neg
+
+    assert N_equals(principal_branch((1 + I)**2, 2*pi), 2*I)
+    assert N_equals(principal_branch((1 + I)**2, 3*pi), 2*I)
+    assert N_equals(principal_branch((1 + I)**2, 1*pi), 2*I)
+
+    # test argument sanitization
+    assert principal_branch(x, I).func is principal_branch
+    assert principal_branch(x, -4).func is principal_branch
+    assert principal_branch(x, -oo).func is principal_branch
+    assert principal_branch(x, zoo).func is principal_branch
+
+
+@XFAIL
+def test_issue_6167_6151():
+    n = pi**1000
+    i = int(n)
+    assert sign(n - i) == 1
+    assert abs(n - i) == n - i
+    x = Symbol('x')
+    eps = pi**-1500
+    big = pi**1000
+    one = cos(x)**2 + sin(x)**2
+    e = big*one - big + eps
+    from sympy.simplify.simplify import simplify
+    assert sign(simplify(e)) == 1
+    for xi in (111, 11, 1, Rational(1, 10)):
+        assert sign(e.subs(x, xi)) == 1
+
+
+def test_issue_14216():
+    from sympy.functions.elementary.complexes import unpolarify
+    A = MatrixSymbol("A", 2, 2)
+    assert unpolarify(A[0, 0]) == A[0, 0]
+    assert unpolarify(A[0, 0]*A[1, 0]) == A[0, 0]*A[1, 0]
+
+
+def test_issue_14238():
+    # doesn't cause recursion error
+    r = Symbol('r', real=True)
+    assert Abs(r + Piecewise((0, r > 0), (1 - r, True)))
+
+
+def test_issue_22189():
+    x = Symbol('x')
+    for a in (sqrt(7 - 2*x) - 2, 1 - x):
+        assert Abs(a) - Abs(-a) == 0, a
+
+
+def test_zero_assumptions():
+    nr = Symbol('nonreal', real=False, finite=True)
+    ni = Symbol('nonimaginary', imaginary=False)
+    # imaginary implies not zero
+    nzni = Symbol('nonzerononimaginary', zero=False, imaginary=False)
+
+    assert re(nr).is_zero is None
+    assert im(nr).is_zero is False
+
+    assert re(ni).is_zero is None
+    assert im(ni).is_zero is None
+
+    assert re(nzni).is_zero is False
+    assert im(nzni).is_zero is None
+
+
+@_both_exp_pow
+def test_issue_15893():
+    f = Function('f', real=True)
+    x = Symbol('x', real=True)
+    eq = Derivative(Abs(f(x)), f(x))
+    assert eq.doit() == sign(f(x))

venv/lib/python3.10/site-packages/sympy/functions/elementary/tests/test_exponential.py

@@ -0,0 +1,806 @@
+from sympy.assumptions.refine import refine
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.function import expand_log
+from sympy.core.numbers import (E, Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (adjoint, conjugate, re, sign, transpose)
+from sympy.functions.elementary.exponential import (LambertW, exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.polys.polytools import gcd
+from sympy.series.order import O
+from sympy.simplify.simplify import simplify
+from sympy.core.parameters import global_parameters
+from sympy.functions.elementary.exponential import match_real_imag
+from sympy.abc import x, y, z
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises, XFAIL, _both_exp_pow
+
+
+@_both_exp_pow
+def test_exp_values():
+    if global_parameters.exp_is_pow:
+        assert type(exp(x)) is Pow
+    else:
+        assert type(exp(x)) is exp
+
+    k = Symbol('k', integer=True)
+
+    assert exp(nan) is nan
+
+    assert exp(oo) is oo
+    assert exp(-oo) == 0
+
+    assert exp(0) == 1
+    assert exp(1) == E
+    assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1)
+    assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1)
+
+    assert exp(pi*I/2) == I
+    assert exp(pi*I) == -1
+    assert exp(pi*I*Rational(3, 2)) == -I
+    assert exp(2*pi*I) == 1
+
+    assert refine(exp(pi*I*2*k)) == 1
+    assert refine(exp(pi*I*2*(k + S.Half))) == -1
+    assert refine(exp(pi*I*2*(k + Rational(1, 4)))) == I
+    assert refine(exp(pi*I*2*(k + Rational(3, 4)))) == -I
+
+    assert exp(log(x)) == x
+    assert exp(2*log(x)) == x**2
+    assert exp(pi*log(x)) == x**pi
+
+    assert exp(17*log(x) + E*log(y)) == x**17 * y**E
+
+    assert exp(x*log(x)) != x**x
+    assert exp(sin(x)*log(x)) != x
+
+    assert exp(3*log(x) + oo*x) == exp(oo*x) * x**3
+    assert exp(4*log(x)*log(y) + 3*log(x)) == x**3 * exp(4*log(x)*log(y))
+
+    assert exp(-oo, evaluate=False).is_finite is True
+    assert exp(oo, evaluate=False).is_finite is False
+
+
+@_both_exp_pow
+def test_exp_period():
+    assert exp(I*pi*Rational(9, 4)) == exp(I*pi/4)
+    assert exp(I*pi*Rational(46, 18)) == exp(I*pi*Rational(5, 9))
+    assert exp(I*pi*Rational(25, 7)) == exp(I*pi*Rational(-3, 7))
+    assert exp(I*pi*Rational(-19, 3)) == exp(-I*pi/3)
+    assert exp(I*pi*Rational(37, 8)) - exp(I*pi*Rational(-11, 8)) == 0
+    assert exp(I*pi*Rational(-5, 3)) / exp(I*pi*Rational(11, 5)) * exp(I*pi*Rational(148, 15)) == 1
+
+    assert exp(2 - I*pi*Rational(17, 5)) == exp(2 + I*pi*Rational(3, 5))
+    assert exp(log(3) + I*pi*Rational(29, 9)) == 3 * exp(I*pi*Rational(-7, 9))
+
+    n = Symbol('n', integer=True)
+    e = Symbol('e', even=True)
+    assert exp(e*I*pi) == 1
+    assert exp((e + 1)*I*pi) == -1
+    assert exp((1 + 4*n)*I*pi/2) == I
+    assert exp((-1 + 4*n)*I*pi/2) == -I
+
+
+@_both_exp_pow
+def test_exp_log():
+    x = Symbol("x", real=True)
+    assert log(exp(x)) == x
+    assert exp(log(x)) == x
+
+    if not global_parameters.exp_is_pow:
+        assert log(x).inverse() == exp
+        assert exp(x).inverse() == log
+
+    y = Symbol("y", polar=True)
+    assert log(exp_polar(z)) == z
+    assert exp(log(y)) == y
+
+
+@_both_exp_pow
+def test_exp_expand():
+    e = exp(log(Rational(2))*(1 + x) - log(Rational(2))*x)
+    assert e.expand() == 2
+    assert exp(x + y) != exp(x)*exp(y)
+    assert exp(x + y).expand() == exp(x)*exp(y)
+
+
+@_both_exp_pow
+def test_exp__as_base_exp():
+    assert exp(x).as_base_exp() == (E, x)
+    assert exp(2*x).as_base_exp() == (E, 2*x)
+    assert exp(x*y).as_base_exp() == (E, x*y)
+    assert exp(-x).as_base_exp() == (E, -x)
+
+    # Pow( *expr.as_base_exp() ) == expr    invariant should hold
+    assert E**x == exp(x)
+    assert E**(2*x) == exp(2*x)
+    assert E**(x*y) == exp(x*y)
+
+    assert exp(x).base is S.Exp1
+    assert exp(x).exp == x
+
+
+@_both_exp_pow
+def test_exp_infinity():
+    assert exp(I*y) != nan
+    assert refine(exp(I*oo)) is nan
+    assert refine(exp(-I*oo)) is nan
+    assert exp(y*I*oo) != nan
+    assert exp(zoo) is nan
+    x = Symbol('x', extended_real=True, finite=False)
+    assert exp(x).is_complex is None
+
+
+@_both_exp_pow
+def test_exp_subs():
+    x = Symbol('x')
+    e = (exp(3*log(x), evaluate=False))  # evaluates to x**3
+    assert e.subs(x**3, y**3) == e
+    assert e.subs(x**2, 5) == e
+    assert (x**3).subs(x**2, y) != y**Rational(3, 2)
+    assert exp(exp(x) + exp(x**2)).subs(exp(exp(x)), y) == y * exp(exp(x**2))
+    assert exp(x).subs(E, y) == y**x
+    x = symbols('x', real=True)
+    assert exp(5*x).subs(exp(7*x), y) == y**Rational(5, 7)
+    assert exp(2*x + 7).subs(exp(3*x), y) == y**Rational(2, 3) * exp(7)
+    x = symbols('x', positive=True)
+    assert exp(3*log(x)).subs(x**2, y) == y**Rational(3, 2)
+    # differentiate between E and exp
+    assert exp(exp(x + E)).subs(exp, 3) == 3**(3**(x + E))
+    assert exp(exp(x + E)).subs(exp, sin) == sin(sin(x + E))
+    assert exp(exp(x + E)).subs(E, 3) == 3**(3**(x + 3))
+    assert exp(3).subs(E, sin) == sin(3)
+
+
+def test_exp_adjoint():
+    assert adjoint(exp(x)) == exp(adjoint(x))
+
+
+def test_exp_conjugate():
+    assert conjugate(exp(x)) == exp(conjugate(x))
+
+
+@_both_exp_pow
+def test_exp_transpose():
+    assert transpose(exp(x)) == exp(transpose(x))
+
+
+@_both_exp_pow
+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))
+
+
+@_both_exp_pow
+def test_exp_leading_term():
+    assert exp(x).as_leading_term(x) == 1
+    assert exp(2 + x).as_leading_term(x) == exp(2)
+    assert exp((2*x + 3) / (x+1)).as_leading_term(x) == exp(3)
+
+    # The following tests are commented, since now SymPy returns the
+    # original function when the leading term in the series expansion does
+    # not exist.
+    # raises(NotImplementedError, lambda: exp(1/x).as_leading_term(x))
+    # raises(NotImplementedError, lambda: exp((x + 1) / x**2).as_leading_term(x))
+    # raises(NotImplementedError, lambda: exp(x + 1/x).as_leading_term(x))
+
+
+@_both_exp_pow
+def test_exp_taylor_term():
+    x = symbols('x')
+    assert exp(x).taylor_term(1, x) == x
+    assert exp(x).taylor_term(3, x) == x**3/6
+    assert exp(x).taylor_term(4, x) == x**4/24
+    assert exp(x).taylor_term(-1, x) is S.Zero
+
+
+def test_exp_MatrixSymbol():
+    A = MatrixSymbol("A", 2, 2)
+    assert exp(A).has(exp)
+
+
+def test_exp_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: exp(x).fdiff(2))
+
+
+def test_log_values():
+    assert log(nan) is nan
+
+    assert log(oo) is oo
+    assert log(-oo) is oo
+
+    assert log(zoo) is zoo
+    assert log(-zoo) is zoo
+
+    assert log(0) is zoo
+
+    assert log(1) == 0
+    assert log(-1) == I*pi
+
+    assert log(E) == 1
+    assert log(-E).expand() == 1 + I*pi
+
+    assert unchanged(log, pi)
+    assert log(-pi).expand() == log(pi) + I*pi
+
+    assert unchanged(log, 17)
+    assert log(-17) == log(17) + I*pi
+
+    assert log(I) == I*pi/2
+    assert log(-I) == -I*pi/2
+
+    assert log(17*I) == I*pi/2 + log(17)
+    assert log(-17*I).expand() == -I*pi/2 + log(17)
+
+    assert log(oo*I) is oo
+    assert log(-oo*I) is oo
+    assert log(0, 2) is zoo
+    assert log(0, 5) is zoo
+
+    assert exp(-log(3))**(-1) == 3
+
+    assert log(S.Half) == -log(2)
+    assert log(2*3).func is log
+    assert log(2*3**2).func is log
+
+
+def test_match_real_imag():
+    x, y = symbols('x,y', real=True)
+    i = Symbol('i', imaginary=True)
+    assert match_real_imag(S.One) == (1, 0)
+    assert match_real_imag(I) == (0, 1)
+    assert match_real_imag(3 - 5*I) == (3, -5)
+    assert match_real_imag(-sqrt(3) + S.Half*I) == (-sqrt(3), S.Half)
+    assert match_real_imag(x + y*I) == (x, y)
+    assert match_real_imag(x*I + y*I) == (0, x + y)
+    assert match_real_imag((x + y)*I) == (0, x + y)
+    assert match_real_imag(Rational(-2, 3)*i*I) == (None, None)
+    assert match_real_imag(1 - 2*i) == (None, None)
+    assert match_real_imag(sqrt(2)*(3 - 5*I)) == (None, None)
+
+
+def test_log_exact():
+    # check for pi/2, pi/3, pi/4, pi/6, pi/8, pi/12; pi/5, pi/10:
+    for n in range(-23, 24):
+        if gcd(n, 24) != 1:
+            assert log(exp(n*I*pi/24).rewrite(sqrt)) == n*I*pi/24
+        for n in range(-9, 10):
+            assert log(exp(n*I*pi/10).rewrite(sqrt)) == n*I*pi/10
+
+    assert log(S.Half - I*sqrt(3)/2) == -I*pi/3
+    assert log(Rational(-1, 2) + I*sqrt(3)/2) == I*pi*Rational(2, 3)
+    assert log(-sqrt(2)/2 - I*sqrt(2)/2) == -I*pi*Rational(3, 4)
+    assert log(-sqrt(3)/2 - I*S.Half) == -I*pi*Rational(5, 6)
+
+    assert log(Rational(-1, 4) + sqrt(5)/4 - I*sqrt(sqrt(5)/8 + Rational(5, 8))) == -I*pi*Rational(2, 5)
+    assert log(sqrt(Rational(5, 8) - sqrt(5)/8) + I*(Rational(1, 4) + sqrt(5)/4)) == I*pi*Rational(3, 10)
+    assert log(-sqrt(sqrt(2)/4 + S.Half) + I*sqrt(S.Half - sqrt(2)/4)) == I*pi*Rational(7, 8)
+    assert log(-sqrt(6)/4 - sqrt(2)/4 + I*(-sqrt(6)/4 + sqrt(2)/4)) == -I*pi*Rational(11, 12)
+
+    assert log(-1 + I*sqrt(3)) == log(2) + I*pi*Rational(2, 3)
+    assert log(5 + 5*I) == log(5*sqrt(2)) + I*pi/4
+    assert log(sqrt(-12)) == log(2*sqrt(3)) + I*pi/2
+    assert log(-sqrt(6) + sqrt(2) - I*sqrt(6) - I*sqrt(2)) == log(4) - I*pi*Rational(7, 12)
+    assert log(-sqrt(6-3*sqrt(2)) - I*sqrt(6+3*sqrt(2))) == log(2*sqrt(3)) - I*pi*Rational(5, 8)
+    assert log(1 + I*sqrt(2-sqrt(2))/sqrt(2+sqrt(2))) == log(2/sqrt(sqrt(2) + 2)) + I*pi/8
+    assert log(cos(pi*Rational(7, 12)) + I*sin(pi*Rational(7, 12))) == I*pi*Rational(7, 12)
+    assert log(cos(pi*Rational(6, 5)) + I*sin(pi*Rational(6, 5))) == I*pi*Rational(-4, 5)
+
+    assert log(5*(1 + I)/sqrt(2)) == log(5) + I*pi/4
+    assert log(sqrt(2)*(-sqrt(3) + 1 - sqrt(3)*I - I)) == log(4) - I*pi*Rational(7, 12)
+    assert log(-sqrt(2)*(1 - I*sqrt(3))) == log(2*sqrt(2)) + I*pi*Rational(2, 3)
+    assert log(sqrt(3)*I*(-sqrt(6 - 3*sqrt(2)) - I*sqrt(3*sqrt(2) + 6))) == log(6) - I*pi/8
+
+    zero = (1 + sqrt(2))**2 - 3 - 2*sqrt(2)
+    assert log(zero - I*sqrt(3)) == log(sqrt(3)) - I*pi/2
+    assert unchanged(log, zero + I*zero) or log(zero + zero*I) is zoo
+
+    # bail quickly if no obvious simplification is possible:
+    assert unchanged(log, (sqrt(2)-1/sqrt(sqrt(3)+I))**1000)
+    # beware of non-real coefficients
+    assert unchanged(log, sqrt(2-sqrt(5))*(1 + I))
+
+
+def test_log_base():
+    assert log(1, 2) == 0
+    assert log(2, 2) == 1
+    assert log(3, 2) == log(3)/log(2)
+    assert log(6, 2) == 1 + log(3)/log(2)
+    assert log(6, 3) == 1 + log(2)/log(3)
+    assert log(2**3, 2) == 3
+    assert log(3**3, 3) == 3
+    assert log(5, 1) is zoo
+    assert log(1, 1) is nan
+    assert log(Rational(2, 3), 10) == log(Rational(2, 3))/log(10)
+    assert log(Rational(2, 3), Rational(1, 3)) == -log(2)/log(3) + 1
+    assert log(Rational(2, 3), Rational(2, 5)) == \
+        log(Rational(2, 3))/log(Rational(2, 5))
+    # issue 17148
+    assert log(Rational(8, 3), 2) == -log(3)/log(2) + 3
+
+
+def test_log_symbolic():
+    assert log(x, exp(1)) == log(x)
+    assert log(exp(x)) != x
+
+    assert log(x, exp(1)) == log(x)
+    assert log(x*y) != log(x) + log(y)
+    assert log(x/y).expand() != log(x) - log(y)
+    assert log(x/y).expand(force=True) == log(x) - log(y)
+    assert log(x**y).expand() != y*log(x)
+    assert log(x**y).expand(force=True) == y*log(x)
+
+    assert log(x, 2) == log(x)/log(2)
+    assert log(E, 2) == 1/log(2)
+
+    p, q = symbols('p,q', positive=True)
+    r = Symbol('r', real=True)
+
+    assert log(p**2) != 2*log(p)
+    assert log(p**2).expand() == 2*log(p)
+    assert log(x**2).expand() != 2*log(x)
+    assert log(p**q) != q*log(p)
+    assert log(exp(p)) == p
+    assert log(p*q) != log(p) + log(q)
+    assert log(p*q).expand() == log(p) + log(q)
+
+    assert log(-sqrt(3)) == log(sqrt(3)) + I*pi
+    assert log(-exp(p)) != p + I*pi
+    assert log(-exp(x)).expand() != x + I*pi
+    assert log(-exp(r)).expand() == r + I*pi
+
+    assert log(x**y) != y*log(x)
+
+    assert (log(x**-5)**-1).expand() != -1/log(x)/5
+    assert (log(p**-5)**-1).expand() == -1/log(p)/5
+    assert log(-x).func is log and log(-x).args[0] == -x
+    assert log(-p).func is log and log(-p).args[0] == -p
+
+
+def test_log_exp():
+    assert log(exp(4*I*pi)) == 0     # exp evaluates
+    assert log(exp(-5*I*pi)) == I*pi # exp evaluates
+    assert log(exp(I*pi*Rational(19, 4))) == I*pi*Rational(3, 4)
+    assert log(exp(I*pi*Rational(25, 7))) == I*pi*Rational(-3, 7)
+    assert log(exp(-5*I)) == -5*I + 2*I*pi
+
+
+@_both_exp_pow
+def test_exp_assumptions():
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+    for e in exp, exp_polar:
+        assert e(x).is_real is None
+        assert e(x).is_imaginary is None
+        assert e(i).is_real is None
+        assert e(i).is_imaginary is None
+        assert e(r).is_real is True
+        assert e(r).is_imaginary is False
+        assert e(re(x)).is_extended_real is True
+        assert e(re(x)).is_imaginary is False
+
+    assert Pow(E, I*pi, evaluate=False).is_imaginary == False
+    assert Pow(E, 2*I*pi, evaluate=False).is_imaginary == False
+    assert Pow(E, I*pi/2, evaluate=False).is_imaginary == True
+    assert Pow(E, I*pi/3, evaluate=False).is_imaginary is None
+
+    assert exp(0, evaluate=False).is_algebraic
+
+    a = Symbol('a', algebraic=True)
+    an = Symbol('an', algebraic=True, nonzero=True)
+    r = Symbol('r', rational=True)
+    rn = Symbol('rn', rational=True, nonzero=True)
+    assert exp(a).is_algebraic is None
+    assert exp(an).is_algebraic is False
+    assert exp(pi*r).is_algebraic is None
+    assert exp(pi*rn).is_algebraic is False
+
+    assert exp(0, evaluate=False).is_algebraic is True
+    assert exp(I*pi/3, evaluate=False).is_algebraic is True
+    assert exp(I*pi*r, evaluate=False).is_algebraic is True
+
+
+@_both_exp_pow
+def test_exp_AccumBounds():
+    assert exp(AccumBounds(1, 2)) == AccumBounds(E, E**2)
+
+
+def test_log_assumptions():
+    p = symbols('p', positive=True)
+    n = symbols('n', negative=True)
+    z = symbols('z', zero=True)
+    x = symbols('x', infinite=True, extended_positive=True)
+
+    assert log(z).is_positive is False
+    assert log(x).is_extended_positive is True
+    assert log(2) > 0
+    assert log(1, evaluate=False).is_zero
+    assert log(1 + z).is_zero
+    assert log(p).is_zero is None
+    assert log(n).is_zero is False
+    assert log(0.5).is_negative is True
+    assert log(exp(p) + 1).is_positive
+
+    assert log(1, evaluate=False).is_algebraic
+    assert log(42, evaluate=False).is_algebraic is False
+
+    assert log(1 + z).is_rational
+
+
+def test_log_hashing():
+    assert x != log(log(x))
+    assert hash(x) != hash(log(log(x)))
+    assert log(x) != log(log(log(x)))
+
+    e = 1/log(log(x) + log(log(x)))
+    assert e.base.func is log
+    e = 1/log(log(x) + log(log(log(x))))
+    assert e.base.func is log
+
+    e = log(log(x))
+    assert e.func is log
+    assert x.func is not log
+    assert hash(log(log(x))) != hash(x)
+    assert e != x
+
+
+def test_log_sign():
+    assert sign(log(2)) == 1
+
+
+def test_log_expand_complex():
+    assert log(1 + I).expand(complex=True) == log(2)/2 + I*pi/4
+    assert log(1 - sqrt(2)).expand(complex=True) == log(sqrt(2) - 1) + I*pi
+
+
+def test_log_apply_evalf():
+    value = (log(3)/log(2) - 1).evalf()
+    assert value.epsilon_eq(Float("0.58496250072115618145373"))
+
+
+def test_log_leading_term():
+    p = Symbol('p')
+
+    # Test for STEP 3
+    assert log(1 + x + x**2).as_leading_term(x, cdir=1) == x
+    # Test for STEP 4
+    assert log(2*x).as_leading_term(x, cdir=1) == log(x) + log(2)
+    assert log(2*x).as_leading_term(x, cdir=-1) == log(x) + log(2)
+    assert log(-2*x).as_leading_term(x, cdir=1, logx=p) == p + log(2) + I*pi
+    assert log(-2*x).as_leading_term(x, cdir=-1, logx=p) == p + log(2) - I*pi
+    # Test for STEP 5
+    assert log(-2*x + (3 - I)*x**2).as_leading_term(x, cdir=1) == log(x) + log(2) - I*pi
+    assert log(-2*x + (3 - I)*x**2).as_leading_term(x, cdir=-1) == log(x) + log(2) - I*pi
+    assert log(2*x + (3 - I)*x**2).as_leading_term(x, cdir=1) == log(x) + log(2)
+    assert log(2*x + (3 - I)*x**2).as_leading_term(x, cdir=-1) == log(x) + log(2) - 2*I*pi
+    assert log(-1 + x - I*x**2 + I*x**3).as_leading_term(x, cdir=1) == -I*pi
+    assert log(-1 + x - I*x**2 + I*x**3).as_leading_term(x, cdir=-1) == -I*pi
+    assert log(-1/(1 - x)).as_leading_term(x, cdir=1) == I*pi
+    assert log(-1/(1 - x)).as_leading_term(x, cdir=-1) == I*pi
+
+
+def test_log_nseries():
+    p = Symbol('p')
+    assert log(1/x)._eval_nseries(x, 4, logx=-p, cdir=1) == p
+    assert log(1/x)._eval_nseries(x, 4, logx=-p, cdir=-1) == p + 2*I*pi
+    assert log(x - 1)._eval_nseries(x, 4, None, I) == I*pi - x - x**2/2 - x**3/3 + O(x**4)
+    assert log(x - 1)._eval_nseries(x, 4, None, -I) == -I*pi - x - x**2/2 - x**3/3 + O(x**4)
+    assert log(I*x + I*x**3 - 1)._eval_nseries(x, 3, None, 1) == I*pi - I*x + x**2/2 + O(x**3)
+    assert log(I*x + I*x**3 - 1)._eval_nseries(x, 3, None, -1) == -I*pi - I*x + x**2/2 + O(x**3)
+    assert log(I*x**2 + I*x**3 - 1)._eval_nseries(x, 3, None, 1) == I*pi - I*x**2 + O(x**3)
+    assert log(I*x**2 + I*x**3 - 1)._eval_nseries(x, 3, None, -1) == I*pi - I*x**2 + O(x**3)
+    assert log(2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, 1) == log(2) + log(x) + \
+    x*(S(3)/2 - I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, -1) == -2*I*pi + log(2) + \
+    log(x) - x*(-S(3)/2 + I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(-2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, 1) == -I*pi + log(2) + log(x) + \
+    x*(-S(3)/2 + I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(-2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, -1) == -I*pi + log(2) + log(x) - \
+    x*(S(3)/2 - I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(sqrt(-I*x**2 - 3)*sqrt(-I*x**2 - 1) - 2)._eval_nseries(x, 3, None, 1) == -I*pi + \
+    log(sqrt(3) + 2) + I*x**2*(-2 + 4*sqrt(3)/3) + O(x**3)
+    assert log(-1/(1 - x))._eval_nseries(x, 3, None, 1) == I*pi + x + x**2/2 + O(x**3)
+    assert log(-1/(1 - x))._eval_nseries(x, 3, None, -1) == I*pi + x + x**2/2 + O(x**3)
+
+
+def test_log_series():
+    # Note Series at infinities other than oo/-oo were introduced as a part of
+    # pull request 23798. Refer https://github.com/sympy/sympy/pull/23798 for
+    # more information.
+    expr1 = log(1 + x)
+    expr2 = log(x + sqrt(x**2 + 1))
+
+    assert expr1.series(x, x0=I*oo, n=4) == 1/(3*x**3) - 1/(2*x**2) + 1/x + \
+    I*pi/2 - log(I/x) + O(x**(-4), (x, oo*I))
+    assert expr1.series(x, x0=-I*oo, n=4) == 1/(3*x**3) - 1/(2*x**2) + 1/x - \
+    I*pi/2 - log(-I/x) + O(x**(-4), (x, -oo*I))
+    assert expr2.series(x, x0=I*oo, n=4) == 1/(4*x**2) + I*pi/2 + log(2) - \
+    log(I/x) + O(x**(-4), (x, oo*I))
+    assert expr2.series(x, x0=-I*oo, n=4) == -1/(4*x**2) - I*pi/2 - log(2) + \
+    log(-I/x) + O(x**(-4), (x, -oo*I))
+
+
+def test_log_expand():
+    w = Symbol("w", positive=True)
+    e = log(w**(log(5)/log(3)))
+    assert e.expand() == log(5)/log(3) * log(w)
+    x, y, z = symbols('x,y,z', positive=True)
+    assert log(x*(y + z)).expand(mul=False) == log(x) + log(y + z)
+    assert log(log(x**2)*log(y*z)).expand() in [log(2*log(x)*log(y) +
+        2*log(x)*log(z)), log(log(x)*log(z) + log(y)*log(x)) + log(2),
+        log((log(y) + log(z))*log(x)) + log(2)]
+    assert log(x**log(x**2)).expand(deep=False) == log(x)*log(x**2)
+    assert log(x**log(x**2)).expand() == 2*log(x)**2
+    x, y = symbols('x,y')
+    assert log(x*y).expand(force=True) == log(x) + log(y)
+    assert log(x**y).expand(force=True) == y*log(x)
+    assert log(exp(x)).expand(force=True) == x
+
+    # there's generally no need to expand out logs since this requires
+    # factoring and if simplification is sought, it's cheaper to put
+    # logs together than it is to take them apart.
+    assert log(2*3**2).expand() != 2*log(3) + log(2)
+
+
+@XFAIL
+def test_log_expand_fail():
+    x, y, z = symbols('x,y,z', positive=True)
+    assert (log(x*(y + z))*(x + y)).expand(mul=True, log=True) == y*log(
+        x) + y*log(y + z) + z*log(x) + z*log(y + z)
+
+
+def test_log_simplify():
+    x = Symbol("x", positive=True)
+    assert log(x**2).expand() == 2*log(x)
+    assert expand_log(log(x**(2 + log(2)))) == (2 + log(2))*log(x)
+
+    z = Symbol('z')
+    assert log(sqrt(z)).expand() == log(z)/2
+    assert expand_log(log(z**(log(2) - 1))) == (log(2) - 1)*log(z)
+    assert log(z**(-1)).expand() != -log(z)
+    assert log(z**(x/(x+1))).expand() == x*log(z)/(x + 1)
+
+
+def test_log_AccumBounds():
+    assert log(AccumBounds(1, E)) == AccumBounds(0, 1)
+    assert log(AccumBounds(0, E)) == AccumBounds(-oo, 1)
+    assert log(AccumBounds(-1, E)) == S.NaN
+    assert log(AccumBounds(0, oo)) == AccumBounds(-oo, oo)
+    assert log(AccumBounds(-oo, 0)) == S.NaN
+    assert log(AccumBounds(-oo, oo)) == S.NaN
+
+
+@_both_exp_pow
+def test_lambertw():
+    k = Symbol('k')
+
+    assert LambertW(x, 0) == LambertW(x)
+    assert LambertW(x, 0, evaluate=False) != LambertW(x)
+    assert LambertW(0) == 0
+    assert LambertW(E) == 1
+    assert LambertW(-1/E) == -1
+    assert LambertW(-log(2)/2) == -log(2)
+    assert LambertW(oo) is oo
+    assert LambertW(0, 1) is -oo
+    assert LambertW(0, 42) is -oo
+    assert LambertW(-pi/2, -1) == -I*pi/2
+    assert LambertW(-1/E, -1) == -1
+    assert LambertW(-2*exp(-2), -1) == -2
+    assert LambertW(2*log(2)) == log(2)
+    assert LambertW(-pi/2) == I*pi/2
+    assert LambertW(exp(1 + E)) == E
+
+    assert LambertW(x**2).diff(x) == 2*LambertW(x**2)/x/(1 + LambertW(x**2))
+    assert LambertW(x, k).diff(x) == LambertW(x, k)/x/(1 + LambertW(x, k))
+
+    assert LambertW(sqrt(2)).evalf(30).epsilon_eq(
+        Float("0.701338383413663009202120278965", 30), 1e-29)
+    assert re(LambertW(2, -1)).evalf().epsilon_eq(Float("-0.834310366631110"))
+
+    assert LambertW(-1).is_real is False  # issue 5215
+    assert LambertW(2, evaluate=False).is_real
+    p = Symbol('p', positive=True)
+    assert LambertW(p, evaluate=False).is_real
+    assert LambertW(p - 1, evaluate=False).is_real is None
+    assert LambertW(-p - 2/S.Exp1, evaluate=False).is_real is False
+    assert LambertW(S.Half, -1, evaluate=False).is_real is False
+    assert LambertW(Rational(-1, 10), -1, evaluate=False).is_real
+    assert LambertW(-10, -1, evaluate=False).is_real is False
+    assert LambertW(-2, 2, evaluate=False).is_real is False
+
+    assert LambertW(0, evaluate=False).is_algebraic
+    na = Symbol('na', nonzero=True, algebraic=True)
+    assert LambertW(na).is_algebraic is False
+    assert LambertW(p).is_zero is False
+    n = Symbol('n', negative=True)
+    assert LambertW(n).is_zero is False
+
+
+def test_issue_5673():
+    e = LambertW(-1)
+    assert e.is_comparable is False
+    assert e.is_positive is not True
+    e2 = 1 - 1/(1 - exp(-1000))
+    assert e2.is_positive is not True
+    e3 = -2 + exp(exp(LambertW(log(2)))*LambertW(log(2)))
+    assert e3.is_nonzero is not True
+
+
+def test_log_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: log(x).fdiff(2))
+
+
+def test_log_taylor_term():
+    x = symbols('x')
+    assert log(x).taylor_term(0, x) == x
+    assert log(x).taylor_term(1, x) == -x**2/2
+    assert log(x).taylor_term(4, x) == x**5/5
+    assert log(x).taylor_term(-1, x) is S.Zero
+
+
+def test_exp_expand_NC():
+    A, B, C = symbols('A,B,C', commutative=False)
+
+    assert exp(A + B).expand() == exp(A + B)
+    assert exp(A + B + C).expand() == exp(A + B + C)
+    assert exp(x + y).expand() == exp(x)*exp(y)
+    assert exp(x + y + z).expand() == exp(x)*exp(y)*exp(z)
+
+
+@_both_exp_pow
+def test_as_numer_denom():
+    n = symbols('n', negative=True)
+    assert exp(x).as_numer_denom() == (exp(x), 1)
+    assert exp(-x).as_numer_denom() == (1, exp(x))
+    assert exp(-2*x).as_numer_denom() == (1, exp(2*x))
+    assert exp(-2).as_numer_denom() == (1, exp(2))
+    assert exp(n).as_numer_denom() == (1, exp(-n))
+    assert exp(-n).as_numer_denom() == (exp(-n), 1)
+    assert exp(-I*x).as_numer_denom() == (1, exp(I*x))
+    assert exp(-I*n).as_numer_denom() == (1, exp(I*n))
+    assert exp(-n).as_numer_denom() == (exp(-n), 1)
+
+
+@_both_exp_pow
+def test_polar():
+    x, y = symbols('x y', polar=True)
+
+    assert abs(exp_polar(I*4)) == 1
+    assert abs(exp_polar(0)) == 1
+    assert abs(exp_polar(2 + 3*I)) == exp(2)
+    assert exp_polar(I*10).n() == exp_polar(I*10)
+
+    assert log(exp_polar(z)) == z
+    assert log(x*y).expand() == log(x) + log(y)
+    assert log(x**z).expand() == z*log(x)
+
+    assert exp_polar(3).exp == 3
+
+    # Compare exp(1.0*pi*I).
+    assert (exp_polar(1.0*pi*I).n(n=5)).as_real_imag()[1] >= 0
+
+    assert exp_polar(0).is_rational is True  # issue 8008
+
+
+def test_exp_summation():
+    w = symbols("w")
+    m, n, i, j = symbols("m n i j")
+    expr = exp(Sum(w*i, (i, 0, n), (j, 0, m)))
+    assert expr.expand() == Product(exp(w*i), (i, 0, n), (j, 0, m))
+
+
+def test_log_product():
+    from sympy.abc import n, m
+
+    i, j = symbols('i,j', positive=True, integer=True)
+    x, y = symbols('x,y', positive=True)
+    z = symbols('z', real=True)
+    w = symbols('w')
+
+    expr = log(Product(x**i, (i, 1, n)))
+    assert simplify(expr) == expr
+    assert expr.expand() == Sum(i*log(x), (i, 1, n))
+    expr = log(Product(x**i*y**j, (i, 1, n), (j, 1, m)))
+    assert simplify(expr) == expr
+    assert expr.expand() == Sum(i*log(x) + j*log(y), (i, 1, n), (j, 1, m))
+
+    expr = log(Product(-2, (n, 0, 4)))
+    assert simplify(expr) == expr
+    assert expr.expand() == expr
+    assert expr.expand(force=True) == Sum(log(-2), (n, 0, 4))
+
+    expr = log(Product(exp(z*i), (i, 0, n)))
+    assert expr.expand() == Sum(z*i, (i, 0, n))
+
+    expr = log(Product(exp(w*i), (i, 0, n)))
+    assert expr.expand() == expr
+    assert expr.expand(force=True) == Sum(w*i, (i, 0, n))
+
+    expr = log(Product(i**2*abs(j), (i, 1, n), (j, 1, m)))
+    assert expr.expand() == Sum(2*log(i) + log(j), (i, 1, n), (j, 1, m))
+
+
+@XFAIL
+def test_log_product_simplify_to_sum():
+    from sympy.abc import n, m
+    i, j = symbols('i,j', positive=True, integer=True)
+    x, y = symbols('x,y', positive=True)
+    assert simplify(log(Product(x**i, (i, 1, n)))) == Sum(i*log(x), (i, 1, n))
+    assert simplify(log(Product(x**i*y**j, (i, 1, n), (j, 1, m)))) == \
+            Sum(i*log(x) + j*log(y), (i, 1, n), (j, 1, m))
+
+
+def test_issue_8866():
+    assert simplify(log(x, 10, evaluate=False)) == simplify(log(x, 10))
+    assert expand_log(log(x, 10, evaluate=False)) == expand_log(log(x, 10))
+
+    y = Symbol('y', positive=True)
+    l1 = log(exp(y), exp(10))
+    b1 = log(exp(y), exp(5))
+    l2 = log(exp(y), exp(10), evaluate=False)
+    b2 = log(exp(y), exp(5), evaluate=False)
+    assert simplify(log(l1, b1)) == simplify(log(l2, b2))
+    assert expand_log(log(l1, b1)) == expand_log(log(l2, b2))
+
+
+def test_log_expand_factor():
+    assert (log(18)/log(3) - 2).expand(factor=True) == log(2)/log(3)
+    assert (log(12)/log(2)).expand(factor=True) == log(3)/log(2) + 2
+    assert (log(15)/log(3)).expand(factor=True) == 1 + log(5)/log(3)
+    assert (log(2)/(-log(12) + log(24))).expand(factor=True) == 1
+
+    assert expand_log(log(12), factor=True) == log(3) + 2*log(2)
+    assert expand_log(log(21)/log(7), factor=False) == log(3)/log(7) + 1
+    assert expand_log(log(45)/log(5) + log(20), factor=False) == \
+        1 + 2*log(3)/log(5) + log(20)
+    assert expand_log(log(45)/log(5) + log(26), factor=True) == \
+        log(2) + log(13) + (log(5) + 2*log(3))/log(5)
+
+
+def test_issue_9116():
+    n = Symbol('n', positive=True, integer=True)
+    assert log(n).is_nonnegative is True
+
+
+def test_issue_18473():
+    assert exp(x*log(cos(1/x))).as_leading_term(x) == S.NaN
+    assert exp(x*log(tan(1/x))).as_leading_term(x) == S.NaN
+    assert log(cos(1/x)).as_leading_term(x) == S.NaN
+    assert log(tan(1/x)).as_leading_term(x) == S.NaN
+    assert log(cos(1/x) + 2).as_leading_term(x) == AccumBounds(0, log(3))
+    assert exp(x*log(cos(1/x) + 2)).as_leading_term(x) == 1
+    assert log(cos(1/x) - 2).as_leading_term(x) == S.NaN
+    assert exp(x*log(cos(1/x) - 2)).as_leading_term(x) == S.NaN
+    assert log(cos(1/x) + 1).as_leading_term(x) == AccumBounds(-oo, log(2))
+    assert exp(x*log(cos(1/x) + 1)).as_leading_term(x) == AccumBounds(0, 1)
+    assert log(sin(1/x)**2).as_leading_term(x) == AccumBounds(-oo, 0)
+    assert exp(x*log(sin(1/x)**2)).as_leading_term(x) == AccumBounds(0, 1)
+    assert log(tan(1/x)**2).as_leading_term(x) == AccumBounds(-oo, oo)
+    assert exp(2*x*(log(tan(1/x)**2))).as_leading_term(x) == AccumBounds(0, oo)

venv/lib/python3.10/site-packages/sympy/functions/elementary/tests/test_interface.py

@@ -0,0 +1,72 @@
+# This test file tests the SymPy function interface, that people use to create
+# their own new functions. It should be as easy as possible.
+from sympy.core.function import Function
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.limits import limit
+from sympy.abc import x
+
+
+def test_function_series1():
+    """Create our new "sin" function."""
+
+    class my_function(Function):
+
+        def fdiff(self, argindex=1):
+            return cos(self.args[0])
+
+        @classmethod
+        def eval(cls, arg):
+            arg = sympify(arg)
+            if arg == 0:
+                return sympify(0)
+
+    #Test that the taylor series is correct
+    assert my_function(x).series(x, 0, 10) == sin(x).series(x, 0, 10)
+    assert limit(my_function(x)/x, x, 0) == 1
+
+
+def test_function_series2():
+    """Create our new "cos" function."""
+
+    class my_function2(Function):
+
+        def fdiff(self, argindex=1):
+            return -sin(self.args[0])
+
+        @classmethod
+        def eval(cls, arg):
+            arg = sympify(arg)
+            if arg == 0:
+                return sympify(1)
+
+    #Test that the taylor series is correct
+    assert my_function2(x).series(x, 0, 10) == cos(x).series(x, 0, 10)
+
+
+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)

venv/lib/python3.10/site-packages/sympy/functions/elementary/tests/test_miscellaneous.py

@@ -0,0 +1,504 @@
+import itertools as it
+
+from sympy.core.expr import unchanged
+from sympy.core.function import Function
+from sympy.core.numbers import I, oo, Rational
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.external import import_module
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.integers import floor, ceiling
+from sympy.functions.elementary.miscellaneous import (sqrt, cbrt, root, Min,
+                                                      Max, real_root, Rem)
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.functions.special.delta_functions import Heaviside
+
+from sympy.utilities.lambdify import lambdify
+from sympy.testing.pytest import raises, skip, ignore_warnings
+
+def test_Min():
+    from sympy.abc import x, y, z
+    n = Symbol('n', negative=True)
+    n_ = Symbol('n_', negative=True)
+    nn = Symbol('nn', nonnegative=True)
+    nn_ = Symbol('nn_', nonnegative=True)
+    p = Symbol('p', positive=True)
+    p_ = Symbol('p_', positive=True)
+    np = Symbol('np', nonpositive=True)
+    np_ = Symbol('np_', nonpositive=True)
+    r = Symbol('r', real=True)
+
+    assert Min(5, 4) == 4
+    assert Min(-oo, -oo) is -oo
+    assert Min(-oo, n) is -oo
+    assert Min(n, -oo) is -oo
+    assert Min(-oo, np) is -oo
+    assert Min(np, -oo) is -oo
+    assert Min(-oo, 0) is -oo
+    assert Min(0, -oo) is -oo
+    assert Min(-oo, nn) is -oo
+    assert Min(nn, -oo) is -oo
+    assert Min(-oo, p) is -oo
+    assert Min(p, -oo) is -oo
+    assert Min(-oo, oo) is -oo
+    assert Min(oo, -oo) is -oo
+    assert Min(n, n) == n
+    assert unchanged(Min, n, np)
+    assert Min(np, n) == Min(n, np)
+    assert Min(n, 0) == n
+    assert Min(0, n) == n
+    assert Min(n, nn) == n
+    assert Min(nn, n) == n
+    assert Min(n, p) == n
+    assert Min(p, n) == n
+    assert Min(n, oo) == n
+    assert Min(oo, n) == n
+    assert Min(np, np) == np
+    assert Min(np, 0) == np
+    assert Min(0, np) == np
+    assert Min(np, nn) == np
+    assert Min(nn, np) == np
+    assert Min(np, p) == np
+    assert Min(p, np) == np
+    assert Min(np, oo) == np
+    assert Min(oo, np) == np
+    assert Min(0, 0) == 0
+    assert Min(0, nn) == 0
+    assert Min(nn, 0) == 0
+    assert Min(0, p) == 0
+    assert Min(p, 0) == 0
+    assert Min(0, oo) == 0
+    assert Min(oo, 0) == 0
+    assert Min(nn, nn) == nn
+    assert unchanged(Min, nn, p)
+    assert Min(p, nn) == Min(nn, p)
+    assert Min(nn, oo) == nn
+    assert Min(oo, nn) == nn
+    assert Min(p, p) == p
+    assert Min(p, oo) == p
+    assert Min(oo, p) == p
+    assert Min(oo, oo) is oo
+
+    assert Min(n, n_).func is Min
+    assert Min(nn, nn_).func is Min
+    assert Min(np, np_).func is Min
+    assert Min(p, p_).func is Min
+
+    # lists
+    assert Min() is S.Infinity
+    assert Min(x) == x
+    assert Min(x, y) == Min(y, x)
+    assert Min(x, y, z) == Min(z, y, x)
+    assert Min(x, Min(y, z)) == Min(z, y, x)
+    assert Min(x, Max(y, -oo)) == Min(x, y)
+    assert Min(p, oo, n, p, p, p_) == n
+    assert Min(p_, n_, p) == n_
+    assert Min(n, oo, -7, p, p, 2) == Min(n, -7)
+    assert Min(2, x, p, n, oo, n_, p, 2, -2, -2) == Min(-2, x, n, n_)
+    assert Min(0, x, 1, y) == Min(0, x, y)
+    assert Min(1000, 100, -100, x, p, n) == Min(n, x, -100)
+    assert unchanged(Min, sin(x), cos(x))
+    assert Min(sin(x), cos(x)) == Min(cos(x), sin(x))
+    assert Min(cos(x), sin(x)).subs(x, 1) == cos(1)
+    assert Min(cos(x), sin(x)).subs(x, S.Half) == sin(S.Half)
+    raises(ValueError, lambda: Min(cos(x), sin(x)).subs(x, I))
+    raises(ValueError, lambda: Min(I))
+    raises(ValueError, lambda: Min(I, x))
+    raises(ValueError, lambda: Min(S.ComplexInfinity, x))
+
+    assert Min(1, x).diff(x) == Heaviside(1 - x)
+    assert Min(x, 1).diff(x) == Heaviside(1 - x)
+    assert Min(0, -x, 1 - 2*x).diff(x) == -Heaviside(x + Min(0, -2*x + 1)) \
+        - 2*Heaviside(2*x + Min(0, -x) - 1)
+
+    # issue 7619
+    f = Function('f')
+    assert Min(1, 2*Min(f(1), 2))  # doesn't fail
+
+    # issue 7233
+    e = Min(0, x)
+    assert e.n().args == (0, x)
+
+    # issue 8643
+    m = Min(n, p_, n_, r)
+    assert m.is_positive is False
+    assert m.is_nonnegative is False
+    assert m.is_negative is True
+
+    m = Min(p, p_)
+    assert m.is_positive is True
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+    m = Min(p, nn_, p_)
+    assert m.is_positive is None
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+    m = Min(nn, p, r)
+    assert m.is_positive is None
+    assert m.is_nonnegative is None
+    assert m.is_negative is None
+
+
+def test_Max():
+    from sympy.abc import x, y, z
+    n = Symbol('n', negative=True)
+    n_ = Symbol('n_', negative=True)
+    nn = Symbol('nn', nonnegative=True)
+    p = Symbol('p', positive=True)
+    p_ = Symbol('p_', positive=True)
+    r = Symbol('r', real=True)
+
+    assert Max(5, 4) == 5
+
+    # lists
+
+    assert Max() is S.NegativeInfinity
+    assert Max(x) == x
+    assert Max(x, y) == Max(y, x)
+    assert Max(x, y, z) == Max(z, y, x)
+    assert Max(x, Max(y, z)) == Max(z, y, x)
+    assert Max(x, Min(y, oo)) == Max(x, y)
+    assert Max(n, -oo, n_, p, 2) == Max(p, 2)
+    assert Max(n, -oo, n_, p) == p
+    assert Max(2, x, p, n, -oo, S.NegativeInfinity, n_, p, 2) == Max(2, x, p)
+    assert Max(0, x, 1, y) == Max(1, x, y)
+    assert Max(r, r + 1, r - 1) == 1 + r
+    assert Max(1000, 100, -100, x, p, n) == Max(p, x, 1000)
+    assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
+    assert Max(cos(x), sin(x)).subs(x, 1) == sin(1)
+    assert Max(cos(x), sin(x)).subs(x, S.Half) == cos(S.Half)
+    raises(ValueError, lambda: Max(cos(x), sin(x)).subs(x, I))
+    raises(ValueError, lambda: Max(I))
+    raises(ValueError, lambda: Max(I, x))
+    raises(ValueError, lambda: Max(S.ComplexInfinity, 1))
+    assert Max(n, -oo, n_,  p, 2) == Max(p, 2)
+    assert Max(n, -oo, n_,  p, 1000) == Max(p, 1000)
+
+    assert Max(1, x).diff(x) == Heaviside(x - 1)
+    assert Max(x, 1).diff(x) == Heaviside(x - 1)
+    assert Max(x**2, 1 + x, 1).diff(x) == \
+        2*x*Heaviside(x**2 - Max(1, x + 1)) \
+        + Heaviside(x - Max(1, x**2) + 1)
+
+    e = Max(0, x)
+    assert e.n().args == (0, x)
+
+    # issue 8643
+    m = Max(p, p_, n, r)
+    assert m.is_positive is True
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+    m = Max(n, n_)
+    assert m.is_positive is False
+    assert m.is_nonnegative is False
+    assert m.is_negative is True
+
+    m = Max(n, n_, r)
+    assert m.is_positive is None
+    assert m.is_nonnegative is None
+    assert m.is_negative is None
+
+    m = Max(n, nn, r)
+    assert m.is_positive is None
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+
+def test_minmax_assumptions():
+    r = Symbol('r', real=True)
+    a = Symbol('a', real=True, algebraic=True)
+    t = Symbol('t', real=True, transcendental=True)
+    q = Symbol('q', rational=True)
+    p = Symbol('p', irrational=True)
+    n = Symbol('n', rational=True, integer=False)
+    i = Symbol('i', integer=True)
+    o = Symbol('o', odd=True)
+    e = Symbol('e', even=True)
+    k = Symbol('k', prime=True)
+    reals = [r, a, t, q, p, n, i, o, e, k]
+
+    for ext in (Max, Min):
+        for x, y in it.product(reals, repeat=2):
+
+            # Must be real
+            assert ext(x, y).is_real
+
+            # Algebraic?
+            if x.is_algebraic and y.is_algebraic:
+                assert ext(x, y).is_algebraic
+            elif x.is_transcendental and y.is_transcendental:
+                assert ext(x, y).is_transcendental
+            else:
+                assert ext(x, y).is_algebraic is None
+
+            # Rational?
+            if x.is_rational and y.is_rational:
+                assert ext(x, y).is_rational
+            elif x.is_irrational and y.is_irrational:
+                assert ext(x, y).is_irrational
+            else:
+                assert ext(x, y).is_rational is None
+
+            # Integer?
+            if x.is_integer and y.is_integer:
+                assert ext(x, y).is_integer
+            elif x.is_noninteger and y.is_noninteger:
+                assert ext(x, y).is_noninteger
+            else:
+                assert ext(x, y).is_integer is None
+
+            # Odd?
+            if x.is_odd and y.is_odd:
+                assert ext(x, y).is_odd
+            elif x.is_odd is False and y.is_odd is False:
+                assert ext(x, y).is_odd is False
+            else:
+                assert ext(x, y).is_odd is None
+
+            # Even?
+            if x.is_even and y.is_even:
+                assert ext(x, y).is_even
+            elif x.is_even is False and y.is_even is False:
+                assert ext(x, y).is_even is False
+            else:
+                assert ext(x, y).is_even is None
+
+            # Prime?
+            if x.is_prime and y.is_prime:
+                assert ext(x, y).is_prime
+            elif x.is_prime is False and y.is_prime is False:
+                assert ext(x, y).is_prime is False
+            else:
+                assert ext(x, y).is_prime is None
+
+
+def test_issue_8413():
+    x = Symbol('x', real=True)
+    # we can't evaluate in general because non-reals are not
+    # comparable: Min(floor(3.2 + I), 3.2 + I) -> ValueError
+    assert Min(floor(x), x) == floor(x)
+    assert Min(ceiling(x), x) == x
+    assert Max(floor(x), x) == x
+    assert Max(ceiling(x), x) == ceiling(x)
+
+
+def test_root():
+    from sympy.abc import x
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+
+    assert root(2, 2) == sqrt(2)
+    assert root(2, 1) == 2
+    assert root(2, 3) == 2**Rational(1, 3)
+    assert root(2, 3) == cbrt(2)
+    assert root(2, -5) == 2**Rational(4, 5)/2
+
+    assert root(-2, 1) == -2
+
+    assert root(-2, 2) == sqrt(2)*I
+    assert root(-2, 1) == -2
+
+    assert root(x, 2) == sqrt(x)
+    assert root(x, 1) == x
+    assert root(x, 3) == x**Rational(1, 3)
+    assert root(x, 3) == cbrt(x)
+    assert root(x, -5) == x**Rational(-1, 5)
+
+    assert root(x, n) == x**(1/n)
+    assert root(x, -n) == x**(-1/n)
+
+    assert root(x, n, k) == (-1)**(2*k/n)*x**(1/n)
+
+
+def test_real_root():
+    assert real_root(-8, 3) == -2
+    assert real_root(-16, 4) == root(-16, 4)
+    r = root(-7, 4)
+    assert real_root(r) == r
+    r1 = root(-1, 3)
+    r2 = r1**2
+    r3 = root(-1, 4)
+    assert real_root(r1 + r2 + r3) == -1 + r2 + r3
+    assert real_root(root(-2, 3)) == -root(2, 3)
+    assert real_root(-8., 3) == -2.0
+    x = Symbol('x')
+    n = Symbol('n')
+    g = real_root(x, n)
+    assert g.subs({"x": -8, "n": 3}) == -2
+    assert g.subs({"x": 8, "n": 3}) == 2
+    # give principle root if there is no real root -- if this is not desired
+    # then maybe a Root class is needed to raise an error instead
+    assert g.subs({"x": I, "n": 3}) == cbrt(I)
+    assert g.subs({"x": -8, "n": 2}) == sqrt(-8)
+    assert g.subs({"x": I, "n": 2}) == sqrt(I)
+
+
+def test_issue_11463():
+    numpy = import_module('numpy')
+    if not numpy:
+        skip("numpy not installed.")
+    x = Symbol('x')
+    f = lambdify(x, real_root((log(x/(x-2))), 3), 'numpy')
+    # numpy.select evaluates all options before considering conditions,
+    # so it raises a warning about root of negative number which does
+    # not affect the outcome. This warning is suppressed here
+    with ignore_warnings(RuntimeWarning):
+        assert f(numpy.array(-1)) < -1
+
+
+def test_rewrite_MaxMin_as_Heaviside():
+    from sympy.abc import x
+    assert Max(0, x).rewrite(Heaviside) == x*Heaviside(x)
+    assert Max(3, x).rewrite(Heaviside) == x*Heaviside(x - 3) + \
+        3*Heaviside(-x + 3)
+    assert Max(0, x+2, 2*x).rewrite(Heaviside) == \
+        2*x*Heaviside(2*x)*Heaviside(x - 2) + \
+        (x + 2)*Heaviside(-x + 2)*Heaviside(x + 2)
+
+    assert Min(0, x).rewrite(Heaviside) == x*Heaviside(-x)
+    assert Min(3, x).rewrite(Heaviside) == x*Heaviside(-x + 3) + \
+        3*Heaviside(x - 3)
+    assert Min(x, -x, -2).rewrite(Heaviside) == \
+        x*Heaviside(-2*x)*Heaviside(-x - 2) - \
+        x*Heaviside(2*x)*Heaviside(x - 2) \
+        - 2*Heaviside(-x + 2)*Heaviside(x + 2)
+
+
+def test_rewrite_MaxMin_as_Piecewise():
+    from sympy.core.symbol import symbols
+    from sympy.functions.elementary.piecewise import Piecewise
+    x, y, z, a, b = symbols('x y z a b', real=True)
+    vx, vy, va = symbols('vx vy va')
+    assert Max(a, b).rewrite(Piecewise) == Piecewise((a, a >= b), (b, True))
+    assert Max(x, y, z).rewrite(Piecewise) == Piecewise((x, (x >= y) & (x >= z)), (y, y >= z), (z, True))
+    assert Max(x, y, a, b).rewrite(Piecewise) == Piecewise((a, (a >= b) & (a >= x) & (a >= y)),
+        (b, (b >= x) & (b >= y)), (x, x >= y), (y, True))
+    assert Min(a, b).rewrite(Piecewise) == Piecewise((a, a <= b), (b, True))
+    assert Min(x, y, z).rewrite(Piecewise) == Piecewise((x, (x <= y) & (x <= z)), (y, y <= z), (z, True))
+    assert Min(x,  y, a, b).rewrite(Piecewise) ==  Piecewise((a, (a <= b) & (a <= x) & (a <= y)),
+        (b, (b <= x) & (b <= y)), (x, x <= y), (y, True))
+
+    # Piecewise rewriting of Min/Max does also takes place for not explicitly real arguments
+    assert Max(vx, vy).rewrite(Piecewise) == Piecewise((vx, vx >= vy), (vy, True))
+    assert Min(va, vx, vy).rewrite(Piecewise) == Piecewise((va, (va <= vx) & (va <= vy)), (vx, vx <= vy), (vy, True))
+
+
+def test_issue_11099():
+    from sympy.abc import x, y
+    # some fixed value tests
+    fixed_test_data = {x: -2, y: 3}
+    assert Min(x, y).evalf(subs=fixed_test_data) == \
+        Min(x, y).subs(fixed_test_data).evalf()
+    assert Max(x, y).evalf(subs=fixed_test_data) == \
+        Max(x, y).subs(fixed_test_data).evalf()
+    # randomly generate some test data
+    from sympy.core.random import randint
+    for i in range(20):
+        random_test_data = {x: randint(-100, 100), y: randint(-100, 100)}
+        assert Min(x, y).evalf(subs=random_test_data) == \
+            Min(x, y).subs(random_test_data).evalf()
+        assert Max(x, y).evalf(subs=random_test_data) == \
+            Max(x, y).subs(random_test_data).evalf()
+
+
+def test_issue_12638():
+    from sympy.abc import a, b, c
+    assert Min(a, b, c, Max(a, b)) == Min(a, b, c)
+    assert Min(a, b, Max(a, b, c)) == Min(a, b)
+    assert Min(a, b, Max(a, c)) == Min(a, b)
+
+def test_issue_21399():
+    from sympy.abc import a, b, c
+    assert Max(Min(a, b), Min(a, b, c)) == Min(a, b)
+
+
+def test_instantiation_evaluation():
+    from sympy.abc import v, w, x, y, z
+    assert Min(1, Max(2, x)) == 1
+    assert Max(3, Min(2, x)) == 3
+    assert Min(Max(x, y), Max(x, z)) == Max(x, Min(y, z))
+    assert set(Min(Max(w, x), Max(y, z)).args) == {
+        Max(w, x), Max(y, z)}
+    assert Min(Max(x, y), Max(x, z), w) == Min(
+        w, Max(x, Min(y, z)))
+    A, B = Min, Max
+    for i in range(2):
+        assert A(x, B(x, y)) == x
+        assert A(x, B(y, A(x, w, z))) == A(x, B(y, A(w, z)))
+        A, B = B, A
+    assert Min(w, Max(x, y), Max(v, x, z)) == Min(
+        w, Max(x, Min(y, Max(v, z))))
+
+def test_rewrite_as_Abs():
+    from itertools import permutations
+    from sympy.functions.elementary.complexes import Abs
+    from sympy.abc import x, y, z, w
+    def test(e):
+        free = e.free_symbols
+        a = e.rewrite(Abs)
+        assert not a.has(Min, Max)
+        for i in permutations(range(len(free))):
+            reps = dict(zip(free, i))
+            assert a.xreplace(reps) == e.xreplace(reps)
+    test(Min(x, y))
+    test(Max(x, y))
+    test(Min(x, y, z))
+    test(Min(Max(w, x), Max(y, z)))
+
+def test_issue_14000():
+    assert isinstance(sqrt(4, evaluate=False), Pow) == True
+    assert isinstance(cbrt(3.5, evaluate=False), Pow) == True
+    assert isinstance(root(16, 4, evaluate=False), Pow) == True
+
+    assert sqrt(4, evaluate=False) == Pow(4, S.Half, evaluate=False)
+    assert cbrt(3.5, evaluate=False) == Pow(3.5, Rational(1, 3), evaluate=False)
+    assert root(4, 2, evaluate=False) == Pow(4, S.Half, evaluate=False)
+
+    assert root(16, 4, 2, evaluate=False).has(Pow) == True
+    assert real_root(-8, 3, evaluate=False).has(Pow) == True
+
+def test_issue_6899():
+    from sympy.core.function import Lambda
+    x = Symbol('x')
+    eqn = Lambda(x, x)
+    assert eqn.func(*eqn.args) == eqn
+
+def test_Rem():
+    from sympy.abc import x, y
+    assert Rem(5, 3) == 2
+    assert Rem(-5, 3) == -2
+    assert Rem(5, -3) == 2
+    assert Rem(-5, -3) == -2
+    assert Rem(x**3, y) == Rem(x**3, y)
+    assert Rem(Rem(-5, 3) + 3, 3) == 1
+
+
+def test_minmax_no_evaluate():
+    from sympy import evaluate
+    p = Symbol('p', positive=True)
+
+    assert Max(1, 3) == 3
+    assert Max(1, 3).args == ()
+    assert Max(0, p) == p
+    assert Max(0, p).args == ()
+    assert Min(0, p) == 0
+    assert Min(0, p).args == ()
+
+    assert Max(1, 3, evaluate=False) != 3
+    assert Max(1, 3, evaluate=False).args == (1, 3)
+    assert Max(0, p, evaluate=False) != p
+    assert Max(0, p, evaluate=False).args == (0, p)
+    assert Min(0, p, evaluate=False) != 0
+    assert Min(0, p, evaluate=False).args == (0, p)
+
+    with evaluate(False):
+        assert Max(1, 3) != 3
+        assert Max(1, 3).args == (1, 3)
+        assert Max(0, p) != p
+        assert Max(0, p).args == (0, p)
+        assert Min(0, p) != 0
+        assert Min(0, p).args == (0, p)

venv/lib/python3.10/site-packages/sympy/functions/elementary/tests/test_piecewise.py

@@ -0,0 +1,1606 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import unchanged
+from sympy.core.function import (Function, diff, expand)
+from sympy.core.mul import Mul
+from sympy.core.mod import Mod
+from sympy.core.numbers import (Float, I, Rational, oo, pi, zoo)
+from sympy.core.relational import (Eq, Ge, Gt, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (Abs, adjoint, arg, conjugate, im, re, transpose)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.piecewise import (Piecewise,
+    piecewise_fold, piecewise_exclusive, Undefined, ExprCondPair)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.logic.boolalg import (And, ITE, Not, Or)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.printing import srepr
+from sympy.sets.contains import Contains
+from sympy.sets.sets import Interval
+from sympy.solvers.solvers import solve
+from sympy.testing.pytest import raises, slow
+from sympy.utilities.lambdify import lambdify
+
+a, b, c, d, x, y = symbols('a:d, x, y')
+z = symbols('z', nonzero=True)
+
+
+def test_piecewise1():
+
+    # Test canonicalization
+    assert unchanged(Piecewise, ExprCondPair(x, x < 1), ExprCondPair(0, True))
+    assert Piecewise((x, x < 1), (0, True)) == Piecewise(ExprCondPair(x, x < 1),
+                                                         ExprCondPair(0, True))
+    assert Piecewise((x, x < 1), (0, True), (1, True)) == \
+        Piecewise((x, x < 1), (0, True))
+    assert Piecewise((x, x < 1), (0, False), (-1, 1 > 2)) == \
+        Piecewise((x, x < 1))
+    assert Piecewise((x, x < 1), (0, x < 1), (0, True)) == \
+        Piecewise((x, x < 1), (0, True))
+    assert Piecewise((x, x < 1), (0, x < 2), (0, True)) == \
+        Piecewise((x, x < 1), (0, True))
+    assert Piecewise((x, x < 1), (x, x < 2), (0, True)) == \
+        Piecewise((x, Or(x < 1, x < 2)), (0, True))
+    assert Piecewise((x, x < 1), (x, x < 2), (x, True)) == x
+    assert Piecewise((x, True)) == x
+    # Explicitly constructed empty Piecewise not accepted
+    raises(TypeError, lambda: Piecewise())
+    # False condition is never retained
+    assert Piecewise((2*x, x < 0), (x, False)) == \
+        Piecewise((2*x, x < 0), (x, False), evaluate=False) == \
+        Piecewise((2*x, x < 0))
+    assert Piecewise((x, False)) == Undefined
+    raises(TypeError, lambda: Piecewise(x))
+    assert Piecewise((x, 1)) == x  # 1 and 0 are accepted as True/False
+    raises(TypeError, lambda: Piecewise((x, 2)))
+    raises(TypeError, lambda: Piecewise((x, x**2)))
+    raises(TypeError, lambda: Piecewise(([1], True)))
+    assert Piecewise(((1, 2), True)) == Tuple(1, 2)
+    cond = (Piecewise((1, x < 0), (2, True)) < y)
+    assert Piecewise((1, cond)
+        ) == Piecewise((1, ITE(x < 0, y > 1, y > 2)))
+
+    assert Piecewise((1, x > 0), (2, And(x <= 0, x > -1))
+        ) == Piecewise((1, x > 0), (2, x > -1))
+    assert Piecewise((1, x <= 0), (2, (x < 0) & (x > -1))
+        ) == Piecewise((1, x <= 0))
+
+    # test for supporting Contains in Piecewise
+    pwise = Piecewise(
+        (1, And(x <= 6, x > 1, Contains(x, S.Integers))),
+        (0, True))
+    assert pwise.subs(x, pi) == 0
+    assert pwise.subs(x, 2) == 1
+    assert pwise.subs(x, 7) == 0
+
+    # Test subs
+    p = Piecewise((-1, x < -1), (x**2, x < 0), (log(x), x >= 0))
+    p_x2 = Piecewise((-1, x**2 < -1), (x**4, x**2 < 0), (log(x**2), x**2 >= 0))
+    assert p.subs(x, x**2) == p_x2
+    assert p.subs(x, -5) == -1
+    assert p.subs(x, -1) == 1
+    assert p.subs(x, 1) == log(1)
+
+    # More subs tests
+    p2 = Piecewise((1, x < pi), (-1, x < 2*pi), (0, x > 2*pi))
+    p3 = Piecewise((1, Eq(x, 0)), (1/x, True))
+    p4 = Piecewise((1, Eq(x, 0)), (2, 1/x>2))
+    assert p2.subs(x, 2) == 1
+    assert p2.subs(x, 4) == -1
+    assert p2.subs(x, 10) == 0
+    assert p3.subs(x, 0.0) == 1
+    assert p4.subs(x, 0.0) == 1
+
+
+    f, g, h = symbols('f,g,h', cls=Function)
+    pf = Piecewise((f(x), x < -1), (f(x) + h(x) + 2, x <= 1))
+    pg = Piecewise((g(x), x < -1), (g(x) + h(x) + 2, x <= 1))
+    assert pg.subs(g, f) == pf
+
+    assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 0) == 1
+    assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 1) == 0
+    assert Piecewise((1, Eq(x, y)), (0, True)).subs(x, y) == 1
+    assert Piecewise((1, Eq(x, z)), (0, True)).subs(x, z) == 1
+    assert Piecewise((1, Eq(exp(x), cos(z))), (0, True)).subs(x, z) == \
+        Piecewise((1, Eq(exp(z), cos(z))), (0, True))
+
+    p5 = Piecewise( (0, Eq(cos(x) + y, 0)), (1, True))
+    assert p5.subs(y, 0) == Piecewise( (0, Eq(cos(x), 0)), (1, True))
+
+    assert Piecewise((-1, y < 1), (0, x < 0), (1, Eq(x, 0)), (2, True)
+        ).subs(x, 1) == Piecewise((-1, y < 1), (2, True))
+    assert Piecewise((1, Eq(x**2, -1)), (2, x < 0)).subs(x, I) == 1
+
+    p6 = Piecewise((x, x > 0))
+    n = symbols('n', negative=True)
+    assert p6.subs(x, n) == Undefined
+
+    # Test evalf
+    assert p.evalf() == Piecewise((-1.0, x < -1), (x**2, x < 0), (log(x), True))
+    assert p.evalf(subs={x: -2}) == -1.0
+    assert p.evalf(subs={x: -1}) == 1.0
+    assert p.evalf(subs={x: 1}) == log(1)
+    assert p6.evalf(subs={x: -5}) == Undefined
+
+    # Test doit
+    f_int = Piecewise((Integral(x, (x, 0, 1)), x < 1))
+    assert f_int.doit() == Piecewise( (S.Half, x < 1) )
+
+    # Test differentiation
+    f = x
+    fp = x*p
+    dp = Piecewise((0, x < -1), (2*x, x < 0), (1/x, x >= 0))
+    fp_dx = x*dp + p
+    assert diff(p, x) == dp
+    assert diff(f*p, x) == fp_dx
+
+    # Test simple arithmetic
+    assert x*p == fp
+    assert x*p + p == p + x*p
+    assert p + f == f + p
+    assert p + dp == dp + p
+    assert p - dp == -(dp - p)
+
+    # Test power
+    dp2 = Piecewise((0, x < -1), (4*x**2, x < 0), (1/x**2, x >= 0))
+    assert dp**2 == dp2
+
+    # Test _eval_interval
+    f1 = x*y + 2
+    f2 = x*y**2 + 3
+    peval = Piecewise((f1, x < 0), (f2, x > 0))
+    peval_interval = f1.subs(
+        x, 0) - f1.subs(x, -1) + f2.subs(x, 1) - f2.subs(x, 0)
+    assert peval._eval_interval(x, 0, 0) == 0
+    assert peval._eval_interval(x, -1, 1) == peval_interval
+    peval2 = Piecewise((f1, x < 0), (f2, True))
+    assert peval2._eval_interval(x, 0, 0) == 0
+    assert peval2._eval_interval(x, 1, -1) == -peval_interval
+    assert peval2._eval_interval(x, -1, -2) == f1.subs(x, -2) - f1.subs(x, -1)
+    assert peval2._eval_interval(x, -1, 1) == peval_interval
+    assert peval2._eval_interval(x, None, 0) == peval2.subs(x, 0)
+    assert peval2._eval_interval(x, -1, None) == -peval2.subs(x, -1)
+
+    # Test integration
+    assert p.integrate() == Piecewise(
+        (-x, x < -1),
+        (x**3/3 + Rational(4, 3), x < 0),
+        (x*log(x) - x + Rational(4, 3), True))
+    p = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x))
+    assert integrate(p, (x, -2, 2)) == Rational(5, 6)
+    assert integrate(p, (x, 2, -2)) == Rational(-5, 6)
+    p = Piecewise((0, x < 0), (1, x < 1), (0, x < 2), (1, x < 3), (0, True))
+    assert integrate(p, (x, -oo, oo)) == 2
+    p = Piecewise((x, x < -10), (x**2, x <= -1), (x, 1 < x))
+    assert integrate(p, (x, -2, 2)) == Undefined
+
+    # Test commutativity
+    assert isinstance(p, Piecewise) and p.is_commutative is True
+
+
+def test_piecewise_free_symbols():
+    f = Piecewise((x, a < 0), (y, True))
+    assert f.free_symbols == {x, y, a}
+
+
+def test_piecewise_integrate1():
+    x, y = symbols('x y', real=True)
+
+    f = Piecewise(((x - 2)**2, x >= 0), (1, True))
+    assert integrate(f, (x, -2, 2)) == Rational(14, 3)
+
+    g = Piecewise(((x - 5)**5, x >= 4), (f, True))
+    assert integrate(g, (x, -2, 2)) == Rational(14, 3)
+    assert integrate(g, (x, -2, 5)) == Rational(43, 6)
+
+    assert g == Piecewise(((x - 5)**5, x >= 4), (f, x < 4))
+
+    g = Piecewise(((x - 5)**5, 2 <= x), (f, x < 2))
+    assert integrate(g, (x, -2, 2)) == Rational(14, 3)
+    assert integrate(g, (x, -2, 5)) == Rational(-701, 6)
+
+    assert g == Piecewise(((x - 5)**5, 2 <= x), (f, True))
+
+    g = Piecewise(((x - 5)**5, 2 <= x), (2*f, True))
+    assert integrate(g, (x, -2, 2)) == Rational(28, 3)
+    assert integrate(g, (x, -2, 5)) == Rational(-673, 6)
+
+
+def test_piecewise_integrate1b():
+    g = Piecewise((1, x > 0), (0, Eq(x, 0)), (-1, x < 0))
+    assert integrate(g, (x, -1, 1)) == 0
+
+    g = Piecewise((1, x - y < 0), (0, True))
+    assert integrate(g, (y, -oo, 0)) == -Min(0, x)
+    assert g.subs(x, -3).integrate((y, -oo, 0)) == 3
+    assert integrate(g, (y, 0, -oo)) == Min(0, x)
+    assert integrate(g, (y, 0, oo)) == -Max(0, x) + oo
+    assert integrate(g, (y, -oo, 42)) == -Min(42, x) + 42
+    assert integrate(g, (y, -oo, oo)) == -x + oo
+
+    g = Piecewise((0, x < 0), (x, x <= 1), (1, True))
+    gy1 = g.integrate((x, y, 1))
+    g1y = g.integrate((x, 1, y))
+    for yy in (-1, S.Half, 2):
+        assert g.integrate((x, yy, 1)) == gy1.subs(y, yy)
+        assert g.integrate((x, 1, yy)) == g1y.subs(y, yy)
+    assert gy1 == Piecewise(
+        (-Min(1, Max(0, y))**2/2 + S.Half, y < 1),
+        (-y + 1, True))
+    assert g1y == Piecewise(
+        (Min(1, Max(0, y))**2/2 - S.Half, y < 1),
+        (y - 1, True))
+
+
+@slow
+def test_piecewise_integrate1ca():
+    y = symbols('y', real=True)
+    g = Piecewise(
+        (1 - x, Interval(0, 1).contains(x)),
+        (1 + x, Interval(-1, 0).contains(x)),
+        (0, True)
+        )
+    gy1 = g.integrate((x, y, 1))
+    g1y = g.integrate((x, 1, y))
+
+    assert g.integrate((x, -2, 1)) == gy1.subs(y, -2)
+    assert g.integrate((x, 1, -2)) == g1y.subs(y, -2)
+    assert g.integrate((x, 0, 1)) == gy1.subs(y, 0)
+    assert g.integrate((x, 1, 0)) == g1y.subs(y, 0)
+    assert g.integrate((x, 2, 1)) == gy1.subs(y, 2)
+    assert g.integrate((x, 1, 2)) == g1y.subs(y, 2)
+    assert piecewise_fold(gy1.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (1, y <= -1),
+            (-y**2/2 - y + S.Half, y <= 0),
+            (y**2/2 - y + S.Half, y < 1),
+            (0, True))
+    assert piecewise_fold(g1y.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (-1, y <= -1),
+            (y**2/2 + y - S.Half, y <= 0),
+            (-y**2/2 + y - S.Half, y < 1),
+            (0, True))
+    assert gy1 == Piecewise(
+        (
+            -Min(1, Max(-1, y))**2/2 - Min(1, Max(-1, y)) +
+            Min(1, Max(0, y))**2 + S.Half, y < 1),
+        (0, True)
+        )
+    assert g1y == Piecewise(
+        (
+            Min(1, Max(-1, y))**2/2 + Min(1, Max(-1, y)) -
+            Min(1, Max(0, y))**2 - S.Half, y < 1),
+        (0, True))
+
+
+@slow
+def test_piecewise_integrate1cb():
+    y = symbols('y', real=True)
+    g = Piecewise(
+        (0, Or(x <= -1, x >= 1)),
+        (1 - x, x > 0),
+        (1 + x, True)
+        )
+    gy1 = g.integrate((x, y, 1))
+    g1y = g.integrate((x, 1, y))
+
+    assert g.integrate((x, -2, 1)) == gy1.subs(y, -2)
+    assert g.integrate((x, 1, -2)) == g1y.subs(y, -2)
+    assert g.integrate((x, 0, 1)) == gy1.subs(y, 0)
+    assert g.integrate((x, 1, 0)) == g1y.subs(y, 0)
+    assert g.integrate((x, 2, 1)) == gy1.subs(y, 2)
+    assert g.integrate((x, 1, 2)) == g1y.subs(y, 2)
+
+    assert piecewise_fold(gy1.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (1, y <= -1),
+            (-y**2/2 - y + S.Half, y <= 0),
+            (y**2/2 - y + S.Half, y < 1),
+            (0, True))
+    assert piecewise_fold(g1y.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (-1, y <= -1),
+            (y**2/2 + y - S.Half, y <= 0),
+            (-y**2/2 + y - S.Half, y < 1),
+            (0, True))
+
+    # g1y and gy1 should simplify if the condition that y < 1
+    # is applied, e.g. Min(1, Max(-1, y)) --> Max(-1, y)
+    assert gy1 == Piecewise(
+        (
+            -Min(1, Max(-1, y))**2/2 - Min(1, Max(-1, y)) +
+            Min(1, Max(0, y))**2 + S.Half, y < 1),
+        (0, True)
+        )
+    assert g1y == Piecewise(
+        (
+            Min(1, Max(-1, y))**2/2 + Min(1, Max(-1, y)) -
+            Min(1, Max(0, y))**2 - S.Half, y < 1),
+        (0, True))
+
+
+def test_piecewise_integrate2():
+    from itertools import permutations
+    lim = Tuple(x, c, d)
+    p = Piecewise((1, x < a), (2, x > b), (3, True))
+    q = p.integrate(lim)
+    assert q == Piecewise(
+        (-c + 2*d - 2*Min(d, Max(a, c)) + Min(d, Max(a, b, c)), c < d),
+        (-2*c + d + 2*Min(c, Max(a, d)) - Min(c, Max(a, b, d)), True))
+    for v in permutations((1, 2, 3, 4)):
+        r = dict(zip((a, b, c, d), v))
+        assert p.subs(r).integrate(lim.subs(r)) == q.subs(r)
+
+
+def test_meijer_bypass():
+    # totally bypass meijerg machinery when dealing
+    # with Piecewise in integrate
+    assert Piecewise((1, x < 4), (0, True)).integrate((x, oo, 1)) == -3
+
+
+def test_piecewise_integrate3_inequality_conditions():
+    from sympy.utilities.iterables import cartes
+    lim = (x, 0, 5)
+    # set below includes two pts below range, 2 pts in range,
+    # 2 pts above range, and the boundaries
+    N = (-2, -1, 0, 1, 2, 5, 6, 7)
+
+    p = Piecewise((1, x > a), (2, x > b), (0, True))
+    ans = p.integrate(lim)
+    for i, j in cartes(N, repeat=2):
+        reps = dict(zip((a, b), (i, j)))
+        assert ans.subs(reps) == p.subs(reps).integrate(lim)
+    assert ans.subs(a, 4).subs(b, 1) == 0 + 2*3 + 1
+
+    p = Piecewise((1, x > a), (2, x < b), (0, True))
+    ans = p.integrate(lim)
+    for i, j in cartes(N, repeat=2):
+        reps = dict(zip((a, b), (i, j)))
+        assert ans.subs(reps) == p.subs(reps).integrate(lim)
+
+    # delete old tests that involved c1 and c2 since those
+    # reduce to the above except that a value of 0 was used
+    # for two expressions whereas the above uses 3 different
+    # values
+
+
+@slow
+def test_piecewise_integrate4_symbolic_conditions():
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    p0 = Piecewise((0, Or(x < a, x > b)), (1, True))
+    p1 = Piecewise((0, x < a), (0, x > b), (1, True))
+    p2 = Piecewise((0, x > b), (0, x < a), (1, True))
+    p3 = Piecewise((0, x < a), (1, x < b), (0, True))
+    p4 = Piecewise((0, x > b), (1, x > a), (0, True))
+    p5 = Piecewise((1, And(a < x, x < b)), (0, True))
+
+    # check values of a=1, b=3 (and reversed) with values
+    # of y of 0, 1, 2, 3, 4
+    lim = Tuple(x, -oo, y)
+    for p in (p0, p1, p2, p3, p4, p5):
+        ans = p.integrate(lim)
+        for i in range(5):
+            reps = {a:1, b:3, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+            reps = {a: 3, b:1, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+    lim = Tuple(x, y, oo)
+    for p in (p0, p1, p2, p3, p4, p5):
+        ans = p.integrate(lim)
+        for i in range(5):
+            reps = {a:1, b:3, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+            reps = {a:3, b:1, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+
+    ans = Piecewise(
+        (0, x <= Min(a, b)),
+        (x - Min(a, b), x <= b),
+        (b - Min(a, b), True))
+    for i in (p0, p1, p2, p4):
+        assert i.integrate(x) == ans
+    assert p3.integrate(x) == Piecewise(
+        (0, x < a),
+        (-a + x, x <= Max(a, b)),
+        (-a + Max(a, b), True))
+    assert p5.integrate(x) == Piecewise(
+        (0, x <= a),
+        (-a + x, x <= Max(a, b)),
+        (-a + Max(a, b), True))
+
+    p1 = Piecewise((0, x < a), (S.Half, x > b), (1, True))
+    p2 = Piecewise((S.Half, x > b), (0, x < a), (1, True))
+    p3 = Piecewise((0, x < a), (1, x < b), (S.Half, True))
+    p4 = Piecewise((S.Half, x > b), (1, x > a), (0, True))
+    p5 = Piecewise((1, And(a < x, x < b)), (S.Half, x > b), (0, True))
+
+    # check values of a=1, b=3 (and reversed) with values
+    # of y of 0, 1, 2, 3, 4
+    lim = Tuple(x, -oo, y)
+    for p in (p1, p2, p3, p4, p5):
+        ans = p.integrate(lim)
+        for i in range(5):
+            reps = {a:1, b:3, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+            reps = {a: 3, b:1, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+
+
+def test_piecewise_integrate5_independent_conditions():
+    p = Piecewise((0, Eq(y, 0)), (x*y, True))
+    assert integrate(p, (x, 1, 3)) == Piecewise((0, Eq(y, 0)), (4*y, True))
+
+
+def test_issue_22917():
+    p = (Piecewise((0, ITE((x - y > 1) | (2 * x - 2 * y > 1), False,
+                           ITE(x - y > 1, 2 * y - 2 < -1, 2 * x - 2 * y > 1))),
+                   (Piecewise((0, ITE(x - y > 1, True, 2 * x - 2 * y > 1)),
+                              (2 * Piecewise((0, x - y > 1), (y, True)), True)), True))
+         + 2 * Piecewise((1, ITE((x - y > 1) | (2 * x - 2 * y > 1), False,
+                                 ITE(x - y > 1, 2 * y - 2 < -1, 2 * x - 2 * y > 1))),
+                         (Piecewise((1, ITE(x - y > 1, True, 2 * x - 2 * y > 1)),
+                                    (2 * Piecewise((1, x - y > 1), (x, True)), True)), True)))
+    assert piecewise_fold(p) == Piecewise((2, (x - y > S.Half) | (x - y > 1)),
+                                          (2*y + 4, x - y > 1),
+                                          (4*x + 2*y, True))
+    assert piecewise_fold(p > 1).rewrite(ITE) == ITE((x - y > S.Half) | (x - y > 1), True,
+                                                     ITE(x - y > 1, 2*y + 4 > 1, 4*x + 2*y > 1))
+
+
+def test_piecewise_simplify():
+    p = Piecewise(((x**2 + 1)/x**2, Eq(x*(1 + x) - x**2, 0)),
+                  ((-1)**x*(-1), True))
+    assert p.simplify() == \
+        Piecewise((zoo, Eq(x, 0)), ((-1)**(x + 1), True))
+    # simplify when there are Eq in conditions
+    assert Piecewise(
+        (a, And(Eq(a, 0), Eq(a + b, 0))), (1, True)).simplify(
+        ) == Piecewise(
+        (0, And(Eq(a, 0), Eq(b, 0))), (1, True))
+    assert Piecewise((2*x*factorial(a)/(factorial(y)*factorial(-y + a)),
+        Eq(y, 0) & Eq(-y + a, 0)), (2*factorial(a)/(factorial(y)*factorial(-y
+        + a)), Eq(y, 0) & Eq(-y + a, 1)), (0, True)).simplify(
+        ) == Piecewise(
+            (2*x, And(Eq(a, 0), Eq(y, 0))),
+            (2, And(Eq(a, 1), Eq(y, 0))),
+            (0, True))
+    args = (2, And(Eq(x, 2), Ge(y, 0))), (x, True)
+    assert Piecewise(*args).simplify() == Piecewise(*args)
+    args = (1, Eq(x, 0)), (sin(x)/x, True)
+    assert Piecewise(*args).simplify() == Piecewise(*args)
+    assert Piecewise((2 + y, And(Eq(x, 2), Eq(y, 0))), (x, True)
+        ).simplify() == x
+    # check that x or f(x) are recognized as being Symbol-like for lhs
+    args = Tuple((1, Eq(x, 0)), (sin(x) + 1 + x, True))
+    ans = x + sin(x) + 1
+    f = Function('f')
+    assert Piecewise(*args).simplify() == ans
+    assert Piecewise(*args.subs(x, f(x))).simplify() == ans.subs(x, f(x))
+
+    # issue 18634
+    d = Symbol("d", integer=True)
+    n = Symbol("n", integer=True)
+    t = Symbol("t", positive=True)
+    expr = Piecewise((-d + 2*n, Eq(1/t, 1)), (t**(1 - 4*n)*t**(4*n - 1)*(-d + 2*n), True))
+    assert expr.simplify() == -d + 2*n
+
+    # issue 22747
+    p = Piecewise((0, (t < -2) & (t < -1) & (t < 0)), ((t/2 + 1)*(t +
+        1)*(t + 2), (t < -1) & (t < 0)), ((S.Half - t/2)*(1 - t)*(t + 1),
+        (t < -2) & (t < -1) & (t < 1)), ((t + 1)*(-t*(t/2 + 1) + (S.Half
+        - t/2)*(1 - t)), (t < -2) & (t < -1) & (t < 0) & (t < 1)), ((t +
+        1)*((S.Half - t/2)*(1 - t) + (t/2 + 1)*(t + 2)), (t < -1) & (t <
+        1)), ((t + 1)*(-t*(t/2 + 1) + (S.Half - t/2)*(1 - t)), (t < -1) &
+        (t < 0) & (t < 1)), (0, (t < -2) & (t < -1)), ((t/2 + 1)*(t +
+        1)*(t + 2), t < -1), ((t + 1)*(-t*(t/2 + 1) + (S.Half - t/2)*(t +
+        1)), (t < 0) & ((t < -2) | (t < 0))), ((S.Half - t/2)*(1 - t)*(t
+        + 1), (t < 1) & ((t < -2) | (t < 1))), (0, True)) + Piecewise((0,
+        (t < -1) & (t < 0) & (t < 1)), ((1 - t)*(t/2 + S.Half)*(t + 1),
+        (t < 0) & (t < 1)), ((1 - t)*(1 - t/2)*(2 - t), (t < -1) & (t <
+        0) & (t < 2)), ((1 - t)*((1 - t)*(t/2 + S.Half) + (1 - t/2)*(2 -
+        t)), (t < -1) & (t < 0) & (t < 1) & (t < 2)), ((1 - t)*((1 -
+        t/2)*(2 - t) + (t/2 + S.Half)*(t + 1)), (t < 0) & (t < 2)), ((1 -
+        t)*((1 - t)*(t/2 + S.Half) + (1 - t/2)*(2 - t)), (t < 0) & (t <
+        1) & (t < 2)), (0, (t < -1) & (t < 0)), ((1 - t)*(t/2 +
+        S.Half)*(t + 1), t < 0), ((1 - t)*(t*(1 - t/2) + (1 - t)*(t/2 +
+        S.Half)), (t < 1) & ((t < -1) | (t < 1))), ((1 - t)*(1 - t/2)*(2
+        - t), (t < 2) & ((t < -1) | (t < 2))), (0, True))
+    assert p.simplify() == Piecewise(
+        (0, t < -2), ((t + 1)*(t + 2)**2/2, t < -1), (-3*t**3/2
+        - 5*t**2/2 + 1, t < 0), (3*t**3/2 - 5*t**2/2 + 1, t < 1), ((1 -
+        t)*(t - 2)**2/2, t < 2), (0, True))
+
+    # coverage
+    nan = Undefined
+    covered = Piecewise((1, x > 3), (2, x < 2), (3, x > 1))
+    assert covered.simplify().args  == covered.args
+    assert Piecewise((1, x < 2), (2, x < 1), (3, True)).simplify(
+        ) == Piecewise((1, x < 2), (3, True))
+    assert Piecewise((1, x > 2)).simplify() == Piecewise((1, x > 2),
+        (nan, True))
+    assert Piecewise((1, (x >= 2) & (x < oo))
+        ).simplify() == Piecewise((1, (x >= 2) & (x < oo)), (nan, True))
+    assert Piecewise((1, x < 2), (2, (x > 1) & (x < 3)), (3, True)
+        ). simplify() == Piecewise((1, x < 2), (2, x < 3), (3, True))
+    assert Piecewise((1, x < 2), (2, (x <= 3) & (x > 1)), (3, True)
+        ).simplify() == Piecewise((1, x < 2), (2, x <= 3), (3, True))
+    assert Piecewise((1, x < 2), (2, (x > 2) & (x < 3)), (3, True)
+        ).simplify() == Piecewise((1, x < 2), (2, (x > 2) & (x < 3)),
+        (3, True))
+    assert Piecewise((1, x < 2), (2, (x >= 1) & (x <= 3)), (3, True)
+        ).simplify() == Piecewise((1, x < 2), (2, x <= 3), (3, True))
+    assert Piecewise((1, x < 1), (2, (x >= 2) & (x <= 3)), (3, True)
+        ).simplify() == Piecewise((1, x < 1), (2, (x >= 2) & (x <= 3)),
+        (3, True))
+
+
+def test_piecewise_solve():
+    abs2 = Piecewise((-x, x <= 0), (x, x > 0))
+    f = abs2.subs(x, x - 2)
+    assert solve(f, x) == [2]
+    assert solve(f - 1, x) == [1, 3]
+
+    f = Piecewise(((x - 2)**2, x >= 0), (1, True))
+    assert solve(f, x) == [2]
+
+    g = Piecewise(((x - 5)**5, x >= 4), (f, True))
+    assert solve(g, x) == [2, 5]
+
+    g = Piecewise(((x - 5)**5, x >= 4), (f, x < 4))
+    assert solve(g, x) == [2, 5]
+
+    g = Piecewise(((x - 5)**5, x >= 2), (f, x < 2))
+    assert solve(g, x) == [5]
+
+    g = Piecewise(((x - 5)**5, x >= 2), (f, True))
+    assert solve(g, x) == [5]
+
+    g = Piecewise(((x - 5)**5, x >= 2), (f, True), (10, False))
+    assert solve(g, x) == [5]
+
+    g = Piecewise(((x - 5)**5, x >= 2),
+                  (-x + 2, x - 2 <= 0), (x - 2, x - 2 > 0))
+    assert solve(g, x) == [5]
+
+    # if no symbol is given the piecewise detection must still work
+    assert solve(Piecewise((x - 2, x > 2), (2 - x, True)) - 3) == [-1, 5]
+
+    f = Piecewise(((x - 2)**2, x >= 0), (0, True))
+    raises(NotImplementedError, lambda: solve(f, x))
+
+    def nona(ans):
+        return list(filter(lambda x: x is not S.NaN, ans))
+    p = Piecewise((x**2 - 4, x < y), (x - 2, True))
+    ans = solve(p, x)
+    assert nona([i.subs(y, -2) for i in ans]) == [2]
+    assert nona([i.subs(y, 2) for i in ans]) == [-2, 2]
+    assert nona([i.subs(y, 3) for i in ans]) == [-2, 2]
+    assert ans == [
+        Piecewise((-2, y > -2), (S.NaN, True)),
+        Piecewise((2, y <= 2), (S.NaN, True)),
+        Piecewise((2, y > 2), (S.NaN, True))]
+
+    # issue 6060
+    absxm3 = Piecewise(
+        (x - 3, 0 <= x - 3),
+        (3 - x, 0 > x - 3)
+    )
+    assert solve(absxm3 - y, x) == [
+        Piecewise((-y + 3, -y < 0), (S.NaN, True)),
+        Piecewise((y + 3, y >= 0), (S.NaN, True))]
+    p = Symbol('p', positive=True)
+    assert solve(absxm3 - p, x) == [-p + 3, p + 3]
+
+    # issue 6989
+    f = Function('f')
+    assert solve(Eq(-f(x), Piecewise((1, x > 0), (0, True))), f(x)) == \
+        [Piecewise((-1, x > 0), (0, True))]
+
+    # issue 8587
+    f = Piecewise((2*x**2, And(0 < x, x < 1)), (2, True))
+    assert solve(f - 1) == [1/sqrt(2)]
+
+
+def test_piecewise_fold():
+    p = Piecewise((x, x < 1), (1, 1 <= x))
+
+    assert piecewise_fold(x*p) == Piecewise((x**2, x < 1), (x, 1 <= x))
+    assert piecewise_fold(p + p) == Piecewise((2*x, x < 1), (2, 1 <= x))
+    assert piecewise_fold(Piecewise((1, x < 0), (2, True))
+                          + Piecewise((10, x < 0), (-10, True))) == \
+        Piecewise((11, x < 0), (-8, True))
+
+    p1 = Piecewise((0, x < 0), (x, x <= 1), (0, True))
+    p2 = Piecewise((0, x < 0), (1 - x, x <= 1), (0, True))
+
+    p = 4*p1 + 2*p2
+    assert integrate(
+        piecewise_fold(p), (x, -oo, oo)) == integrate(2*x + 2, (x, 0, 1))
+
+    assert piecewise_fold(
+        Piecewise((1, y <= 0), (-Piecewise((2, y >= 0)), True)
+        )) == Piecewise((1, y <= 0), (-2, y >= 0))
+
+    assert piecewise_fold(Piecewise((x, ITE(x > 0, y < 1, y > 1)))
+        ) == Piecewise((x, ((x <= 0) | (y < 1)) & ((x > 0) | (y > 1))))
+
+    a, b = (Piecewise((2, Eq(x, 0)), (0, True)),
+        Piecewise((x, Eq(-x + y, 0)), (1, Eq(-x + y, 1)), (0, True)))
+    assert piecewise_fold(Mul(a, b, evaluate=False)
+        ) == piecewise_fold(Mul(b, a, evaluate=False))
+
+
+def test_piecewise_fold_piecewise_in_cond():
+    p1 = Piecewise((cos(x), x < 0), (0, True))
+    p2 = Piecewise((0, Eq(p1, 0)), (p1 / Abs(p1), True))
+    assert p2.subs(x, -pi/2) == 0
+    assert p2.subs(x, 1) == 0
+    assert p2.subs(x, -pi/4) == 1
+    p4 = Piecewise((0, Eq(p1, 0)), (1,True))
+    ans = piecewise_fold(p4)
+    for i in range(-1, 1):
+        assert ans.subs(x, i) == p4.subs(x, i)
+
+    r1 = 1 < Piecewise((1, x < 1), (3, True))
+    ans = piecewise_fold(r1)
+    for i in range(2):
+        assert ans.subs(x, i) == r1.subs(x, i)
+
+    p5 = Piecewise((1, x < 0), (3, True))
+    p6 = Piecewise((1, x < 1), (3, True))
+    p7 = Piecewise((1, p5 < p6), (0, True))
+    ans = piecewise_fold(p7)
+    for i in range(-1, 2):
+        assert ans.subs(x, i) == p7.subs(x, i)
+
+
+def test_piecewise_fold_piecewise_in_cond_2():
+    p1 = Piecewise((cos(x), x < 0), (0, True))
+    p2 = Piecewise((0, Eq(p1, 0)), (1 / p1, True))
+    p3 = Piecewise(
+        (0, (x >= 0) | Eq(cos(x), 0)),
+        (1/cos(x), x < 0),
+        (zoo, True))  # redundant b/c all x are already covered
+    assert(piecewise_fold(p2) == p3)
+
+
+def test_piecewise_fold_expand():
+    p1 = Piecewise((1, Interval(0, 1, False, True).contains(x)), (0, True))
+
+    p2 = piecewise_fold(expand((1 - x)*p1))
+    cond = ((x >= 0) & (x < 1))
+    assert piecewise_fold(expand((1 - x)*p1), evaluate=False
+        ) == Piecewise((1 - x, cond), (-x, cond), (1, cond), (0, True), evaluate=False)
+    assert piecewise_fold(expand((1 - x)*p1), evaluate=None
+        ) == Piecewise((1 - x, cond), (0, True))
+    assert p2 == Piecewise((1 - x, cond), (0, True))
+    assert p2 == expand(piecewise_fold((1 - x)*p1))
+
+
+def test_piecewise_duplicate():
+    p = Piecewise((x, x < -10), (x**2, x <= -1), (x, 1 < x))
+    assert p == Piecewise(*p.args)
+
+
+def test_doit():
+    p1 = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x))
+    p2 = Piecewise((x, x < 1), (Integral(2 * x), -1 <= x), (x, 3 < x))
+    assert p2.doit() == p1
+    assert p2.doit(deep=False) == p2
+    # issue 17165
+    p1 = Sum(y**x, (x, -1, oo)).doit()
+    assert p1.doit() == p1
+
+
+def test_piecewise_interval():
+    p1 = Piecewise((x, Interval(0, 1).contains(x)), (0, True))
+    assert p1.subs(x, -0.5) == 0
+    assert p1.subs(x, 0.5) == 0.5
+    assert p1.diff(x) == Piecewise((1, Interval(0, 1).contains(x)), (0, True))
+    assert integrate(p1, x) == Piecewise(
+        (0, x <= 0),
+        (x**2/2, x <= 1),
+        (S.Half, True))
+
+
+def test_piecewise_exclusive():
+    p = Piecewise((0, x < 0), (S.Half, x <= 0), (1, True))
+    assert piecewise_exclusive(p) == Piecewise((0, x < 0), (S.Half, Eq(x, 0)),
+                                               (1, x > 0), evaluate=False)
+    assert piecewise_exclusive(p + 2) == Piecewise((0, x < 0), (S.Half, Eq(x, 0)),
+                                               (1, x > 0), evaluate=False) + 2
+    assert piecewise_exclusive(Piecewise((1, y <= 0),
+                                         (-Piecewise((2, y >= 0)), True))) == \
+        Piecewise((1, y <= 0),
+                  (-Piecewise((2, y >= 0),
+                              (S.NaN, y < 0), evaluate=False), y > 0), evaluate=False)
+    assert piecewise_exclusive(Piecewise((1, x > y))) == Piecewise((1, x > y),
+                                                                  (S.NaN, x <= y),
+                                                                  evaluate=False)
+    assert piecewise_exclusive(Piecewise((1, x > y)),
+                               skip_nan=True) == Piecewise((1, x > y))
+
+    xr, yr = symbols('xr, yr', real=True)
+
+    p1 = Piecewise((1, xr < 0), (2, True), evaluate=False)
+    p1x = Piecewise((1, xr < 0), (2, xr >= 0), evaluate=False)
+
+    p2 = Piecewise((p1, yr < 0), (3, True), evaluate=False)
+    p2x = Piecewise((p1, yr < 0), (3, yr >= 0), evaluate=False)
+    p2xx = Piecewise((p1x, yr < 0), (3, yr >= 0), evaluate=False)
+
+    assert piecewise_exclusive(p2) == p2xx
+    assert piecewise_exclusive(p2, deep=False) == p2x
+
+
+def test_piecewise_collapse():
+    assert Piecewise((x, True)) == x
+    a = x < 1
+    assert Piecewise((x, a), (x + 1, a)) == Piecewise((x, a))
+    assert Piecewise((x, a), (x + 1, a.reversed)) == Piecewise((x, a))
+    b = x < 5
+    def canonical(i):
+        if isinstance(i, Piecewise):
+            return Piecewise(*i.args)
+        return i
+    for args in [
+        ((1, a), (Piecewise((2, a), (3, b)), b)),
+        ((1, a), (Piecewise((2, a), (3, b.reversed)), b)),
+        ((1, a), (Piecewise((2, a), (3, b)), b), (4, True)),
+        ((1, a), (Piecewise((2, a), (3, b), (4, True)), b)),
+        ((1, a), (Piecewise((2, a), (3, b), (4, True)), b), (5, True))]:
+        for i in (0, 2, 10):
+            assert canonical(
+                Piecewise(*args, evaluate=False).subs(x, i)
+                ) == canonical(Piecewise(*args).subs(x, i))
+    r1, r2, r3, r4 = symbols('r1:5')
+    a = x < r1
+    b = x < r2
+    c = x < r3
+    d = x < r4
+    assert Piecewise((1, a), (Piecewise(
+        (2, a), (3, b), (4, c)), b), (5, c)
+        ) == Piecewise((1, a), (3, b), (5, c))
+    assert Piecewise((1, a), (Piecewise(
+        (2, a), (3, b), (4, c), (6, True)), c), (5, d)
+        ) == Piecewise((1, a), (Piecewise(
+        (3, b), (4, c)), c), (5, d))
+    assert Piecewise((1, Or(a, d)), (Piecewise(
+        (2, d), (3, b), (4, c)), b), (5, c)
+        ) == Piecewise((1, Or(a, d)), (Piecewise(
+        (2, d), (3, b)), b), (5, c))
+    assert Piecewise((1, c), (2, ~c), (3, S.true)
+        ) == Piecewise((1, c), (2, S.true))
+    assert Piecewise((1, c), (2, And(~c, b)), (3,True)
+        ) == Piecewise((1, c), (2, b), (3, True))
+    assert Piecewise((1, c), (2, Or(~c, b)), (3,True)
+        ).subs(dict(zip((r1, r2, r3, r4, x), (1, 2, 3, 4, 3.5))))  == 2
+    assert Piecewise((1, c), (2, ~c)) == Piecewise((1, c), (2, True))
+
+
+def test_piecewise_lambdify():
+    p = Piecewise(
+        (x**2, x < 0),
+        (x, Interval(0, 1, False, True).contains(x)),
+        (2 - x, x >= 1),
+        (0, True)
+    )
+
+    f = lambdify(x, p)
+    assert f(-2.0) == 4.0
+    assert f(0.0) == 0.0
+    assert f(0.5) == 0.5
+    assert f(2.0) == 0.0
+
+
+def test_piecewise_series():
+    from sympy.series.order import O
+    p1 = Piecewise((sin(x), x < 0), (cos(x), x > 0))
+    p2 = Piecewise((x + O(x**2), x < 0), (1 + O(x**2), x > 0))
+    assert p1.nseries(x, n=2) == p2
+
+
+def test_piecewise_as_leading_term():
+    p1 = Piecewise((1/x, x > 1), (0, True))
+    p2 = Piecewise((x, x > 1), (0, True))
+    p3 = Piecewise((1/x, x > 1), (x, True))
+    p4 = Piecewise((x, x > 1), (1/x, True))
+    p5 = Piecewise((1/x, x > 1), (x, True))
+    p6 = Piecewise((1/x, x < 1), (x, True))
+    p7 = Piecewise((x, x < 1), (1/x, True))
+    p8 = Piecewise((x, x > 1), (1/x, True))
+    assert p1.as_leading_term(x) == 0
+    assert p2.as_leading_term(x) == 0
+    assert p3.as_leading_term(x) == x
+    assert p4.as_leading_term(x) == 1/x
+    assert p5.as_leading_term(x) == x
+    assert p6.as_leading_term(x) == 1/x
+    assert p7.as_leading_term(x) == x
+    assert p8.as_leading_term(x) == 1/x
+
+
+def test_piecewise_complex():
+    p1 = Piecewise((2, x < 0), (1, 0 <= x))
+    p2 = Piecewise((2*I, x < 0), (I, 0 <= x))
+    p3 = Piecewise((I*x, x > 1), (1 + I, True))
+    p4 = Piecewise((-I*conjugate(x), x > 1), (1 - I, True))
+
+    assert conjugate(p1) == p1
+    assert conjugate(p2) == piecewise_fold(-p2)
+    assert conjugate(p3) == p4
+
+    assert p1.is_imaginary is False
+    assert p1.is_real is True
+    assert p2.is_imaginary is True
+    assert p2.is_real is False
+    assert p3.is_imaginary is None
+    assert p3.is_real is None
+
+    assert p1.as_real_imag() == (p1, 0)
+    assert p2.as_real_imag() == (0, -I*p2)
+
+
+def test_conjugate_transpose():
+    A, B = symbols("A B", commutative=False)
+    p = Piecewise((A*B**2, x > 0), (A**2*B, True))
+    assert p.adjoint() == \
+        Piecewise((adjoint(A*B**2), x > 0), (adjoint(A**2*B), True))
+    assert p.conjugate() == \
+        Piecewise((conjugate(A*B**2), x > 0), (conjugate(A**2*B), True))
+    assert p.transpose() == \
+        Piecewise((transpose(A*B**2), x > 0), (transpose(A**2*B), True))
+
+
+def test_piecewise_evaluate():
+    assert Piecewise((x, True)) == x
+    assert Piecewise((x, True), evaluate=True) == x
+    assert Piecewise((1, Eq(1, x))).args == ((1, Eq(x, 1)),)
+    assert Piecewise((1, Eq(1, x)), evaluate=False).args == (
+        (1, Eq(1, x)),)
+    # like the additive and multiplicative identities that
+    # cannot be kept in Add/Mul, we also do not keep a single True
+    p = Piecewise((x, True), evaluate=False)
+    assert p == x
+
+
+def test_as_expr_set_pairs():
+    assert Piecewise((x, x > 0), (-x, x <= 0)).as_expr_set_pairs() == \
+        [(x, Interval(0, oo, True, True)), (-x, Interval(-oo, 0))]
+
+    assert Piecewise(((x - 2)**2, x >= 0), (0, True)).as_expr_set_pairs() == \
+        [((x - 2)**2, Interval(0, oo)), (0, Interval(-oo, 0, True, True))]
+
+
+def test_S_srepr_is_identity():
+    p = Piecewise((10, Eq(x, 0)), (12, True))
+    q = S(srepr(p))
+    assert p == q
+
+
+def test_issue_12587():
+    # sort holes into intervals
+    p = Piecewise((1, x > 4), (2, Not((x <= 3) & (x > -1))), (3, True))
+    assert p.integrate((x, -5, 5)) == 23
+    p = Piecewise((1, x > 1), (2, x < y), (3, True))
+    lim = x, -3, 3
+    ans = p.integrate(lim)
+    for i in range(-1, 3):
+        assert ans.subs(y, i) == p.subs(y, i).integrate(lim)
+
+
+def test_issue_11045():
+    assert integrate(1/(x*sqrt(x**2 - 1)), (x, 1, 2)) == pi/3
+
+    # handle And with Or arguments
+    assert Piecewise((1, And(Or(x < 1, x > 3), x < 2)), (0, True)
+        ).integrate((x, 0, 3)) == 1
+
+    # hidden false
+    assert Piecewise((1, x > 1), (2, x > x + 1), (3, True)
+        ).integrate((x, 0, 3)) == 5
+    # targetcond is Eq
+    assert Piecewise((1, x > 1), (2, Eq(1, x)), (3, True)
+        ).integrate((x, 0, 4)) == 6
+    # And has Relational needing to be solved
+    assert Piecewise((1, And(2*x > x + 1, x < 2)), (0, True)
+        ).integrate((x, 0, 3)) == 1
+    # Or has Relational needing to be solved
+    assert Piecewise((1, Or(2*x > x + 2, x < 1)), (0, True)
+        ).integrate((x, 0, 3)) == 2
+    # ignore hidden false (handled in canonicalization)
+    assert Piecewise((1, x > 1), (2, x > x + 1), (3, True)
+        ).integrate((x, 0, 3)) == 5
+    # watch for hidden True Piecewise
+    assert Piecewise((2, Eq(1 - x, x*(1/x - 1))), (0, True)
+        ).integrate((x, 0, 3)) == 6
+
+    # overlapping conditions of targetcond are recognized and ignored;
+    # the condition x > 3 will be pre-empted by the first condition
+    assert Piecewise((1, Or(x < 1, x > 2)), (2, x > 3), (3, True)
+        ).integrate((x, 0, 4)) == 6
+
+    # convert Ne to Or
+    assert Piecewise((1, Ne(x, 0)), (2, True)
+        ).integrate((x, -1, 1)) == 2
+
+    # no default but well defined
+    assert Piecewise((x, (x > 1) & (x < 3)), (1, (x < 4))
+        ).integrate((x, 1, 4)) == 5
+
+    p = Piecewise((x, (x > 1) & (x < 3)), (1, (x < 4)))
+    nan = Undefined
+    i = p.integrate((x, 1, y))
+    assert i == Piecewise(
+        (y - 1, y < 1),
+        (Min(3, y)**2/2 - Min(3, y) + Min(4, y) - S.Half,
+            y <= Min(4, y)),
+        (nan, True))
+    assert p.integrate((x, 1, -1)) == i.subs(y, -1)
+    assert p.integrate((x, 1, 4)) == 5
+    assert p.integrate((x, 1, 5)) is nan
+
+    # handle Not
+    p = Piecewise((1, x > 1), (2, Not(And(x > 1, x< 3))), (3, True))
+    assert p.integrate((x, 0, 3)) == 4
+
+    # handle updating of int_expr when there is overlap
+    p = Piecewise(
+        (1, And(5 > x, x > 1)),
+        (2, Or(x < 3, x > 7)),
+        (4, x < 8))
+    assert p.integrate((x, 0, 10)) == 20
+
+    # And with Eq arg handling
+    assert Piecewise((1, x < 1), (2, And(Eq(x, 3), x > 1))
+        ).integrate((x, 0, 3)) is S.NaN
+    assert Piecewise((1, x < 1), (2, And(Eq(x, 3), x > 1)), (3, True)
+        ).integrate((x, 0, 3)) == 7
+    assert Piecewise((1, x < 0), (2, And(Eq(x, 3), x < 1)), (3, True)
+        ).integrate((x, -1, 1)) == 4
+    # middle condition doesn't matter: it's a zero width interval
+    assert Piecewise((1, x < 1), (2, Eq(x, 3) & (y < x)), (3, True)
+        ).integrate((x, 0, 3)) == 7
+
+
+def test_holes():
+    nan = Undefined
+    assert Piecewise((1, x < 2)).integrate(x) == Piecewise(
+        (x, x < 2), (nan, True))
+    assert Piecewise((1, And(x > 1, x < 2))).integrate(x) == Piecewise(
+        (nan, x < 1), (x, x < 2), (nan, True))
+    assert Piecewise((1, And(x > 1, x < 2))).integrate((x, 0, 3)) is nan
+    assert Piecewise((1, And(x > 0, x < 4))).integrate((x, 1, 3)) == 2
+
+    # this also tests that the integrate method is used on non-Piecwise
+    # arguments in _eval_integral
+    A, B = symbols("A B")
+    a, b = symbols('a b', real=True)
+    assert Piecewise((A, And(x < 0, a < 1)), (B, Or(x < 1, a > 2))
+        ).integrate(x) == Piecewise(
+        (B*x, (a > 2)),
+        (Piecewise((A*x, x < 0), (B*x, x < 1), (nan, True)), a < 1),
+        (Piecewise((B*x, x < 1), (nan, True)), True))
+
+
+def test_issue_11922():
+    def f(x):
+        return Piecewise((0, x < -1), (1 - x**2, x < 1), (0, True))
+    autocorr = lambda k: (
+        f(x) * f(x + k)).integrate((x, -1, 1))
+    assert autocorr(1.9) > 0
+    k = symbols('k')
+    good_autocorr = lambda k: (
+        (1 - x**2) * f(x + k)).integrate((x, -1, 1))
+    a = good_autocorr(k)
+    assert a.subs(k, 3) == 0
+    k = symbols('k', positive=True)
+    a = good_autocorr(k)
+    assert a.subs(k, 3) == 0
+    assert Piecewise((0, x < 1), (10, (x >= 1))
+        ).integrate() == Piecewise((0, x < 1), (10*x - 10, True))
+
+
+def test_issue_5227():
+    f = 0.0032513612725229*Piecewise((0, x < -80.8461538461539),
+        (-0.0160799238820171*x + 1.33215984776403, x < 2),
+        (Piecewise((0.3, x > 123), (0.7, True)) +
+        Piecewise((0.4, x > 2), (0.6, True)), x <=
+        123), (-0.00817409766454352*x + 2.10541401273885, x <
+        380.571428571429), (0, True))
+    i = integrate(f, (x, -oo, oo))
+    assert i == Integral(f, (x, -oo, oo)).doit()
+    assert str(i) == '1.00195081676351'
+    assert Piecewise((1, x - y < 0), (0, True)
+        ).integrate(y) == Piecewise((0, y <= x), (-x + y, True))
+
+
+def test_issue_10137():
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    p0 = Piecewise((0, Or(x < a, x > b)), (1, True))
+    p1 = Piecewise((0, Or(a > x, b < x)), (1, True))
+    assert integrate(p0, (x, y, oo)) == integrate(p1, (x, y, oo))
+    p3 = Piecewise((1, And(0 < x, x < a)), (0, True))
+    p4 = Piecewise((1, And(a > x, x > 0)), (0, True))
+    ip3 = integrate(p3, x)
+    assert ip3 == Piecewise(
+        (0, x <= 0),
+        (x, x <= Max(0, a)),
+        (Max(0, a), True))
+    ip4 = integrate(p4, x)
+    assert ip4 == ip3
+    assert p3.integrate((x, 2, 4)) == Min(4, Max(2, a)) - 2
+    assert p4.integrate((x, 2, 4)) == Min(4, Max(2, a)) - 2
+
+
+def test_stackoverflow_43852159():
+    f = lambda x: Piecewise((1, (x >= -1) & (x <= 1)), (0, True))
+    Conv = lambda x: integrate(f(x - y)*f(y), (y, -oo, +oo))
+    cx = Conv(x)
+    assert cx.subs(x, -1.5) == cx.subs(x, 1.5)
+    assert cx.subs(x, 3) == 0
+    assert piecewise_fold(f(x - y)*f(y)) == Piecewise(
+        (1, (y >= -1) & (y <= 1) & (x - y >= -1) & (x - y <= 1)),
+        (0, True))
+
+
+def test_issue_12557():
+    '''
+    # 3200 seconds to compute the fourier part of issue
+    import sympy as sym
+    x,y,z,t = sym.symbols('x y z t')
+    k = sym.symbols("k", integer=True)
+    fourier = sym.fourier_series(sym.cos(k*x)*sym.sqrt(x**2),
+                                 (x, -sym.pi, sym.pi))
+    assert fourier == FourierSeries(
+    sqrt(x**2)*cos(k*x), (x, -pi, pi), (Piecewise((pi**2,
+    Eq(k, 0)), (2*(-1)**k/k**2 - 2/k**2, True))/(2*pi),
+    SeqFormula(Piecewise((pi**2, (Eq(_n, 0) & Eq(k, 0)) | (Eq(_n, 0) &
+    Eq(_n, k) & Eq(k, 0)) | (Eq(_n, 0) & Eq(k, 0) & Eq(_n, -k)) | (Eq(_n,
+    0) & Eq(_n, k) & Eq(k, 0) & Eq(_n, -k))), (pi**2/2, Eq(_n, k) | Eq(_n,
+    -k) | (Eq(_n, 0) & Eq(_n, k)) | (Eq(_n, k) & Eq(k, 0)) | (Eq(_n, 0) &
+    Eq(_n, -k)) | (Eq(_n, k) & Eq(_n, -k)) | (Eq(k, 0) & Eq(_n, -k)) |
+    (Eq(_n, 0) & Eq(_n, k) & Eq(_n, -k)) | (Eq(_n, k) & Eq(k, 0) & Eq(_n,
+    -k))), ((-1)**k*pi**2*_n**3*sin(pi*_n)/(pi*_n**4 - 2*pi*_n**2*k**2 +
+    pi*k**4) - (-1)**k*pi**2*_n**3*sin(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2
+    - pi*k**4) + (-1)**k*pi*_n**2*cos(pi*_n)/(pi*_n**4 - 2*pi*_n**2*k**2 +
+    pi*k**4) - (-1)**k*pi*_n**2*cos(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2 -
+    pi*k**4) - (-1)**k*pi**2*_n*k**2*sin(pi*_n)/(pi*_n**4 -
+    2*pi*_n**2*k**2 + pi*k**4) +
+    (-1)**k*pi**2*_n*k**2*sin(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2 -
+    pi*k**4) + (-1)**k*pi*k**2*cos(pi*_n)/(pi*_n**4 - 2*pi*_n**2*k**2 +
+    pi*k**4) - (-1)**k*pi*k**2*cos(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2 -
+    pi*k**4) - (2*_n**2 + 2*k**2)/(_n**4 - 2*_n**2*k**2 + k**4),
+    True))*cos(_n*x)/pi, (_n, 1, oo)), SeqFormula(0, (_k, 1, oo))))
+    '''
+    x = symbols("x", real=True)
+    k = symbols('k', integer=True, finite=True)
+    abs2 = lambda x: Piecewise((-x, x <= 0), (x, x > 0))
+    assert integrate(abs2(x), (x, -pi, pi)) == pi**2
+    func = cos(k*x)*sqrt(x**2)
+    assert integrate(func, (x, -pi, pi)) == Piecewise(
+        (2*(-1)**k/k**2 - 2/k**2, Ne(k, 0)), (pi**2, True))
+
+def test_issue_6900():
+    from itertools import permutations
+    t0, t1, T, t = symbols('t0, t1 T t')
+    f = Piecewise((0, t < t0), (x, And(t0 <= t, t < t1)), (0, t >= t1))
+    g = f.integrate(t)
+    assert g == Piecewise(
+        (0, t <= t0),
+        (t*x - t0*x, t <= Max(t0, t1)),
+        (-t0*x + x*Max(t0, t1), True))
+    for i in permutations(range(2)):
+        reps = dict(zip((t0,t1), i))
+        for tt in range(-1,3):
+            assert (g.xreplace(reps).subs(t,tt) ==
+                f.xreplace(reps).integrate(t).subs(t,tt))
+    lim = Tuple(t, t0, T)
+    g = f.integrate(lim)
+    ans = Piecewise(
+        (-t0*x + x*Min(T, Max(t0, t1)), T > t0),
+        (0, True))
+    for i in permutations(range(3)):
+        reps = dict(zip((t0,t1,T), i))
+        tru = f.xreplace(reps).integrate(lim.xreplace(reps))
+        assert tru == ans.xreplace(reps)
+    assert g == ans
+
+
+def test_issue_10122():
+    assert solve(abs(x) + abs(x - 1) - 1 > 0, x
+        ) == Or(And(-oo < x, x < S.Zero), And(S.One < x, x < oo))
+
+
+def test_issue_4313():
+    u = Piecewise((0, x <= 0), (1, x >= a), (x/a, True))
+    e = (u - u.subs(x, y))**2/(x - y)**2
+    M = Max(0, a)
+    assert integrate(e,  x).expand() == Piecewise(
+        (Piecewise(
+            (0, x <= 0),
+            (-y**2/(a**2*x - a**2*y) + x/a**2 - 2*y*log(-y)/a**2 +
+                2*y*log(x - y)/a**2 - y/a**2, x <= M),
+            (-y**2/(-a**2*y + a**2*M) + 1/(-y + M) -
+                1/(x - y) - 2*y*log(-y)/a**2 + 2*y*log(-y +
+                M)/a**2 - y/a**2 + M/a**2, True)),
+        ((a <= y) & (y <= 0)) | ((y <= 0) & (y > -oo))),
+        (Piecewise(
+            (-1/(x - y), x <= 0),
+            (-a**2/(a**2*x - a**2*y) + 2*a*y/(a**2*x - a**2*y) -
+                y**2/(a**2*x - a**2*y) + 2*log(-y)/a - 2*log(x - y)/a +
+                2/a + x/a**2 - 2*y*log(-y)/a**2 + 2*y*log(x - y)/a**2 -
+                y/a**2, x <= M),
+            (-a**2/(-a**2*y + a**2*M) + 2*a*y/(-a**2*y +
+                a**2*M) - y**2/(-a**2*y + a**2*M) +
+                2*log(-y)/a - 2*log(-y + M)/a + 2/a -
+                2*y*log(-y)/a**2 + 2*y*log(-y + M)/a**2 -
+                y/a**2 + M/a**2, True)),
+        a <= y),
+        (Piecewise(
+            (-y**2/(a**2*x - a**2*y), x <= 0),
+            (x/a**2 + y/a**2, x <= M),
+            (a**2/(-a**2*y + a**2*M) -
+                a**2/(a**2*x - a**2*y) - 2*a*y/(-a**2*y + a**2*M) +
+                2*a*y/(a**2*x - a**2*y) + y**2/(-a**2*y + a**2*M) -
+                y**2/(a**2*x - a**2*y) + y/a**2 + M/a**2, True)),
+        True))
+
+
+def test__intervals():
+    assert Piecewise((x + 2, Eq(x, 3)))._intervals(x) == (True, [])
+    assert Piecewise(
+        (1, x > x + 1),
+        (Piecewise((1, x < x + 1)), 2*x < 2*x + 1),
+        (1, True))._intervals(x) == (True, [(-oo, oo, 1, 1)])
+    assert Piecewise((1, Ne(x, I)), (0, True))._intervals(x) == (True,
+        [(-oo, oo, 1, 0)])
+    assert Piecewise((-cos(x), sin(x) >= 0), (cos(x), True)
+        )._intervals(x) == (True,
+        [(0, pi, -cos(x), 0), (-oo, oo, cos(x), 1)])
+    # the following tests that duplicates are removed and that non-Eq
+    # generated zero-width intervals are removed
+    assert Piecewise((1, Abs(x**(-2)) > 1), (0, True)
+        )._intervals(x) == (True,
+        [(-1, 0, 1, 0), (0, 1, 1, 0), (-oo, oo, 0, 1)])
+
+
+def test_containment():
+    a, b, c, d, e = [1, 2, 3, 4, 5]
+    p = (Piecewise((d, x > 1), (e, True))*
+        Piecewise((a, Abs(x - 1) < 1), (b, Abs(x - 2) < 2), (c, True)))
+    assert p.integrate(x).diff(x) == Piecewise(
+        (c*e, x <= 0),
+        (a*e, x <= 1),
+        (a*d, x < 2),  # this is what we want to get right
+        (b*d, x < 4),
+        (c*d, True))
+
+
+def test_piecewise_with_DiracDelta():
+    d1 = DiracDelta(x - 1)
+    assert integrate(d1, (x, -oo, oo)) == 1
+    assert integrate(d1, (x, 0, 2)) == 1
+    assert Piecewise((d1, Eq(x, 2)), (0, True)).integrate(x) == 0
+    assert Piecewise((d1, x < 2), (0, True)).integrate(x) == Piecewise(
+        (Heaviside(x - 1), x < 2), (1, True))
+    # TODO raise error if function is discontinuous at limit of
+    # integration, e.g. integrate(d1, (x, -2, 1)) or Piecewise(
+    # (d1, Eq(x, 1)
+
+
+def test_issue_10258():
+    assert Piecewise((0, x < 1), (1, True)).is_zero is None
+    assert Piecewise((-1, x < 1), (1, True)).is_zero is False
+    a = Symbol('a', zero=True)
+    assert Piecewise((0, x < 1), (a, True)).is_zero
+    assert Piecewise((1, x < 1), (a, x < 3)).is_zero is None
+    a = Symbol('a')
+    assert Piecewise((0, x < 1), (a, True)).is_zero is None
+    assert Piecewise((0, x < 1), (1, True)).is_nonzero is None
+    assert Piecewise((1, x < 1), (2, True)).is_nonzero
+    assert Piecewise((0, x < 1), (oo, True)).is_finite is None
+    assert Piecewise((0, x < 1), (1, True)).is_finite
+    b = Basic()
+    assert Piecewise((b, x < 1)).is_finite is None
+
+    # 10258
+    c = Piecewise((1, x < 0), (2, True)) < 3
+    assert c != True
+    assert piecewise_fold(c) == True
+
+
+def test_issue_10087():
+    a, b = Piecewise((x, x > 1), (2, True)), Piecewise((x, x > 3), (3, True))
+    m = a*b
+    f = piecewise_fold(m)
+    for i in (0, 2, 4):
+        assert m.subs(x, i) == f.subs(x, i)
+    m = a + b
+    f = piecewise_fold(m)
+    for i in (0, 2, 4):
+        assert m.subs(x, i) == f.subs(x, i)
+
+
+def test_issue_8919():
+    c = symbols('c:5')
+    x = symbols("x")
+    f1 = Piecewise((c[1], x < 1), (c[2], True))
+    f2 = Piecewise((c[3], x < Rational(1, 3)), (c[4], True))
+    assert integrate(f1*f2, (x, 0, 2)
+        ) == c[1]*c[3]/3 + 2*c[1]*c[4]/3 + c[2]*c[4]
+    f1 = Piecewise((0, x < 1), (2, True))
+    f2 = Piecewise((3, x < 2), (0, True))
+    assert integrate(f1*f2, (x, 0, 3)) == 6
+
+    y = symbols("y", positive=True)
+    a, b, c, x, z = symbols("a,b,c,x,z", real=True)
+    I = Integral(Piecewise(
+        (0, (x >= y) | (x < 0) | (b > c)),
+        (a, True)), (x, 0, z))
+    ans = I.doit()
+    assert ans == Piecewise((0, b > c), (a*Min(y, z) - a*Min(0, z), True))
+    for cond in (True, False):
+         for yy in range(1, 3):
+             for zz in range(-yy, 0, yy):
+                 reps = [(b > c, cond), (y, yy), (z, zz)]
+                 assert ans.subs(reps) == I.subs(reps).doit()
+
+
+def test_unevaluated_integrals():
+    f = Function('f')
+    p = Piecewise((1, Eq(f(x) - 1, 0)), (2, x - 10 < 0), (0, True))
+    assert p.integrate(x) == Integral(p, x)
+    assert p.integrate((x, 0, 5)) == Integral(p, (x, 0, 5))
+    # test it by replacing f(x) with x%2 which will not
+    # affect the answer: the integrand is essentially 2 over
+    # the domain of integration
+    assert Integral(p, (x, 0, 5)).subs(f(x), x%2).n() == 10.0
+
+    # this is a test of using _solve_inequality when
+    # solve_univariate_inequality fails
+    assert p.integrate(y) == Piecewise(
+        (y, Eq(f(x), 1) | ((x < 10) & Eq(f(x), 1))),
+        (2*y, (x > -oo) & (x < 10)), (0, True))
+
+
+def test_conditions_as_alternate_booleans():
+    a, b, c = symbols('a:c')
+    assert Piecewise((x, Piecewise((y < 1, x > 0), (y > 1, True)))
+        ) == Piecewise((x, ITE(x > 0, y < 1, y > 1)))
+
+
+def test_Piecewise_rewrite_as_ITE():
+    a, b, c, d = symbols('a:d')
+
+    def _ITE(*args):
+        return Piecewise(*args).rewrite(ITE)
+
+    assert _ITE((a, x < 1), (b, x >= 1)) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, x < oo)) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, Or(y < 1, x < oo)), (c, y > 0)
+               ) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, True)) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, x < 2), (c, True)
+               ) == ITE(x < 1, a, ITE(x < 2, b, c))
+    assert _ITE((a, x < 1), (b, y < 2), (c, True)
+               ) == ITE(x < 1, a, ITE(y < 2, b, c))
+    assert _ITE((a, x < 1), (b, x < oo), (c, y < 1)
+               ) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (c, y < 1), (b, x < oo), (d, True)
+               ) == ITE(x < 1, a, ITE(y < 1, c, b))
+    assert _ITE((a, x < 0), (b, Or(x < oo, y < 1))
+               ) == ITE(x < 0, a, b)
+    raises(TypeError, lambda: _ITE((x + 1, x < 1), (x, True)))
+    # if `a` in the following were replaced with y then the coverage
+    # is complete but something other than as_set would need to be
+    # used to detect this
+    raises(NotImplementedError, lambda: _ITE((x, x < y), (y, x >= a)))
+    raises(ValueError, lambda: _ITE((a, x < 2), (b, x > 3)))
+
+
+def test_issue_14052():
+    assert integrate(abs(sin(x)), (x, 0, 2*pi)) == 4
+
+
+def test_issue_14240():
+    assert piecewise_fold(
+        Piecewise((1, a), (2, b), (4, True)) +
+        Piecewise((8, a), (16, True))
+        ) == Piecewise((9, a), (18, b), (20, True))
+    assert piecewise_fold(
+        Piecewise((2, a), (3, b), (5, True)) *
+        Piecewise((7, a), (11, True))
+        ) == Piecewise((14, a), (33, b), (55, True))
+    # these will hang if naive folding is used
+    assert piecewise_fold(Add(*[
+        Piecewise((i, a), (0, True)) for i in range(40)])
+        ) == Piecewise((780, a), (0, True))
+    assert piecewise_fold(Mul(*[
+        Piecewise((i, a), (0, True)) for i in range(1, 41)])
+        ) == Piecewise((factorial(40), a), (0, True))
+
+
+def test_issue_14787():
+    x = Symbol('x')
+    f = Piecewise((x, x < 1), ((S(58) / 7), True))
+    assert str(f.evalf()) == "Piecewise((x, x < 1), (8.28571428571429, True))"
+
+def test_issue_21481():
+    b, e = symbols('b e')
+    C = Piecewise(
+        (2,
+        ((b > 1) & (e > 0)) |
+        ((b > 0) & (b < 1) & (e < 0)) |
+        ((e >= 2) & (b < -1) & Eq(Mod(e, 2), 0)) |
+        ((e <= -2) & (b > -1) & (b < 0) & Eq(Mod(e, 2), 0))),
+        (S.Half,
+        ((b > 1) & (e < 0)) |
+        ((b > 0) & (e > 0) & (b < 1)) |
+        ((e <= -2) & (b < -1) & Eq(Mod(e, 2), 0)) |
+        ((e >= 2) & (b > -1) & (b < 0) & Eq(Mod(e, 2), 0))),
+        (-S.Half,
+        Eq(Mod(e, 2), 1) &
+        (((e <= -1) & (b < -1)) | ((e >= 1) & (b > -1) & (b < 0)))),
+        (-2,
+        ((e >= 1) & (b < -1) & Eq(Mod(e, 2), 1)) |
+        ((e <= -1) & (b > -1) & (b < 0) & Eq(Mod(e, 2), 1)))
+    )
+    A = Piecewise(
+        (1, Eq(b, 1) | Eq(e, 0) | (Eq(b, -1) & Eq(Mod(e, 2), 0))),
+        (0, Eq(b, 0) & (e > 0)),
+        (-1, Eq(b, -1) & Eq(Mod(e, 2), 1)),
+        (C, Eq(im(b), 0) & Eq(im(e), 0))
+    )
+
+    B = piecewise_fold(A)
+    sa = A.simplify()
+    sb = B.simplify()
+    v = (-2, -1, -S.Half, 0, S.Half, 1, 2)
+    for i in v:
+        for j in v:
+            r = {b:i, e:j}
+            ok = [k.xreplace(r) for k in (A, B, sa, sb)]
+            assert len(set(ok)) == 1
+
+
+def test_issue_8458():
+    x, y = symbols('x y')
+    # Original issue
+    p1 = Piecewise((0, Eq(x, 0)), (sin(x), True))
+    assert p1.simplify() == sin(x)
+    # Slightly larger variant
+    p2 = Piecewise((x, Eq(x, 0)), (4*x + (y-2)**4, Eq(x, 0) & Eq(x+y, 2)), (sin(x), True))
+    assert p2.simplify() == sin(x)
+    # Test for problem highlighted during review
+    p3 = Piecewise((x+1, Eq(x, -1)), (4*x + (y-2)**4, Eq(x, 0) & Eq(x+y, 2)), (sin(x), True))
+    assert p3.simplify() == Piecewise((0, Eq(x, -1)), (sin(x), True))
+
+
+def test_issue_16417():
+    z = Symbol('z')
+    assert unchanged(Piecewise, (1, Or(Eq(im(z), 0), Gt(re(z), 0))), (2, True))
+
+    x = Symbol('x')
+    assert unchanged(Piecewise, (S.Pi, re(x) < 0),
+                 (0, Or(re(x) > 0, Ne(im(x), 0))),
+                 (S.NaN, True))
+    r = Symbol('r', real=True)
+    p = Piecewise((S.Pi, re(r) < 0),
+                 (0, Or(re(r) > 0, Ne(im(r), 0))),
+                 (S.NaN, True))
+    assert p == Piecewise((S.Pi, r < 0),
+                 (0, r > 0),
+                 (S.NaN, True), evaluate=False)
+    # Does not work since imaginary != 0...
+    #i = Symbol('i', imaginary=True)
+    #p = Piecewise((S.Pi, re(i) < 0),
+    #              (0, Or(re(i) > 0, Ne(im(i), 0))),
+    #              (S.NaN, True))
+    #assert p == Piecewise((0, Ne(im(i), 0)),
+    #                      (S.NaN, True), evaluate=False)
+    i = I*r
+    p = Piecewise((S.Pi, re(i) < 0),
+                  (0, Or(re(i) > 0, Ne(im(i), 0))),
+                  (S.NaN, True))
+    assert p == Piecewise((0, Ne(im(i), 0)),
+                          (S.NaN, True), evaluate=False)
+    assert p == Piecewise((0, Ne(r, 0)),
+                          (S.NaN, True), evaluate=False)
+
+
+def test_eval_rewrite_as_KroneckerDelta():
+    x, y, z, n, t, m = symbols('x y z n t m')
+    K = KroneckerDelta
+    f = lambda p: expand(p.rewrite(K))
+
+    p1 = Piecewise((0, Eq(x, y)), (1, True))
+    assert f(p1) == 1 - K(x, y)
+
+    p2 = Piecewise((x, Eq(y,0)), (z, Eq(t,0)), (n, True))
+    assert f(p2) == n*K(0, t)*K(0, y) - n*K(0, t) - n*K(0, y) + n + \
+           x*K(0, y) - z*K(0, t)*K(0, y) + z*K(0, t)
+
+    p3 = Piecewise((1, Ne(x, y)), (0, True))
+    assert f(p3) == 1 - K(x, y)
+
+    p4 = Piecewise((1, Eq(x, 3)), (4, True), (5, True))
+    assert f(p4) == 4 - 3*K(3, x)
+
+    p5 = Piecewise((3, Ne(x, 2)), (4, Eq(y, 2)), (5, True))
+    assert f(p5) == -K(2, x)*K(2, y) + 2*K(2, x) + 3
+
+    p6 = Piecewise((0, Ne(x, 1) & Ne(y, 4)), (1, True))
+    assert f(p6) == -K(1, x)*K(4, y) + K(1, x) + K(4, y)
+
+    p7 = Piecewise((2, Eq(y, 3) & Ne(x, 2)), (1, True))
+    assert f(p7) == -K(2, x)*K(3, y) + K(3, y) + 1
+
+    p8 = Piecewise((4, Eq(x, 3) & Ne(y, 2)), (1, True))
+    assert f(p8) == -3*K(2, y)*K(3, x) + 3*K(3, x) + 1
+
+    p9 = Piecewise((6, Eq(x, 4) & Eq(y, 1)), (1, True))
+    assert f(p9) == 5 * K(1, y) * K(4, x) + 1
+
+    p10 = Piecewise((4, Ne(x, -4) | Ne(y, 1)), (1, True))
+    assert f(p10) == -3 * K(-4, x) * K(1, y) + 4
+
+    p11 = Piecewise((1, Eq(y, 2) | Ne(x, -3)), (2, True))
+    assert f(p11) == -K(-3, x)*K(2, y) + K(-3, x) + 1
+
+    p12 = Piecewise((-1, Eq(x, 1) | Ne(y, 3)), (1, True))
+    assert f(p12) == -2*K(1, x)*K(3, y) + 2*K(3, y) - 1
+
+    p13 = Piecewise((3, Eq(x, 2) | Eq(y, 4)), (1, True))
+    assert f(p13) == -2*K(2, x)*K(4, y) + 2*K(2, x) + 2*K(4, y) + 1
+
+    p14 = Piecewise((1, Ne(x, 0) | Ne(y, 1)), (3, True))
+    assert f(p14) == 2 * K(0, x) * K(1, y) + 1
+
+    p15 = Piecewise((2, Eq(x, 3) | Ne(y, 2)), (3, Eq(x, 4) & Eq(y, 5)), (1, True))
+    assert f(p15) == -2*K(2, y)*K(3, x)*K(4, x)*K(5, y) + K(2, y)*K(3, x) + \
+           2*K(2, y)*K(4, x)*K(5, y) - K(2, y) + 2
+
+    p16 = Piecewise((0, Ne(m, n)), (1, True))*Piecewise((0, Ne(n, t)), (1, True))\
+          *Piecewise((0, Ne(n, x)), (1, True)) - Piecewise((0, Ne(t, x)), (1, True))
+    assert f(p16) == K(m, n)*K(n, t)*K(n, x) - K(t, x)
+
+    p17 = Piecewise((0, Ne(t, x) & (Ne(m, n) | Ne(n, t) | Ne(n, x))),
+                    (1, Ne(t, x)), (-1, Ne(m, n) | Ne(n, t) | Ne(n, x)), (0, True))
+    assert f(p17) == K(m, n)*K(n, t)*K(n, x) - K(t, x)
+
+    p18 = Piecewise((-4, Eq(y, 1) | (Eq(x, -5) & Eq(x, z))), (4, True))
+    assert f(p18) == 8*K(-5, x)*K(1, y)*K(x, z) - 8*K(-5, x)*K(x, z) - 8*K(1, y) + 4
+
+    p19 = Piecewise((0, x > 2), (1, True))
+    assert f(p19) == p19
+
+    p20 = Piecewise((0, And(x < 2, x > -5)), (1, True))
+    assert f(p20) == p20
+
+    p21 = Piecewise((0, Or(x > 1, x < 0)), (1, True))
+    assert f(p21) == p21
+
+    p22 = Piecewise((0, ~((Eq(y, -1) | Ne(x, 0)) & (Ne(x, 1) | Ne(y, -1)))), (1, True))
+    assert f(p22) == K(-1, y)*K(0, x) - K(-1, y)*K(1, x) - K(0, x) + 1
+
+
+@slow
+def test_identical_conds_issue():
+    from sympy.stats import Uniform, density
+    u1 = Uniform('u1', 0, 1)
+    u2 = Uniform('u2', 0, 1)
+    # Result is quite big, so not really important here (and should ideally be
+    # simpler). Should not give an exception though.
+    density(u1 + u2)
+
+
+def test_issue_7370():
+    f = Piecewise((1, x <= 2400))
+    v = integrate(f, (x, 0, Float("252.4", 30)))
+    assert str(v) == '252.400000000000000000000000000'
+
+
+def test_issue_14933():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    inp = MatrixSymbol('inp', 1, 1)
+    rep_dict = {y: inp[0, 0], x: inp[0, 0]}
+
+    p = Piecewise((1, ITE(y > 0, x < 0, True)))
+    assert p.xreplace(rep_dict) == Piecewise((1, ITE(inp[0, 0] > 0, inp[0, 0] < 0, True)))
+
+
+def test_issue_16715():
+    raises(NotImplementedError, lambda: Piecewise((x, x<0), (0, y>1)).as_expr_set_pairs())
+
+
+def test_issue_20360():
+    t, tau = symbols("t tau", real=True)
+    n = symbols("n", integer=True)
+    lam = pi * (n - S.Half)
+    eq = integrate(exp(lam * tau), (tau, 0, t))
+    assert eq.simplify() == (2*exp(pi*t*(2*n - 1)/2) - 2)/(pi*(2*n - 1))
+
+
+def test_piecewise_eval():
+    # XXX these tests might need modification if this
+    # simplification is moved out of eval and into
+    # boolalg or Piecewise simplification functions
+    f = lambda x: x.args[0].cond
+    # unsimplified
+    assert f(Piecewise((x, (x > -oo) & (x < 3)))
+        ) == ((x > -oo) & (x < 3))
+    assert f(Piecewise((x, (x > -oo) & (x < oo)))
+        ) == ((x > -oo) & (x < oo))
+    assert f(Piecewise((x, (x > -3) & (x < 3)))
+        ) == ((x > -3) & (x < 3))
+    assert f(Piecewise((x, (x > -3) & (x < oo)))
+        ) == ((x > -3) & (x < oo))
+    assert f(Piecewise((x, (x <= 3) & (x > -oo)))
+        ) == ((x <= 3) & (x > -oo))
+    assert f(Piecewise((x, (x <= 3) & (x > -3)))
+        ) == ((x <= 3) & (x > -3))
+    assert f(Piecewise((x, (x >= -3) & (x < 3)))
+        ) == ((x >= -3) & (x < 3))
+    assert f(Piecewise((x, (x >= -3) & (x < oo)))
+        ) == ((x >= -3) & (x < oo))
+    assert f(Piecewise((x, (x >= -3) & (x <= 3)))
+        ) == ((x >= -3) & (x <= 3))
+    # could simplify by keeping only the first
+    # arg of result
+    assert f(Piecewise((x, (x <= oo) & (x > -oo)))
+        ) == (x > -oo) & (x <= oo)
+    assert f(Piecewise((x, (x <= oo) & (x > -3)))
+        ) == (x > -3) & (x <= oo)
+    assert f(Piecewise((x, (x >= -oo) & (x < 3)))
+        ) == (x < 3) & (x >= -oo)
+    assert f(Piecewise((x, (x >= -oo) & (x < oo)))
+        ) == (x < oo) & (x >= -oo)
+    assert f(Piecewise((x, (x >= -oo) & (x <= 3)))
+        ) == (x <= 3) & (x >= -oo)
+    assert f(Piecewise((x, (x >= -oo) & (x <= oo)))
+        ) == (x <= oo) & (x >= -oo)  # but cannot be True unless x is real
+    assert f(Piecewise((x, (x >= -3) & (x <= oo)))
+        ) == (x >= -3) & (x <= oo)
+    assert f(Piecewise((x, (Abs(arg(a)) <= 1) | (Abs(arg(a)) < 1)))
+        ) == (Abs(arg(a)) <= 1) | (Abs(arg(a)) < 1)
+
+
+def test_issue_22533():
+    x = Symbol('x', real=True)
+    f = Piecewise((-1 / x, x <= 0), (1 / x, True))
+    assert integrate(f, x) == Piecewise((-log(x), x <= 0), (log(x), True))
+
+
+def test_issue_24072():
+    assert Piecewise((1, x > 1), (2, x <= 1), (3, x <= 1)
+        ) == Piecewise((1, x > 1), (2, True))
+
+
+def test_piecewise__eval_is_meromorphic():
+    """ Issue 24127: Tests eval_is_meromorphic auxiliary method """
+    x = symbols('x', real=True)
+    f = Piecewise((1, x < 0), (sqrt(1 - x), True))
+    assert f.is_meromorphic(x, I) is None
+    assert f.is_meromorphic(x, -1) == True
+    assert f.is_meromorphic(x, 0) == None
+    assert f.is_meromorphic(x, 1) == False
+    assert f.is_meromorphic(x, 2) == True
+    assert f.is_meromorphic(x, Symbol('a')) == None
+    assert f.is_meromorphic(x, Symbol('a', real=True)) == None

venv/lib/python3.10/site-packages/sympy/functions/elementary/tests/test_trigonometric.py

@@ -0,0 +1,2162 @@
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core.add import Add
+from sympy.core.function import (Lambda, diff)
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import (E, Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (arg, conjugate, im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acoth, asinh, atanh, cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, acot, acsc, asec, asin, atan, atan2,
+                                                      cos, cot, csc, sec, sin, sinc, tan)
+from sympy.functions.special.bessel import (besselj, jn)
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.matrices.dense import Matrix
+from sympy.polys.polytools import (cancel, gcd)
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.series.series import series
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.sets import (FiniteSet, Interval)
+from sympy.simplify.simplify import simplify
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.core.relational import Ne, Eq
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.sets.setexpr import SetExpr
+from sympy.testing.pytest import XFAIL, slow, raises
+
+
+x, y, z = symbols('x y z')
+r = Symbol('r', real=True)
+k, m = symbols('k m', integer=True)
+p = Symbol('p', positive=True)
+n = Symbol('n', negative=True)
+np = Symbol('p', nonpositive=True)
+nn = Symbol('n', nonnegative=True)
+nz = Symbol('nz', nonzero=True)
+ep = Symbol('ep', extended_positive=True)
+en = Symbol('en', extended_negative=True)
+enp = Symbol('ep', extended_nonpositive=True)
+enn = Symbol('en', extended_nonnegative=True)
+enz = Symbol('enz', extended_nonzero=True)
+a = Symbol('a', algebraic=True)
+na = Symbol('na', nonzero=True, algebraic=True)
+
+
+def test_sin():
+    x, y = symbols('x y')
+    z = symbols('z', imaginary=True)
+
+    assert sin.nargs == FiniteSet(1)
+    assert sin(nan) is nan
+    assert sin(zoo) is nan
+
+    assert sin(oo) == AccumBounds(-1, 1)
+    assert sin(oo) - sin(oo) == AccumBounds(-2, 2)
+    assert sin(oo*I) == oo*I
+    assert sin(-oo*I) == -oo*I
+    assert 0*sin(oo) is S.Zero
+    assert 0/sin(oo) is S.Zero
+    assert 0 + sin(oo) == AccumBounds(-1, 1)
+    assert 5 + sin(oo) == AccumBounds(4, 6)
+
+    assert sin(0) == 0
+
+    assert sin(z*I) == I*sinh(z)
+    assert sin(asin(x)) == x
+    assert sin(atan(x)) == x / sqrt(1 + x**2)
+    assert sin(acos(x)) == sqrt(1 - x**2)
+    assert sin(acot(x)) == 1 / (sqrt(1 + 1 / x**2) * x)
+    assert sin(acsc(x)) == 1 / x
+    assert sin(asec(x)) == sqrt(1 - 1 / x**2)
+    assert sin(atan2(y, x)) == y / sqrt(x**2 + y**2)
+
+    assert sin(pi*I) == sinh(pi)*I
+    assert sin(-pi*I) == -sinh(pi)*I
+    assert sin(-2*I) == -sinh(2)*I
+
+    assert sin(pi) == 0
+    assert sin(-pi) == 0
+    assert sin(2*pi) == 0
+    assert sin(-2*pi) == 0
+    assert sin(-3*10**73*pi) == 0
+    assert sin(7*10**103*pi) == 0
+
+    assert sin(pi/2) == 1
+    assert sin(-pi/2) == -1
+    assert sin(pi*Rational(5, 2)) == 1
+    assert sin(pi*Rational(7, 2)) == -1
+
+    ne = symbols('ne', integer=True, even=False)
+    e = symbols('e', even=True)
+    assert sin(pi*ne/2) == (-1)**(ne/2 - S.Half)
+    assert sin(pi*k/2).func == sin
+    assert sin(pi*e/2) == 0
+    assert sin(pi*k) == 0
+    assert sin(pi*k).subs(k, 3) == sin(pi*k/2).subs(k, 6)  # issue 8298
+
+    assert sin(pi/3) == S.Half*sqrt(3)
+    assert sin(pi*Rational(-2, 3)) == Rational(-1, 2)*sqrt(3)
+
+    assert sin(pi/4) == S.Half*sqrt(2)
+    assert sin(-pi/4) == Rational(-1, 2)*sqrt(2)
+    assert sin(pi*Rational(17, 4)) == S.Half*sqrt(2)
+    assert sin(pi*Rational(-3, 4)) == Rational(-1, 2)*sqrt(2)
+
+    assert sin(pi/6) == S.Half
+    assert sin(-pi/6) == Rational(-1, 2)
+    assert sin(pi*Rational(7, 6)) == Rational(-1, 2)
+    assert sin(pi*Rational(-5, 6)) == Rational(-1, 2)
+
+    assert sin(pi*Rational(1, 5)) == sqrt((5 - sqrt(5)) / 8)
+    assert sin(pi*Rational(2, 5)) == sqrt((5 + sqrt(5)) / 8)
+    assert sin(pi*Rational(3, 5)) == sin(pi*Rational(2, 5))
+    assert sin(pi*Rational(4, 5)) == sin(pi*Rational(1, 5))
+    assert sin(pi*Rational(6, 5)) == -sin(pi*Rational(1, 5))
+    assert sin(pi*Rational(8, 5)) == -sin(pi*Rational(2, 5))
+
+    assert sin(pi*Rational(-1273, 5)) == -sin(pi*Rational(2, 5))
+
+    assert sin(pi/8) == sqrt((2 - sqrt(2))/4)
+
+    assert sin(pi/10) == Rational(-1, 4) + sqrt(5)/4
+
+    assert sin(pi/12) == -sqrt(2)/4 + sqrt(6)/4
+    assert sin(pi*Rational(5, 12)) == sqrt(2)/4 + sqrt(6)/4
+    assert sin(pi*Rational(-7, 12)) == -sqrt(2)/4 - sqrt(6)/4
+    assert sin(pi*Rational(-11, 12)) == sqrt(2)/4 - sqrt(6)/4
+
+    assert sin(pi*Rational(104, 105)) == sin(pi/105)
+    assert sin(pi*Rational(106, 105)) == -sin(pi/105)
+
+    assert sin(pi*Rational(-104, 105)) == -sin(pi/105)
+    assert sin(pi*Rational(-106, 105)) == sin(pi/105)
+
+    assert sin(x*I) == sinh(x)*I
+
+    assert sin(k*pi) == 0
+    assert sin(17*k*pi) == 0
+    assert sin(2*k*pi + 4) == sin(4)
+    assert sin(2*k*pi + m*pi + 1) == (-1)**(m + 2*k)*sin(1)
+
+    assert sin(k*pi*I) == sinh(k*pi)*I
+
+    assert sin(r).is_real is True
+
+    assert sin(0, evaluate=False).is_algebraic
+    assert sin(a).is_algebraic is None
+    assert sin(na).is_algebraic is False
+    q = Symbol('q', rational=True)
+    assert sin(pi*q).is_algebraic
+    qn = Symbol('qn', rational=True, nonzero=True)
+    assert sin(qn).is_rational is False
+    assert sin(q).is_rational is None  # issue 8653
+
+    assert isinstance(sin( re(x) - im(y)), sin) is True
+    assert isinstance(sin(-re(x) + im(y)), sin) is False
+
+    assert sin(SetExpr(Interval(0, 1))) == SetExpr(ImageSet(Lambda(x, sin(x)),
+                       Interval(0, 1)))
+
+    for d in list(range(1, 22)) + [60, 85]:
+        for n in range(d*2 + 1):
+            x = n*pi/d
+            e = abs( float(sin(x)) - sin(float(x)) )
+            assert e < 1e-12
+
+    assert sin(0, evaluate=False).is_zero is True
+    assert sin(k*pi, evaluate=False).is_zero is True
+
+    assert sin(Add(1, -1, evaluate=False), evaluate=False).is_zero is True
+
+
+def test_sin_cos():
+    for d in [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 24, 30, 40, 60, 120]:  # list is not exhaustive...
+        for n in range(-2*d, d*2):
+            x = n*pi/d
+            assert sin(x + pi/2) == cos(x), "fails for %d*pi/%d" % (n, d)
+            assert sin(x - pi/2) == -cos(x), "fails for %d*pi/%d" % (n, d)
+            assert sin(x) == cos(x - pi/2), "fails for %d*pi/%d" % (n, d)
+            assert -sin(x) == cos(x + pi/2), "fails for %d*pi/%d" % (n, d)
+
+
+def test_sin_series():
+    assert sin(x).series(x, 0, 9) == \
+        x - x**3/6 + x**5/120 - x**7/5040 + O(x**9)
+
+
+def test_sin_rewrite():
+    assert sin(x).rewrite(exp) == -I*(exp(I*x) - exp(-I*x))/2
+    assert sin(x).rewrite(tan) == 2*tan(x/2)/(1 + tan(x/2)**2)
+    assert sin(x).rewrite(cot) == \
+        Piecewise((0, Eq(im(x), 0) & Eq(Mod(x, pi), 0)),
+                  (2*cot(x/2)/(cot(x/2)**2 + 1), True))
+    assert sin(sinh(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, sinh(3)).n()
+    assert sin(cosh(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cosh(3)).n()
+    assert sin(tanh(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, tanh(3)).n()
+    assert sin(coth(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, coth(3)).n()
+    assert sin(sin(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, sin(3)).n()
+    assert sin(cos(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cos(3)).n()
+    assert sin(tan(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, tan(3)).n()
+    assert sin(cot(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cot(3)).n()
+    assert sin(log(x)).rewrite(Pow) == I*x**-I / 2 - I*x**I /2
+    assert sin(x).rewrite(csc) == 1/csc(x)
+    assert sin(x).rewrite(cos) == cos(x - pi / 2, evaluate=False)
+    assert sin(x).rewrite(sec) == 1 / sec(x - pi / 2, evaluate=False)
+    assert sin(cos(x)).rewrite(Pow) == sin(cos(x))
+
+
+def _test_extrig(f, i, e):
+    from sympy.core.function import expand_trig
+    assert unchanged(f, i)
+    assert expand_trig(f(i)) == f(i)
+    # testing directly instead of with .expand(trig=True)
+    # because the other expansions undo the unevaluated Mul
+    assert expand_trig(f(Mul(i, 1, evaluate=False))) == e
+    assert abs(f(i) - e).n() < 1e-10
+
+
+def test_sin_expansion():
+    # Note: these formulas are not unique.  The ones here come from the
+    # Chebyshev formulas.
+    assert sin(x + y).expand(trig=True) == sin(x)*cos(y) + cos(x)*sin(y)
+    assert sin(x - y).expand(trig=True) == sin(x)*cos(y) - cos(x)*sin(y)
+    assert sin(y - x).expand(trig=True) == cos(x)*sin(y) - sin(x)*cos(y)
+    assert sin(2*x).expand(trig=True) == 2*sin(x)*cos(x)
+    assert sin(3*x).expand(trig=True) == -4*sin(x)**3 + 3*sin(x)
+    assert sin(4*x).expand(trig=True) == -8*sin(x)**3*cos(x) + 4*sin(x)*cos(x)
+    _test_extrig(sin, 2, 2*sin(1)*cos(1))
+    _test_extrig(sin, 3, -4*sin(1)**3 + 3*sin(1))
+
+
+def test_sin_AccumBounds():
+    assert sin(AccumBounds(-oo, oo)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(0, oo)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(-oo, 0)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(0, 2*S.Pi)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(0, S.Pi*Rational(3, 4))) == AccumBounds(0, 1)
+    assert sin(AccumBounds(S.Pi*Rational(3, 4), S.Pi*Rational(7, 4))) == AccumBounds(-1, sin(S.Pi*Rational(3, 4)))
+    assert sin(AccumBounds(S.Pi/4, S.Pi/3)) == AccumBounds(sin(S.Pi/4), sin(S.Pi/3))
+    assert sin(AccumBounds(S.Pi*Rational(3, 4), S.Pi*Rational(5, 6))) == AccumBounds(sin(S.Pi*Rational(5, 6)), sin(S.Pi*Rational(3, 4)))
+
+
+def test_sin_fdiff():
+    assert sin(x).fdiff() == cos(x)
+    raises(ArgumentIndexError, lambda: sin(x).fdiff(2))
+
+
+def test_trig_symmetry():
+    assert sin(-x) == -sin(x)
+    assert cos(-x) == cos(x)
+    assert tan(-x) == -tan(x)
+    assert cot(-x) == -cot(x)
+    assert sin(x + pi) == -sin(x)
+    assert sin(x + 2*pi) == sin(x)
+    assert sin(x + 3*pi) == -sin(x)
+    assert sin(x + 4*pi) == sin(x)
+    assert sin(x - 5*pi) == -sin(x)
+    assert cos(x + pi) == -cos(x)
+    assert cos(x + 2*pi) == cos(x)
+    assert cos(x + 3*pi) == -cos(x)
+    assert cos(x + 4*pi) == cos(x)
+    assert cos(x - 5*pi) == -cos(x)
+    assert tan(x + pi) == tan(x)
+    assert tan(x - 3*pi) == tan(x)
+    assert cot(x + pi) == cot(x)
+    assert cot(x - 3*pi) == cot(x)
+    assert sin(pi/2 - x) == cos(x)
+    assert sin(pi*Rational(3, 2) - x) == -cos(x)
+    assert sin(pi*Rational(5, 2) - x) == cos(x)
+    assert cos(pi/2 - x) == sin(x)
+    assert cos(pi*Rational(3, 2) - x) == -sin(x)
+    assert cos(pi*Rational(5, 2) - x) == sin(x)
+    assert tan(pi/2 - x) == cot(x)
+    assert tan(pi*Rational(3, 2) - x) == cot(x)
+    assert tan(pi*Rational(5, 2) - x) == cot(x)
+    assert cot(pi/2 - x) == tan(x)
+    assert cot(pi*Rational(3, 2) - x) == tan(x)
+    assert cot(pi*Rational(5, 2) - x) == tan(x)
+    assert sin(pi/2 + x) == cos(x)
+    assert cos(pi/2 + x) == -sin(x)
+    assert tan(pi/2 + x) == -cot(x)
+    assert cot(pi/2 + x) == -tan(x)
+
+
+def test_cos():
+    x, y = symbols('x y')
+
+    assert cos.nargs == FiniteSet(1)
+    assert cos(nan) is nan
+
+    assert cos(oo) == AccumBounds(-1, 1)
+    assert cos(oo) - cos(oo) == AccumBounds(-2, 2)
+    assert cos(oo*I) is oo
+    assert cos(-oo*I) is oo
+    assert cos(zoo) is nan
+
+    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(acsc(x)) == sqrt(1 - 1 / x**2)
+    assert cos(asec(x)) == 1 / x
+    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) == S.Half
+    assert cos(pi*Rational(-2, 3)) == Rational(-1, 2)
+
+    assert cos(pi/4) == S.Half*sqrt(2)
+    assert cos(-pi/4) == S.Half*sqrt(2)
+    assert cos(pi*Rational(11, 4)) == Rational(-1, 2)*sqrt(2)
+    assert cos(pi*Rational(-3, 4)) == Rational(-1, 2)*sqrt(2)
+
+    assert cos(pi/6) == S.Half*sqrt(3)
+    assert cos(-pi/6) == S.Half*sqrt(3)
+    assert cos(pi*Rational(7, 6)) == Rational(-1, 2)*sqrt(3)
+    assert cos(pi*Rational(-5, 6)) == Rational(-1, 2)*sqrt(3)
+
+    assert cos(pi*Rational(1, 5)) == (sqrt(5) + 1)/4
+    assert cos(pi*Rational(2, 5)) == (sqrt(5) - 1)/4
+    assert cos(pi*Rational(3, 5)) == -cos(pi*Rational(2, 5))
+    assert cos(pi*Rational(4, 5)) == -cos(pi*Rational(1, 5))
+    assert cos(pi*Rational(6, 5)) == -cos(pi*Rational(1, 5))
+    assert cos(pi*Rational(8, 5)) == cos(pi*Rational(2, 5))
+
+    assert cos(pi*Rational(-1273, 5)) == -cos(pi*Rational(2, 5))
+
+    assert cos(pi/8) == sqrt((2 + sqrt(2))/4)
+
+    assert cos(pi/12) == sqrt(2)/4 + sqrt(6)/4
+    assert cos(pi*Rational(5, 12)) == -sqrt(2)/4 + sqrt(6)/4
+    assert cos(pi*Rational(7, 12)) == sqrt(2)/4 - sqrt(6)/4
+    assert cos(pi*Rational(11, 12)) == -sqrt(2)/4 - sqrt(6)/4
+
+    assert cos(pi*Rational(104, 105)) == -cos(pi/105)
+    assert cos(pi*Rational(106, 105)) == -cos(pi/105)
+
+    assert cos(pi*Rational(-104, 105)) == -cos(pi/105)
+    assert cos(pi*Rational(-106, 105)) == -cos(pi/105)
+
+    assert cos(x*I) == cosh(x)
+    assert cos(k*pi*I) == cosh(k*pi)
+
+    assert cos(r).is_real is True
+
+    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(pi*Rational(2, 7)).is_algebraic
+
+    assert cos(k*pi) == (-1)**k
+    assert cos(2*k*pi) == 1
+    assert cos(0, evaluate=False).is_zero is False
+    assert cos(Rational(1, 2)).is_zero is False
+    # The following test will return None as the result, but really it should
+    # be True even if it is not always possible to resolve an assumptions query.
+    assert cos(asin(-1, evaluate=False), evaluate=False).is_zero is None
+    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
+
+
+def test_issue_6190():
+    c = Float('123456789012345678901234567890.25', '')
+    for cls in [sin, cos, tan, cot]:
+        assert cls(c*pi) == cls(pi/4)
+        assert cls(4.125*pi) == cls(pi/8)
+        assert cls(4.7*pi) == cls((4.7 % 2)*pi)
+
+
+def test_cos_series():
+    assert cos(x).series(x, 0, 9) == \
+        1 - x**2/2 + x**4/24 - x**6/720 + x**8/40320 + O(x**9)
+
+
+def test_cos_rewrite():
+    assert cos(x).rewrite(exp) == exp(I*x)/2 + exp(-I*x)/2
+    assert cos(x).rewrite(tan) == (1 - tan(x/2)**2)/(1 + tan(x/2)**2)
+    assert cos(x).rewrite(cot) == \
+        Piecewise((1, Eq(im(x), 0) & Eq(Mod(x, 2*pi), 0)),
+                  ((cot(x/2)**2 - 1)/(cot(x/2)**2 + 1), True))
+    assert cos(sinh(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, sinh(3)).n()
+    assert cos(cosh(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cosh(3)).n()
+    assert cos(tanh(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, tanh(3)).n()
+    assert cos(coth(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, coth(3)).n()
+    assert cos(sin(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, sin(3)).n()
+    assert cos(cos(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cos(3)).n()
+    assert cos(tan(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, tan(3)).n()
+    assert cos(cot(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cot(3)).n()
+    assert cos(log(x)).rewrite(Pow) == x**I/2 + x**-I/2
+    assert cos(x).rewrite(sec) == 1/sec(x)
+    assert cos(x).rewrite(sin) == sin(x + pi/2, evaluate=False)
+    assert cos(x).rewrite(csc) == 1/csc(-x + pi/2, evaluate=False)
+    assert cos(sin(x)).rewrite(Pow) == cos(sin(x))
+
+
+def test_cos_expansion():
+    assert cos(x + y).expand(trig=True) == cos(x)*cos(y) - sin(x)*sin(y)
+    assert cos(x - y).expand(trig=True) == cos(x)*cos(y) + sin(x)*sin(y)
+    assert cos(y - x).expand(trig=True) == cos(x)*cos(y) + sin(x)*sin(y)
+    assert cos(2*x).expand(trig=True) == 2*cos(x)**2 - 1
+    assert cos(3*x).expand(trig=True) == 4*cos(x)**3 - 3*cos(x)
+    assert cos(4*x).expand(trig=True) == 8*cos(x)**4 - 8*cos(x)**2 + 1
+    _test_extrig(cos, 2, 2*cos(1)**2 - 1)
+    _test_extrig(cos, 3, 4*cos(1)**3 - 3*cos(1))
+
+
+def test_cos_AccumBounds():
+    assert cos(AccumBounds(-oo, oo)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(0, oo)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(-oo, 0)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(0, 2*S.Pi)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(-S.Pi/3, S.Pi/4)) == AccumBounds(cos(-S.Pi/3), 1)
+    assert cos(AccumBounds(S.Pi*Rational(3, 4), S.Pi*Rational(5, 4))) == AccumBounds(-1, cos(S.Pi*Rational(3, 4)))
+    assert cos(AccumBounds(S.Pi*Rational(5, 4), S.Pi*Rational(4, 3))) == AccumBounds(cos(S.Pi*Rational(5, 4)), cos(S.Pi*Rational(4, 3)))
+    assert cos(AccumBounds(S.Pi/4, S.Pi/3)) == AccumBounds(cos(S.Pi/3), cos(S.Pi/4))
+
+
+def test_cos_fdiff():
+    assert cos(x).fdiff() == -sin(x)
+    raises(ArgumentIndexError, lambda: cos(x).fdiff(2))
+
+
+def test_tan():
+    assert tan(nan) is nan
+
+    assert tan(zoo) is nan
+    assert tan(oo) == AccumBounds(-oo, oo)
+    assert tan(oo) - tan(oo) == AccumBounds(-oo, oo)
+    assert tan.nargs == FiniteSet(1)
+    assert tan(oo*I) == I
+    assert tan(-oo*I) == -I
+
+    assert tan(0) == 0
+
+    assert tan(atan(x)) == x
+    assert tan(asin(x)) == x / sqrt(1 - x**2)
+    assert tan(acos(x)) == sqrt(1 - x**2) / x
+    assert tan(acot(x)) == 1 / x
+    assert tan(acsc(x)) == 1 / (sqrt(1 - 1 / x**2) * x)
+    assert tan(asec(x)) == sqrt(1 - 1 / x**2) * x
+    assert tan(atan2(y, x)) == y/x
+
+    assert tan(pi*I) == tanh(pi)*I
+    assert tan(-pi*I) == -tanh(pi)*I
+    assert tan(-2*I) == -tanh(2)*I
+
+    assert tan(pi) == 0
+    assert tan(-pi) == 0
+    assert tan(2*pi) == 0
+    assert tan(-2*pi) == 0
+    assert tan(-3*10**73*pi) == 0
+
+    assert tan(pi/2) is zoo
+    assert tan(pi*Rational(3, 2)) is zoo
+
+    assert tan(pi/3) == sqrt(3)
+    assert tan(pi*Rational(-2, 3)) == sqrt(3)
+
+    assert tan(pi/4) is S.One
+    assert tan(-pi/4) is S.NegativeOne
+    assert tan(pi*Rational(17, 4)) is S.One
+    assert tan(pi*Rational(-3, 4)) is S.One
+
+    assert tan(pi/5) == sqrt(5 - 2*sqrt(5))
+    assert tan(pi*Rational(2, 5)) == sqrt(5 + 2*sqrt(5))
+    assert tan(pi*Rational(18, 5)) == -sqrt(5 + 2*sqrt(5))
+    assert tan(pi*Rational(-16, 5)) == -sqrt(5 - 2*sqrt(5))
+
+    assert tan(pi/6) == 1/sqrt(3)
+    assert tan(-pi/6) == -1/sqrt(3)
+    assert tan(pi*Rational(7, 6)) == 1/sqrt(3)
+    assert tan(pi*Rational(-5, 6)) == 1/sqrt(3)
+
+    assert tan(pi/8) == -1 + sqrt(2)
+    assert tan(pi*Rational(3, 8)) == 1 + sqrt(2)  # issue 15959
+    assert tan(pi*Rational(5, 8)) == -1 - sqrt(2)
+    assert tan(pi*Rational(7, 8)) == 1 - sqrt(2)
+
+    assert tan(pi/10) == sqrt(1 - 2*sqrt(5)/5)
+    assert tan(pi*Rational(3, 10)) == sqrt(1 + 2*sqrt(5)/5)
+    assert tan(pi*Rational(17, 10)) == -sqrt(1 + 2*sqrt(5)/5)
+    assert tan(pi*Rational(-31, 10)) == -sqrt(1 - 2*sqrt(5)/5)
+
+    assert tan(pi/12) == -sqrt(3) + 2
+    assert tan(pi*Rational(5, 12)) == sqrt(3) + 2
+    assert tan(pi*Rational(7, 12)) == -sqrt(3) - 2
+    assert tan(pi*Rational(11, 12)) == sqrt(3) - 2
+
+    assert tan(pi/24).radsimp() == -2 - sqrt(3) + sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(5, 24)).radsimp() == -2 + sqrt(3) - sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(7, 24)).radsimp() == 2 - sqrt(3) - sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(11, 24)).radsimp() == 2 + sqrt(3) + sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(13, 24)).radsimp() == -2 - sqrt(3) - sqrt(2) - sqrt(6)
+    assert tan(pi*Rational(17, 24)).radsimp() == -2 + sqrt(3) + sqrt(2) - sqrt(6)
+    assert tan(pi*Rational(19, 24)).radsimp() == 2 - sqrt(3) + sqrt(2) - sqrt(6)
+    assert tan(pi*Rational(23, 24)).radsimp() == 2 + sqrt(3) - sqrt(2) - sqrt(6)
+
+    assert tan(x*I) == tanh(x)*I
+
+    assert tan(k*pi) == 0
+    assert tan(17*k*pi) == 0
+
+    assert tan(k*pi*I) == tanh(k*pi)*I
+
+    assert tan(r).is_real is None
+    assert tan(r).is_extended_real is True
+
+    assert tan(0, evaluate=False).is_algebraic
+    assert tan(a).is_algebraic is None
+    assert tan(na).is_algebraic is False
+
+    assert tan(pi*Rational(10, 7)) == tan(pi*Rational(3, 7))
+    assert tan(pi*Rational(11, 7)) == -tan(pi*Rational(3, 7))
+    assert tan(pi*Rational(-11, 7)) == tan(pi*Rational(3, 7))
+
+    assert tan(pi*Rational(15, 14)) == tan(pi/14)
+    assert tan(pi*Rational(-15, 14)) == -tan(pi/14)
+
+    assert tan(r).is_finite is None
+    assert tan(I*r).is_finite is True
+
+    # https://github.com/sympy/sympy/issues/21177
+    f = tan(pi*(x + S(3)/2))/(3*x)
+    assert f.as_leading_term(x) == -1/(3*pi*x**2)
+
+
+def test_tan_series():
+    assert tan(x).series(x, 0, 9) == \
+        x + x**3/3 + 2*x**5/15 + 17*x**7/315 + O(x**9)
+
+
+def test_tan_rewrite():
+    neg_exp, pos_exp = exp(-x*I), exp(x*I)
+    assert tan(x).rewrite(exp) == I*(neg_exp - pos_exp)/(neg_exp + pos_exp)
+    assert tan(x).rewrite(sin) == 2*sin(x)**2/sin(2*x)
+    assert tan(x).rewrite(cos) == cos(x - S.Pi/2, evaluate=False)/cos(x)
+    assert tan(x).rewrite(cot) == 1/cot(x)
+    assert tan(sinh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sinh(3)).n()
+    assert tan(cosh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cosh(3)).n()
+    assert tan(tanh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tanh(3)).n()
+    assert tan(coth(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, coth(3)).n()
+    assert tan(sin(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sin(3)).n()
+    assert tan(cos(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cos(3)).n()
+    assert tan(tan(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tan(3)).n()
+    assert tan(cot(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cot(3)).n()
+    assert tan(log(x)).rewrite(Pow) == I*(x**-I - x**I)/(x**-I + x**I)
+    assert tan(x).rewrite(sec) == sec(x)/sec(x - pi/2, evaluate=False)
+    assert tan(x).rewrite(csc) == csc(-x + pi/2, evaluate=False)/csc(x)
+    assert tan(sin(x)).rewrite(Pow) == tan(sin(x))
+
+
+@slow
+def test_tan_rewrite_slow():
+    assert 0 == (cos(pi/34)*tan(pi/34) - sin(pi/34)).rewrite(pow)
+    assert 0 == (cos(pi/17)*tan(pi/17) - sin(pi/17)).rewrite(pow)
+    assert tan(pi/19).rewrite(pow) == tan(pi/19)
+    assert tan(pi*Rational(8, 19)).rewrite(sqrt) == tan(pi*Rational(8, 19))
+    assert tan(pi*Rational(2, 5), evaluate=False).rewrite(sqrt) == sqrt(sqrt(5)/8 +
+               Rational(5, 8))/(Rational(-1, 4) + sqrt(5)/4)
+
+
+def test_tan_subs():
+    assert tan(x).subs(tan(x), y) == y
+    assert tan(x).subs(x, y) == tan(y)
+    assert tan(x).subs(x, S.Pi/2) is zoo
+    assert tan(x).subs(x, S.Pi*Rational(3, 2)) is zoo
+
+
+def test_tan_expansion():
+    assert tan(x + y).expand(trig=True) == ((tan(x) + tan(y))/(1 - tan(x)*tan(y))).expand()
+    assert tan(x - y).expand(trig=True) == ((tan(x) - tan(y))/(1 + tan(x)*tan(y))).expand()
+    assert tan(x + y + z).expand(trig=True) == (
+        (tan(x) + tan(y) + tan(z) - tan(x)*tan(y)*tan(z))/
+        (1 - tan(x)*tan(y) - tan(x)*tan(z) - tan(y)*tan(z))).expand()
+    assert 0 == tan(2*x).expand(trig=True).rewrite(tan).subs([(tan(x), Rational(1, 7))])*24 - 7
+    assert 0 == tan(3*x).expand(trig=True).rewrite(tan).subs([(tan(x), Rational(1, 5))])*55 - 37
+    assert 0 == tan(4*x - pi/4).expand(trig=True).rewrite(tan).subs([(tan(x), Rational(1, 5))])*239 - 1
+    _test_extrig(tan, 2, 2*tan(1)/(1 - tan(1)**2))
+    _test_extrig(tan, 3, (-tan(1)**3 + 3*tan(1))/(1 - 3*tan(1)**2))
+
+
+def test_tan_AccumBounds():
+    assert tan(AccumBounds(-oo, oo)) == AccumBounds(-oo, oo)
+    assert tan(AccumBounds(S.Pi/3, S.Pi*Rational(2, 3))) == AccumBounds(-oo, oo)
+    assert tan(AccumBounds(S.Pi/6, S.Pi/3)) == AccumBounds(tan(S.Pi/6), tan(S.Pi/3))
+
+
+def test_tan_fdiff():
+    assert tan(x).fdiff() == tan(x)**2 + 1
+    raises(ArgumentIndexError, lambda: tan(x).fdiff(2))
+
+
+def test_cot():
+    assert cot(nan) is nan
+
+    assert cot.nargs == FiniteSet(1)
+    assert cot(oo*I) == -I
+    assert cot(-oo*I) == I
+    assert cot(zoo) is nan
+
+    assert cot(0) is zoo
+    assert cot(2*pi) is zoo
+
+    assert cot(acot(x)) == x
+    assert cot(atan(x)) == 1 / x
+    assert cot(asin(x)) == sqrt(1 - x**2) / x
+    assert cot(acos(x)) == x / sqrt(1 - x**2)
+    assert cot(acsc(x)) == sqrt(1 - 1 / x**2) * x
+    assert cot(asec(x)) == 1 / (sqrt(1 - 1 / x**2) * x)
+    assert cot(atan2(y, x)) == x/y
+
+    assert cot(pi*I) == -coth(pi)*I
+    assert cot(-pi*I) == coth(pi)*I
+    assert cot(-2*I) == coth(2)*I
+
+    assert cot(pi) == cot(2*pi) == cot(3*pi)
+    assert cot(-pi) == cot(-2*pi) == cot(-3*pi)
+
+    assert cot(pi/2) == 0
+    assert cot(-pi/2) == 0
+    assert cot(pi*Rational(5, 2)) == 0
+    assert cot(pi*Rational(7, 2)) == 0
+
+    assert cot(pi/3) == 1/sqrt(3)
+    assert cot(pi*Rational(-2, 3)) == 1/sqrt(3)
+
+    assert cot(pi/4) is S.One
+    assert cot(-pi/4) is S.NegativeOne
+    assert cot(pi*Rational(17, 4)) is S.One
+    assert cot(pi*Rational(-3, 4)) is S.One
+
+    assert cot(pi/6) == sqrt(3)
+    assert cot(-pi/6) == -sqrt(3)
+    assert cot(pi*Rational(7, 6)) == sqrt(3)
+    assert cot(pi*Rational(-5, 6)) == sqrt(3)
+
+    assert cot(pi/8) == 1 + sqrt(2)
+    assert cot(pi*Rational(3, 8)) == -1 + sqrt(2)
+    assert cot(pi*Rational(5, 8)) == 1 - sqrt(2)
+    assert cot(pi*Rational(7, 8)) == -1 - sqrt(2)
+
+    assert cot(pi/12) == sqrt(3) + 2
+    assert cot(pi*Rational(5, 12)) == -sqrt(3) + 2
+    assert cot(pi*Rational(7, 12)) == sqrt(3) - 2
+    assert cot(pi*Rational(11, 12)) == -sqrt(3) - 2
+
+    assert cot(pi/24).radsimp() == sqrt(2) + sqrt(3) + 2 + sqrt(6)
+    assert cot(pi*Rational(5, 24)).radsimp() == -sqrt(2) - sqrt(3) + 2 + sqrt(6)
+    assert cot(pi*Rational(7, 24)).radsimp() == -sqrt(2) + sqrt(3) - 2 + sqrt(6)
+    assert cot(pi*Rational(11, 24)).radsimp() == sqrt(2) - sqrt(3) - 2 + sqrt(6)
+    assert cot(pi*Rational(13, 24)).radsimp() == -sqrt(2) + sqrt(3) + 2 - sqrt(6)
+    assert cot(pi*Rational(17, 24)).radsimp() == sqrt(2) - sqrt(3) + 2 - sqrt(6)
+    assert cot(pi*Rational(19, 24)).radsimp() == sqrt(2) + sqrt(3) - 2 - sqrt(6)
+    assert cot(pi*Rational(23, 24)).radsimp() == -sqrt(2) - sqrt(3) - 2 - sqrt(6)
+
+    assert cot(x*I) == -coth(x)*I
+    assert cot(k*pi*I) == -coth(k*pi)*I
+
+    assert cot(r).is_real is None
+    assert cot(r).is_extended_real is True
+
+    assert cot(a).is_algebraic is None
+    assert cot(na).is_algebraic is False
+
+    assert cot(pi*Rational(10, 7)) == cot(pi*Rational(3, 7))
+    assert cot(pi*Rational(11, 7)) == -cot(pi*Rational(3, 7))
+    assert cot(pi*Rational(-11, 7)) == cot(pi*Rational(3, 7))
+
+    assert cot(pi*Rational(39, 34)) == cot(pi*Rational(5, 34))
+    assert cot(pi*Rational(-41, 34)) == -cot(pi*Rational(7, 34))
+
+    assert cot(x).is_finite is None
+    assert cot(r).is_finite is None
+    i = Symbol('i', imaginary=True)
+    assert cot(i).is_finite is True
+
+    assert cot(x).subs(x, 3*pi) is zoo
+
+    # https://github.com/sympy/sympy/issues/21177
+    f = cot(pi*(x + 4))/(3*x)
+    assert f.as_leading_term(x) == 1/(3*pi*x**2)
+
+
+def test_tan_cot_sin_cos_evalf():
+    assert abs((tan(pi*Rational(8, 15))*cos(pi*Rational(8, 15))/sin(pi*Rational(8, 15)) - 1).evalf()) < 1e-14
+    assert abs((cot(pi*Rational(4, 15))*sin(pi*Rational(4, 15))/cos(pi*Rational(4, 15)) - 1).evalf()) < 1e-14
+
+@XFAIL
+def test_tan_cot_sin_cos_ratsimp():
+    assert 1 == (tan(pi*Rational(8, 15))*cos(pi*Rational(8, 15))/sin(pi*Rational(8, 15))).ratsimp()
+    assert 1 == (cot(pi*Rational(4, 15))*sin(pi*Rational(4, 15))/cos(pi*Rational(4, 15))).ratsimp()
+
+
+def test_cot_series():
+    assert cot(x).series(x, 0, 9) == \
+        1/x - x/3 - x**3/45 - 2*x**5/945 - x**7/4725 + O(x**9)
+    # issue 6210
+    assert cot(x**4 + x**5).series(x, 0, 1) == \
+        x**(-4) - 1/x**3 + x**(-2) - 1/x + 1 + O(x)
+    assert cot(pi*(1-x)).series(x, 0, 3) == -1/(pi*x) + pi*x/3 + O(x**3)
+    assert cot(x).taylor_term(0, x) == 1/x
+    assert cot(x).taylor_term(2, x) is S.Zero
+    assert cot(x).taylor_term(3, x) == -x**3/45
+
+
+def test_cot_rewrite():
+    neg_exp, pos_exp = exp(-x*I), exp(x*I)
+    assert cot(x).rewrite(exp) == I*(pos_exp + neg_exp)/(pos_exp - neg_exp)
+    assert cot(x).rewrite(sin) == sin(2*x)/(2*(sin(x)**2))
+    assert cot(x).rewrite(cos) == cos(x)/cos(x - pi/2, evaluate=False)
+    assert cot(x).rewrite(tan) == 1/tan(x)
+    def check(func):
+        z = cot(func(x)).rewrite(exp) - cot(x).rewrite(exp).subs(x, func(x))
+        assert z.rewrite(exp).expand() == 0
+    check(sinh)
+    check(cosh)
+    check(tanh)
+    check(coth)
+    check(sin)
+    check(cos)
+    check(tan)
+    assert cot(log(x)).rewrite(Pow) == -I*(x**-I + x**I)/(x**-I - x**I)
+    assert cot(x).rewrite(sec) == sec(x - pi / 2, evaluate=False) / sec(x)
+    assert cot(x).rewrite(csc) == csc(x) / csc(- x + pi / 2, evaluate=False)
+    assert cot(sin(x)).rewrite(Pow) == cot(sin(x))
+
+
+@slow
+def test_cot_rewrite_slow():
+    assert cot(pi*Rational(4, 34)).rewrite(pow).ratsimp() == \
+        (cos(pi*Rational(4, 34))/sin(pi*Rational(4, 34))).rewrite(pow).ratsimp()
+    assert cot(pi*Rational(4, 17)).rewrite(pow) == \
+        (cos(pi*Rational(4, 17))/sin(pi*Rational(4, 17))).rewrite(pow)
+    assert cot(pi/19).rewrite(pow) == cot(pi/19)
+    assert cot(pi/19).rewrite(sqrt) == cot(pi/19)
+    assert cot(pi*Rational(2, 5), evaluate=False).rewrite(sqrt) == \
+        (Rational(-1, 4) + sqrt(5)/4) / sqrt(sqrt(5)/8 + Rational(5, 8))
+
+
+def test_cot_subs():
+    assert cot(x).subs(cot(x), y) == y
+    assert cot(x).subs(x, y) == cot(y)
+    assert cot(x).subs(x, 0) is zoo
+    assert cot(x).subs(x, S.Pi) is zoo
+
+
+def test_cot_expansion():
+    assert cot(x + y).expand(trig=True).together() == (
+        (cot(x)*cot(y) - 1)/(cot(x) + cot(y)))
+    assert cot(x - y).expand(trig=True).together() == (
+        cot(x)*cot(-y) - 1)/(cot(x) + cot(-y))
+    assert cot(x + y + z).expand(trig=True).together() == (
+        (cot(x)*cot(y)*cot(z) - cot(x) - cot(y) - cot(z))/
+        (-1 + cot(x)*cot(y) + cot(x)*cot(z) + cot(y)*cot(z)))
+    assert cot(3*x).expand(trig=True).together() == (
+        (cot(x)**2 - 3)*cot(x)/(3*cot(x)**2 - 1))
+    assert cot(2*x).expand(trig=True) == cot(x)/2 - 1/(2*cot(x))
+    assert cot(3*x).expand(trig=True).together() == (
+        cot(x)**2 - 3)*cot(x)/(3*cot(x)**2 - 1)
+    assert cot(4*x - pi/4).expand(trig=True).cancel() == (
+        -tan(x)**4 + 4*tan(x)**3 + 6*tan(x)**2 - 4*tan(x) - 1
+        )/(tan(x)**4 + 4*tan(x)**3 - 6*tan(x)**2 - 4*tan(x) + 1)
+    _test_extrig(cot, 2, (-1 + cot(1)**2)/(2*cot(1)))
+    _test_extrig(cot, 3, (-3*cot(1) + cot(1)**3)/(-1 + 3*cot(1)**2))
+
+
+def test_cot_AccumBounds():
+    assert cot(AccumBounds(-oo, oo)) == AccumBounds(-oo, oo)
+    assert cot(AccumBounds(-S.Pi/3, S.Pi/3)) == AccumBounds(-oo, oo)
+    assert cot(AccumBounds(S.Pi/6, S.Pi/3)) == AccumBounds(cot(S.Pi/3), cot(S.Pi/6))
+
+
+def test_cot_fdiff():
+    assert cot(x).fdiff() == -cot(x)**2 - 1
+    raises(ArgumentIndexError, lambda: cot(x).fdiff(2))
+
+
+def test_sinc():
+    assert isinstance(sinc(x), sinc)
+
+    s = Symbol('s', zero=True)
+    assert sinc(s) is S.One
+    assert sinc(S.Infinity) is S.Zero
+    assert sinc(S.NegativeInfinity) is S.Zero
+    assert sinc(S.NaN) is S.NaN
+    assert sinc(S.ComplexInfinity) is S.NaN
+
+    n = Symbol('n', integer=True, nonzero=True)
+    assert sinc(n*pi) is S.Zero
+    assert sinc(-n*pi) is S.Zero
+    assert sinc(pi/2) == 2 / pi
+    assert sinc(-pi/2) == 2 / pi
+    assert sinc(pi*Rational(5, 2)) == 2 / (5*pi)
+    assert sinc(pi*Rational(7, 2)) == -2 / (7*pi)
+
+    assert sinc(-x) == sinc(x)
+
+    assert sinc(x).diff(x) == cos(x)/x - sin(x)/x**2
+    assert sinc(x).diff(x) == (sin(x)/x).diff(x)
+    assert sinc(x).diff(x, x) == (-sin(x) - 2*cos(x)/x + 2*sin(x)/x**2)/x
+    assert sinc(x).diff(x, x) == (sin(x)/x).diff(x, x)
+    assert limit(sinc(x).diff(x), x, 0) == 0
+    assert limit(sinc(x).diff(x, x), x, 0) == -S(1)/3
+
+    # https://github.com/sympy/sympy/issues/11402
+    #
+    # assert sinc(x).diff(x) == Piecewise(((x*cos(x) - sin(x)) / x**2, Ne(x, 0)), (0, True))
+    #
+    # assert sinc(x).diff(x).equals(sinc(x).rewrite(sin).diff(x))
+    #
+    # assert sinc(x).diff(x).subs(x, 0) is S.Zero
+
+    assert sinc(x).series() == 1 - x**2/6 + x**4/120 + O(x**6)
+
+    assert sinc(x).rewrite(jn) == jn(0, x)
+    assert sinc(x).rewrite(sin) == Piecewise((sin(x)/x, Ne(x, 0)), (1, True))
+    assert sinc(pi, evaluate=False).is_zero is True
+    assert sinc(0, evaluate=False).is_zero is False
+    assert sinc(n*pi, evaluate=False).is_zero is True
+    assert sinc(x).is_zero is None
+    xr = Symbol('xr', real=True, nonzero=True)
+    assert sinc(x).is_real is None
+    assert sinc(xr).is_real is True
+    assert sinc(I*xr).is_real is True
+    assert sinc(I*100).is_real is True
+    assert sinc(x).is_finite is None
+    assert sinc(xr).is_finite is True
+
+
+def test_asin():
+    assert asin(nan) is nan
+
+    assert asin.nargs == FiniteSet(1)
+    assert asin(oo) == -I*oo
+    assert asin(-oo) == I*oo
+    assert asin(zoo) is zoo
+
+    # Note: asin(-x) = - asin(x)
+    assert asin(0) == 0
+    assert asin(1) == pi/2
+    assert asin(-1) == -pi/2
+    assert asin(sqrt(3)/2) == pi/3
+    assert asin(-sqrt(3)/2) == -pi/3
+    assert asin(sqrt(2)/2) == pi/4
+    assert asin(-sqrt(2)/2) == -pi/4
+    assert asin(sqrt((5 - sqrt(5))/8)) == pi/5
+    assert asin(-sqrt((5 - sqrt(5))/8)) == -pi/5
+    assert asin(S.Half) == pi/6
+    assert asin(Rational(-1, 2)) == -pi/6
+    assert asin((sqrt(2 - sqrt(2)))/2) == pi/8
+    assert asin(-(sqrt(2 - sqrt(2)))/2) == -pi/8
+    assert asin((sqrt(5) - 1)/4) == pi/10
+    assert asin(-(sqrt(5) - 1)/4) == -pi/10
+    assert asin((sqrt(3) - 1)/sqrt(2**3)) == pi/12
+    assert asin(-(sqrt(3) - 1)/sqrt(2**3)) == -pi/12
+
+    # check round-trip for exact values:
+    for d in [5, 6, 8, 10, 12]:
+        for n in range(-(d//2), d//2 + 1):
+            if gcd(n, d) == 1:
+                assert asin(sin(n*pi/d)) == n*pi/d
+
+    assert asin(x).diff(x) == 1/sqrt(1 - x**2)
+
+    assert asin(0.2, evaluate=False).is_real is True
+    assert asin(-2).is_real is False
+    assert asin(r).is_real is None
+
+    assert asin(-2*I) == -I*asinh(2)
+
+    assert asin(Rational(1, 7), evaluate=False).is_positive is True
+    assert asin(Rational(-1, 7), evaluate=False).is_positive is False
+    assert asin(p).is_positive is None
+    assert asin(sin(Rational(7, 2))) == Rational(-7, 2) + pi
+    assert asin(sin(Rational(-7, 4))) == Rational(7, 4) - pi
+    assert unchanged(asin, cos(x))
+
+
+def test_asin_series():
+    assert asin(x).series(x, 0, 9) == \
+        x + x**3/6 + 3*x**5/40 + 5*x**7/112 + O(x**9)
+    t5 = asin(x).taylor_term(5, x)
+    assert t5 == 3*x**5/40
+    assert asin(x).taylor_term(7, x, t5, 0) == 5*x**7/112
+
+
+def test_asin_leading_term():
+    assert asin(x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert asin(x + 1).as_leading_term(x) == pi/2
+    assert asin(x - 1).as_leading_term(x) == -pi/2
+    assert asin(1/x).as_leading_term(x, cdir=1) == I*log(x) + pi/2 - I*log(2)
+    assert asin(1/x).as_leading_term(x, cdir=-1) == -I*log(x) - 3*pi/2 + I*log(2)
+    # Tests concerning points lying on branch cuts
+    assert asin(I*x + 2).as_leading_term(x, cdir=1) == pi - asin(2)
+    assert asin(-I*x + 2).as_leading_term(x, cdir=1) == asin(2)
+    assert asin(I*x - 2).as_leading_term(x, cdir=1) == -asin(2)
+    assert asin(-I*x - 2).as_leading_term(x, cdir=1) == -pi + asin(2)
+    # Tests concerning im(ndir) == 0
+    assert asin(-I*x**2 + x - 2).as_leading_term(x, cdir=1) == -pi/2 + I*log(2 - sqrt(3))
+    assert asin(-I*x**2 + x - 2).as_leading_term(x, cdir=-1) == -pi/2 + I*log(2 - sqrt(3))
+
+
+def test_asin_rewrite():
+    assert asin(x).rewrite(log) == -I*log(I*x + sqrt(1 - x**2))
+    assert asin(x).rewrite(atan) == 2*atan(x/(1 + sqrt(1 - x**2)))
+    assert asin(x).rewrite(acos) == S.Pi/2 - acos(x)
+    assert asin(x).rewrite(acot) == 2*acot((sqrt(-x**2 + 1) + 1)/x)
+    assert asin(x).rewrite(asec) == -asec(1/x) + pi/2
+    assert asin(x).rewrite(acsc) == acsc(1/x)
+
+
+def test_asin_fdiff():
+    assert asin(x).fdiff() == 1/sqrt(1 - x**2)
+    raises(ArgumentIndexError, lambda: asin(x).fdiff(2))
+
+
+def test_acos():
+    assert acos(nan) is nan
+    assert acos(zoo) is zoo
+
+    assert acos.nargs == FiniteSet(1)
+    assert acos(oo) == I*oo
+    assert acos(-oo) == -I*oo
+
+    # Note: acos(-x) = pi - acos(x)
+    assert acos(0) == pi/2
+    assert acos(S.Half) == pi/3
+    assert acos(Rational(-1, 2)) == pi*Rational(2, 3)
+    assert acos(1) == 0
+    assert acos(-1) == pi
+    assert acos(sqrt(2)/2) == pi/4
+    assert acos(-sqrt(2)/2) == pi*Rational(3, 4)
+
+    # check round-trip for exact values:
+    for d in [5, 6, 8, 10, 12]:
+        for num in range(d):
+            if gcd(num, d) == 1:
+                assert acos(cos(num*pi/d)) == num*pi/d
+
+    assert acos(2*I) == pi/2 - asin(2*I)
+
+    assert acos(x).diff(x) == -1/sqrt(1 - x**2)
+
+    assert acos(0.2).is_real is True
+    assert acos(-2).is_real is False
+    assert acos(r).is_real is None
+
+    assert acos(Rational(1, 7), evaluate=False).is_positive is True
+    assert acos(Rational(-1, 7), evaluate=False).is_positive is True
+    assert acos(Rational(3, 2), evaluate=False).is_positive is False
+    assert acos(p).is_positive is None
+
+    assert acos(2 + p).conjugate() != acos(10 + p)
+    assert acos(-3 + n).conjugate() != acos(-3 + n)
+    assert acos(Rational(1, 3)).conjugate() == acos(Rational(1, 3))
+    assert acos(Rational(-1, 3)).conjugate() == acos(Rational(-1, 3))
+    assert acos(p + n*I).conjugate() == acos(p - n*I)
+    assert acos(z).conjugate() != acos(conjugate(z))
+
+
+def test_acos_leading_term():
+    assert acos(x).as_leading_term(x) == pi/2
+    # Tests concerning branch points
+    assert acos(x + 1).as_leading_term(x) == sqrt(2)*sqrt(-x)
+    assert acos(x - 1).as_leading_term(x) == pi
+    assert acos(1/x).as_leading_term(x, cdir=1) == -I*log(x) + I*log(2)
+    assert acos(1/x).as_leading_term(x, cdir=-1) == I*log(x) + 2*pi - I*log(2)
+    # Tests concerning points lying on branch cuts
+    assert acos(I*x + 2).as_leading_term(x, cdir=1) == -acos(2)
+    assert acos(-I*x + 2).as_leading_term(x, cdir=1) == acos(2)
+    assert acos(I*x - 2).as_leading_term(x, cdir=1) == acos(-2)
+    assert acos(-I*x - 2).as_leading_term(x, cdir=1) == 2*pi - acos(-2)
+    # Tests concerning im(ndir) == 0
+    assert acos(-I*x**2 + x - 2).as_leading_term(x, cdir=1) == pi + I*log(sqrt(3) + 2)
+    assert acos(-I*x**2 + x - 2).as_leading_term(x, cdir=-1) == pi + I*log(sqrt(3) + 2)
+
+
+def test_acos_series():
+    assert acos(x).series(x, 0, 8) == \
+        pi/2 - x - x**3/6 - 3*x**5/40 - 5*x**7/112 + O(x**8)
+    assert acos(x).series(x, 0, 8) == pi/2 - asin(x).series(x, 0, 8)
+    t5 = acos(x).taylor_term(5, x)
+    assert t5 == -3*x**5/40
+    assert acos(x).taylor_term(7, x, t5, 0) == -5*x**7/112
+    assert acos(x).taylor_term(0, x) == pi/2
+    assert acos(x).taylor_term(2, x) is S.Zero
+
+
+def test_acos_rewrite():
+    assert acos(x).rewrite(log) == pi/2 + I*log(I*x + sqrt(1 - x**2))
+    assert acos(x).rewrite(atan) == pi*(-x*sqrt(x**(-2)) + 1)/2 + atan(sqrt(1 - x**2)/x)
+    assert acos(0).rewrite(atan) == S.Pi/2
+    assert acos(0.5).rewrite(atan) == acos(0.5).rewrite(log)
+    assert acos(x).rewrite(asin) == S.Pi/2 - asin(x)
+    assert acos(x).rewrite(acot) == -2*acot((sqrt(-x**2 + 1) + 1)/x) + pi/2
+    assert acos(x).rewrite(asec) == asec(1/x)
+    assert acos(x).rewrite(acsc) == -acsc(1/x) + pi/2
+
+
+def test_acos_fdiff():
+    assert acos(x).fdiff() == -1/sqrt(1 - x**2)
+    raises(ArgumentIndexError, lambda: acos(x).fdiff(2))
+
+
+def test_atan():
+    assert atan(nan) is nan
+
+    assert atan.nargs == FiniteSet(1)
+    assert atan(oo) == pi/2
+    assert atan(-oo) == -pi/2
+    assert atan(zoo) == AccumBounds(-pi/2, pi/2)
+
+    assert atan(0) == 0
+    assert atan(1) == pi/4
+    assert atan(sqrt(3)) == pi/3
+    assert atan(-(1 + sqrt(2))) == pi*Rational(-3, 8)
+    assert atan(sqrt(5 - 2 * sqrt(5))) == pi/5
+    assert atan(-sqrt(1 - 2 * sqrt(5)/ 5)) == -pi/10
+    assert atan(sqrt(1 + 2 * sqrt(5) / 5)) == pi*Rational(3, 10)
+    assert atan(-2 + sqrt(3)) == -pi/12
+    assert atan(2 + sqrt(3)) == pi*Rational(5, 12)
+    assert atan(-2 - sqrt(3)) == pi*Rational(-5, 12)
+
+    # check round-trip for exact values:
+    for d in [5, 6, 8, 10, 12]:
+        for num in range(-(d//2), d//2 + 1):
+            if gcd(num, d) == 1:
+                assert atan(tan(num*pi/d)) == num*pi/d
+
+    assert atan(oo) == pi/2
+    assert atan(x).diff(x) == 1/(1 + x**2)
+
+    assert atan(r).is_real is True
+
+    assert atan(-2*I) == -I*atanh(2)
+    assert unchanged(atan, cot(x))
+    assert atan(cot(Rational(1, 4))) == Rational(-1, 4) + pi/2
+    assert acot(Rational(1, 4)).is_rational is False
+
+    for s in (x, p, n, np, nn, nz, ep, en, enp, enn, enz):
+        if s.is_real or s.is_extended_real is None:
+            assert s.is_nonzero is atan(s).is_nonzero
+            assert s.is_positive is atan(s).is_positive
+            assert s.is_negative is atan(s).is_negative
+            assert s.is_nonpositive is atan(s).is_nonpositive
+            assert s.is_nonnegative is atan(s).is_nonnegative
+        else:
+            assert s.is_extended_nonzero is atan(s).is_nonzero
+            assert s.is_extended_positive is atan(s).is_positive
+            assert s.is_extended_negative is atan(s).is_negative
+            assert s.is_extended_nonpositive is atan(s).is_nonpositive
+            assert s.is_extended_nonnegative is atan(s).is_nonnegative
+        assert s.is_extended_nonzero is atan(s).is_extended_nonzero
+        assert s.is_extended_positive is atan(s).is_extended_positive
+        assert s.is_extended_negative is atan(s).is_extended_negative
+        assert s.is_extended_nonpositive is atan(s).is_extended_nonpositive
+        assert s.is_extended_nonnegative is atan(s).is_extended_nonnegative
+
+
+def test_atan_rewrite():
+    assert atan(x).rewrite(log) == I*(log(1 - I*x)-log(1 + I*x))/2
+    assert atan(x).rewrite(asin) == (-asin(1/sqrt(x**2 + 1)) + pi/2)*sqrt(x**2)/x
+    assert atan(x).rewrite(acos) == sqrt(x**2)*acos(1/sqrt(x**2 + 1))/x
+    assert atan(x).rewrite(acot) == acot(1/x)
+    assert atan(x).rewrite(asec) == sqrt(x**2)*asec(sqrt(x**2 + 1))/x
+    assert atan(x).rewrite(acsc) == (-acsc(sqrt(x**2 + 1)) + pi/2)*sqrt(x**2)/x
+
+    assert atan(-5*I).evalf() == atan(x).rewrite(log).evalf(subs={x:-5*I})
+    assert atan(5*I).evalf() == atan(x).rewrite(log).evalf(subs={x:5*I})
+
+
+def test_atan_fdiff():
+    assert atan(x).fdiff() == 1/(x**2 + 1)
+    raises(ArgumentIndexError, lambda: atan(x).fdiff(2))
+
+
+def test_atan_leading_term():
+    assert atan(x).as_leading_term(x) == x
+    assert atan(1/x).as_leading_term(x, cdir=1) == pi/2
+    assert atan(1/x).as_leading_term(x, cdir=-1) == -pi/2
+    # Tests concerning branch points
+    assert atan(x + I).as_leading_term(x, cdir=1) == -I*log(x)/2 + pi/4 + I*log(2)/2
+    assert atan(x + I).as_leading_term(x, cdir=-1) == -I*log(x)/2 - 3*pi/4 + I*log(2)/2
+    assert atan(x - I).as_leading_term(x, cdir=1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    assert atan(x - I).as_leading_term(x, cdir=-1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    # Tests concerning points lying on branch cuts
+    assert atan(x + 2*I).as_leading_term(x, cdir=1) == I*atanh(2)
+    assert atan(x + 2*I).as_leading_term(x, cdir=-1) == -pi + I*atanh(2)
+    assert atan(x - 2*I).as_leading_term(x, cdir=1) == pi - I*atanh(2)
+    assert atan(x - 2*I).as_leading_term(x, cdir=-1) == -I*atanh(2)
+    # Tests concerning re(ndir) == 0
+    assert atan(2*I - I*x - x**2).as_leading_term(x, cdir=1) == -pi/2 + I*log(3)/2
+    assert atan(2*I - I*x - x**2).as_leading_term(x, cdir=-1) == -pi/2 + I*log(3)/2
+
+
+def test_atan2():
+    assert atan2.nargs == FiniteSet(2)
+    assert atan2(0, 0) is S.NaN
+    assert atan2(0, 1) == 0
+    assert atan2(1, 1) == pi/4
+    assert atan2(1, 0) == pi/2
+    assert atan2(1, -1) == pi*Rational(3, 4)
+    assert atan2(0, -1) == pi
+    assert atan2(-1, -1) == pi*Rational(-3, 4)
+    assert atan2(-1, 0) == -pi/2
+    assert atan2(-1, 1) == -pi/4
+    i = symbols('i', imaginary=True)
+    r = symbols('r', real=True)
+    eq = atan2(r, i)
+    ans = -I*log((i + I*r)/sqrt(i**2 + r**2))
+    reps = ((r, 2), (i, I))
+    assert eq.subs(reps) == ans.subs(reps)
+
+    x = Symbol('x', negative=True)
+    y = Symbol('y', negative=True)
+    assert atan2(y, x) == atan(y/x) - pi
+    y = Symbol('y', nonnegative=True)
+    assert atan2(y, x) == atan(y/x) + pi
+    y = Symbol('y')
+    assert atan2(y, x) == atan2(y, x, evaluate=False)
+
+    u = Symbol("u", positive=True)
+    assert atan2(0, u) == 0
+    u = Symbol("u", negative=True)
+    assert atan2(0, u) == pi
+
+    assert atan2(y, oo) ==  0
+    assert atan2(y, -oo)==  2*pi*Heaviside(re(y), S.Half) - pi
+
+    assert atan2(y, x).rewrite(log) == -I*log((x + I*y)/sqrt(x**2 + y**2))
+    assert atan2(0, 0) is S.NaN
+
+    ex = atan2(y, x) - arg(x + I*y)
+    assert ex.subs({x:2, y:3}).rewrite(arg) == 0
+    assert ex.subs({x:2, y:3*I}).rewrite(arg) == -pi - I*log(sqrt(5)*I/5)
+    assert ex.subs({x:2*I, y:3}).rewrite(arg) == -pi/2 - I*log(sqrt(5)*I)
+    assert ex.subs({x:2*I, y:3*I}).rewrite(arg) == -pi + atan(Rational(2, 3)) + atan(Rational(3, 2))
+    i = symbols('i', imaginary=True)
+    r = symbols('r', real=True)
+    e = atan2(i, r)
+    rewrite = e.rewrite(arg)
+    reps = {i: I, r: -2}
+    assert rewrite == -I*log(abs(I*i + r)/sqrt(abs(i**2 + r**2))) + arg((I*i + r)/sqrt(i**2 + r**2))
+    assert (e - rewrite).subs(reps).equals(0)
+
+    assert atan2(0, x).rewrite(atan) == Piecewise((pi, re(x) < 0),
+                                            (0, Ne(x, 0)),
+                                            (nan, True))
+    assert atan2(0, r).rewrite(atan) == Piecewise((pi, r < 0), (0, Ne(r, 0)), (S.NaN, True))
+    assert atan2(0, i),rewrite(atan) == 0
+    assert atan2(0, r + i).rewrite(atan) == Piecewise((pi, r < 0), (0, True))
+
+    assert atan2(y, x).rewrite(atan) == Piecewise(
+            (2*atan(y/(x + sqrt(x**2 + y**2))), Ne(y, 0)),
+            (pi, re(x) < 0),
+            (0, (re(x) > 0) | Ne(im(x), 0)),
+            (nan, True))
+    assert conjugate(atan2(x, y)) == atan2(conjugate(x), conjugate(y))
+
+    assert diff(atan2(y, x), x) == -y/(x**2 + y**2)
+    assert diff(atan2(y, x), y) == x/(x**2 + y**2)
+
+    assert simplify(diff(atan2(y, x).rewrite(log), x)) == -y/(x**2 + y**2)
+    assert simplify(diff(atan2(y, x).rewrite(log), y)) ==  x/(x**2 + y**2)
+
+    assert str(atan2(1, 2).evalf(5)) == '0.46365'
+    raises(ArgumentIndexError, lambda: atan2(x, y).fdiff(3))
+
+def test_issue_17461():
+    class A(Symbol):
+        is_extended_real = True
+
+        def _eval_evalf(self, prec):
+            return Float(5.0)
+
+    x = A('X')
+    y = A('Y')
+    assert abs(atan2(x, y).evalf() - 0.785398163397448) <= 1e-10
+
+def test_acot():
+    assert acot(nan) is nan
+
+    assert acot.nargs == FiniteSet(1)
+    assert acot(-oo) == 0
+    assert acot(oo) == 0
+    assert acot(zoo) == 0
+    assert acot(1) == pi/4
+    assert acot(0) == pi/2
+    assert acot(sqrt(3)/3) == pi/3
+    assert acot(1/sqrt(3)) == pi/3
+    assert acot(-1/sqrt(3)) == -pi/3
+    assert acot(x).diff(x) == -1/(1 + x**2)
+
+    assert acot(r).is_extended_real is True
+
+    assert acot(I*pi) == -I*acoth(pi)
+    assert acot(-2*I) == I*acoth(2)
+    assert acot(x).is_positive is None
+    assert acot(n).is_positive is False
+    assert acot(p).is_positive is True
+    assert acot(I).is_positive is False
+    assert acot(Rational(1, 4)).is_rational is False
+    assert unchanged(acot, cot(x))
+    assert unchanged(acot, tan(x))
+    assert acot(cot(Rational(1, 4))) == Rational(1, 4)
+    assert acot(tan(Rational(-1, 4))) == Rational(1, 4) - pi/2
+
+
+def test_acot_rewrite():
+    assert acot(x).rewrite(log) == I*(log(1 - I/x)-log(1 + I/x))/2
+    assert acot(x).rewrite(asin) == x*(-asin(sqrt(-x**2)/sqrt(-x**2 - 1)) + pi/2)*sqrt(x**(-2))
+    assert acot(x).rewrite(acos) == x*sqrt(x**(-2))*acos(sqrt(-x**2)/sqrt(-x**2 - 1))
+    assert acot(x).rewrite(atan) == atan(1/x)
+    assert acot(x).rewrite(asec) == x*sqrt(x**(-2))*asec(sqrt((x**2 + 1)/x**2))
+    assert acot(x).rewrite(acsc) == x*(-acsc(sqrt((x**2 + 1)/x**2)) + pi/2)*sqrt(x**(-2))
+
+    assert acot(-I/5).evalf() == acot(x).rewrite(log).evalf(subs={x:-I/5})
+    assert acot(I/5).evalf() == acot(x).rewrite(log).evalf(subs={x:I/5})
+
+
+def test_acot_fdiff():
+    assert acot(x).fdiff() == -1/(x**2 + 1)
+    raises(ArgumentIndexError, lambda: acot(x).fdiff(2))
+
+def test_acot_leading_term():
+    assert acot(1/x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert acot(x + I).as_leading_term(x, cdir=1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    assert acot(x + I).as_leading_term(x, cdir=-1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    assert acot(x - I).as_leading_term(x, cdir=1) == -I*log(x)/2 + pi/4 + I*log(2)/2
+    assert acot(x - I).as_leading_term(x, cdir=-1) == -I*log(x)/2 - 3*pi/4 + I*log(2)/2
+    # Tests concerning points lying on branch cuts
+    assert acot(x).as_leading_term(x, cdir=1) == pi/2
+    assert acot(x).as_leading_term(x, cdir=-1) == -pi/2
+    assert acot(x + I/2).as_leading_term(x, cdir=1) == pi - I*acoth(S(1)/2)
+    assert acot(x + I/2).as_leading_term(x, cdir=-1) == -I*acoth(S(1)/2)
+    assert acot(x - I/2).as_leading_term(x, cdir=1) == I*acoth(S(1)/2)
+    assert acot(x - I/2).as_leading_term(x, cdir=-1) == -pi + I*acoth(S(1)/2)
+    # Tests concerning re(ndir) == 0
+    assert acot(I/2 - I*x - x**2).as_leading_term(x, cdir=1) == -pi/2 - I*log(3)/2
+    assert acot(I/2 - I*x - x**2).as_leading_term(x, cdir=-1) == -pi/2 - I*log(3)/2
+
+
+def test_attributes():
+    assert sin(x).args == (x,)
+
+
+def test_sincos_rewrite():
+    assert sin(pi/2 - x) == cos(x)
+    assert sin(pi - x) == sin(x)
+    assert cos(pi/2 - x) == sin(x)
+    assert cos(pi - x) == -cos(x)
+
+
+def _check_even_rewrite(func, arg):
+    """Checks that the expr has been rewritten using f(-x) -> f(x)
+    arg : -x
+    """
+    return func(arg).args[0] == -arg
+
+
+def _check_odd_rewrite(func, arg):
+    """Checks that the expr has been rewritten using f(-x) -> -f(x)
+    arg : -x
+    """
+    return func(arg).func.is_Mul
+
+
+def _check_no_rewrite(func, arg):
+    """Checks that the expr is not rewritten"""
+    return func(arg).args[0] == arg
+
+
+def test_evenodd_rewrite():
+    a = cos(2)  # negative
+    b = sin(1)  # positive
+    even = [cos]
+    odd = [sin, tan, cot, asin, atan, acot]
+    with_minus = [-1, -2**1024 * E, -pi/105, -x*y, -x - y]
+    for func in even:
+        for expr in with_minus:
+            assert _check_even_rewrite(func, expr)
+        assert _check_no_rewrite(func, a*b)
+        assert func(
+            x - y) == func(y - x)  # it doesn't matter which form is canonical
+    for func in odd:
+        for expr in with_minus:
+            assert _check_odd_rewrite(func, expr)
+        assert _check_no_rewrite(func, a*b)
+        assert func(
+            x - y) == -func(y - x)  # it doesn't matter which form is canonical
+
+
+def test_as_leading_term_issue_5272():
+    assert sin(x).as_leading_term(x) == x
+    assert cos(x).as_leading_term(x) == 1
+    assert tan(x).as_leading_term(x) == x
+    assert cot(x).as_leading_term(x) == 1/x
+
+
+def test_leading_terms():
+    assert sin(1/x).as_leading_term(x) == AccumBounds(-1, 1)
+    assert sin(S.Half).as_leading_term(x) == sin(S.Half)
+    assert cos(1/x).as_leading_term(x) == AccumBounds(-1, 1)
+    assert cos(S.Half).as_leading_term(x) == cos(S.Half)
+    assert sec(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert csc(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert tan(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert cot(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+
+    # https://github.com/sympy/sympy/issues/21038
+    f = sin(pi*(x + 4))/(3*x)
+    assert f.as_leading_term(x) == pi/3
+
+
+def test_atan2_expansion():
+    assert cancel(atan2(x**2, x + 1).diff(x) - atan(x**2/(x + 1)).diff(x)) == 0
+    assert cancel(atan(y/x).series(y, 0, 5) - atan2(y, x).series(y, 0, 5)
+                  + atan2(0, x) - atan(0)) == O(y**5)
+    assert cancel(atan(y/x).series(x, 1, 4) - atan2(y, x).series(x, 1, 4)
+                  + atan2(y, 1) - atan(y)) == O((x - 1)**4, (x, 1))
+    assert cancel(atan((y + x)/x).series(x, 1, 3) - atan2(y + x, x).series(x, 1, 3)
+                  + atan2(1 + y, 1) - atan(1 + y)) == O((x - 1)**3, (x, 1))
+    assert Matrix([atan2(y, x)]).jacobian([y, x]) == \
+        Matrix([[x/(y**2 + x**2), -y/(y**2 + x**2)]])
+
+
+def test_aseries():
+    def t(n, v, d, e):
+        assert abs(
+            n(1/v).evalf() - n(1/x).series(x, dir=d).removeO().subs(x, v)) < e
+    t(atan, 0.1, '+', 1e-5)
+    t(atan, -0.1, '-', 1e-5)
+    t(acot, 0.1, '+', 1e-5)
+    t(acot, -0.1, '-', 1e-5)
+
+
+def test_issue_4420():
+    i = Symbol('i', integer=True)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+
+    # unknown parity for variable
+    assert cos(4*i*pi) == 1
+    assert sin(4*i*pi) == 0
+    assert tan(4*i*pi) == 0
+    assert cot(4*i*pi) is zoo
+
+    assert cos(3*i*pi) == cos(pi*i)  # +/-1
+    assert sin(3*i*pi) == 0
+    assert tan(3*i*pi) == 0
+    assert cot(3*i*pi) is zoo
+
+    assert cos(4.0*i*pi) == 1
+    assert sin(4.0*i*pi) == 0
+    assert tan(4.0*i*pi) == 0
+    assert cot(4.0*i*pi) is zoo
+
+    assert cos(3.0*i*pi) == cos(pi*i)  # +/-1
+    assert sin(3.0*i*pi) == 0
+    assert tan(3.0*i*pi) == 0
+    assert cot(3.0*i*pi) is zoo
+
+    assert cos(4.5*i*pi) == cos(0.5*pi*i)
+    assert sin(4.5*i*pi) == sin(0.5*pi*i)
+    assert tan(4.5*i*pi) == tan(0.5*pi*i)
+    assert cot(4.5*i*pi) == cot(0.5*pi*i)
+
+    # parity of variable is known
+    assert cos(4*e*pi) == 1
+    assert sin(4*e*pi) == 0
+    assert tan(4*e*pi) == 0
+    assert cot(4*e*pi) is zoo
+
+    assert cos(3*e*pi) == 1
+    assert sin(3*e*pi) == 0
+    assert tan(3*e*pi) == 0
+    assert cot(3*e*pi) is zoo
+
+    assert cos(4.0*e*pi) == 1
+    assert sin(4.0*e*pi) == 0
+    assert tan(4.0*e*pi) == 0
+    assert cot(4.0*e*pi) is zoo
+
+    assert cos(3.0*e*pi) == 1
+    assert sin(3.0*e*pi) == 0
+    assert tan(3.0*e*pi) == 0
+    assert cot(3.0*e*pi) is zoo
+
+    assert cos(4.5*e*pi) == cos(0.5*pi*e)
+    assert sin(4.5*e*pi) == sin(0.5*pi*e)
+    assert tan(4.5*e*pi) == tan(0.5*pi*e)
+    assert cot(4.5*e*pi) == cot(0.5*pi*e)
+
+    assert cos(4*o*pi) == 1
+    assert sin(4*o*pi) == 0
+    assert tan(4*o*pi) == 0
+    assert cot(4*o*pi) is zoo
+
+    assert cos(3*o*pi) == -1
+    assert sin(3*o*pi) == 0
+    assert tan(3*o*pi) == 0
+    assert cot(3*o*pi) is zoo
+
+    assert cos(4.0*o*pi) == 1
+    assert sin(4.0*o*pi) == 0
+    assert tan(4.0*o*pi) == 0
+    assert cot(4.0*o*pi) is zoo
+
+    assert cos(3.0*o*pi) == -1
+    assert sin(3.0*o*pi) == 0
+    assert tan(3.0*o*pi) == 0
+    assert cot(3.0*o*pi) is zoo
+
+    assert cos(4.5*o*pi) == cos(0.5*pi*o)
+    assert sin(4.5*o*pi) == sin(0.5*pi*o)
+    assert tan(4.5*o*pi) == tan(0.5*pi*o)
+    assert cot(4.5*o*pi) == cot(0.5*pi*o)
+
+    # x could be imaginary
+    assert cos(4*x*pi) == cos(4*pi*x)
+    assert sin(4*x*pi) == sin(4*pi*x)
+    assert tan(4*x*pi) == tan(4*pi*x)
+    assert cot(4*x*pi) == cot(4*pi*x)
+
+    assert cos(3*x*pi) == cos(3*pi*x)
+    assert sin(3*x*pi) == sin(3*pi*x)
+    assert tan(3*x*pi) == tan(3*pi*x)
+    assert cot(3*x*pi) == cot(3*pi*x)
+
+    assert cos(4.0*x*pi) == cos(4.0*pi*x)
+    assert sin(4.0*x*pi) == sin(4.0*pi*x)
+    assert tan(4.0*x*pi) == tan(4.0*pi*x)
+    assert cot(4.0*x*pi) == cot(4.0*pi*x)
+
+    assert cos(3.0*x*pi) == cos(3.0*pi*x)
+    assert sin(3.0*x*pi) == sin(3.0*pi*x)
+    assert tan(3.0*x*pi) == tan(3.0*pi*x)
+    assert cot(3.0*x*pi) == cot(3.0*pi*x)
+
+    assert cos(4.5*x*pi) == cos(4.5*pi*x)
+    assert sin(4.5*x*pi) == sin(4.5*pi*x)
+    assert tan(4.5*x*pi) == tan(4.5*pi*x)
+    assert cot(4.5*x*pi) == cot(4.5*pi*x)
+
+
+def test_inverses():
+    raises(AttributeError, lambda: sin(x).inverse())
+    raises(AttributeError, lambda: cos(x).inverse())
+    assert tan(x).inverse() == atan
+    assert cot(x).inverse() == acot
+    raises(AttributeError, lambda: csc(x).inverse())
+    raises(AttributeError, lambda: sec(x).inverse())
+    assert asin(x).inverse() == sin
+    assert acos(x).inverse() == cos
+    assert atan(x).inverse() == tan
+    assert acot(x).inverse() == cot
+
+
+def test_real_imag():
+    a, b = symbols('a b', real=True)
+    z = a + b*I
+    for deep in [True, False]:
+        assert sin(
+            z).as_real_imag(deep=deep) == (sin(a)*cosh(b), cos(a)*sinh(b))
+        assert cos(
+            z).as_real_imag(deep=deep) == (cos(a)*cosh(b), -sin(a)*sinh(b))
+        assert tan(z).as_real_imag(deep=deep) == (sin(2*a)/(cos(2*a) +
+            cosh(2*b)), sinh(2*b)/(cos(2*a) + cosh(2*b)))
+        assert cot(z).as_real_imag(deep=deep) == (-sin(2*a)/(cos(2*a) -
+            cosh(2*b)), sinh(2*b)/(cos(2*a) - cosh(2*b)))
+        assert sin(a).as_real_imag(deep=deep) == (sin(a), 0)
+        assert cos(a).as_real_imag(deep=deep) == (cos(a), 0)
+        assert tan(a).as_real_imag(deep=deep) == (tan(a), 0)
+        assert cot(a).as_real_imag(deep=deep) == (cot(a), 0)
+
+
+@XFAIL
+def test_sin_cos_with_infinity():
+    # Test for issue 5196
+    # https://github.com/sympy/sympy/issues/5196
+    assert sin(oo) is S.NaN
+    assert cos(oo) is S.NaN
+
+
+@slow
+def test_sincos_rewrite_sqrt():
+    # equivalent to testing rewrite(pow)
+    for p in [1, 3, 5, 17]:
+        for t in [1, 8]:
+            n = t*p
+            # The vertices `exp(i*pi/n)` of a regular `n`-gon can
+            # be expressed by means of nested square roots if and
+            # only if `n` is a product of Fermat primes, `p`, and
+            # powers of 2, `t'. The code aims to check all vertices
+            # not belonging to an `m`-gon for `m < n`(`gcd(i, n) == 1`).
+            # For large `n` this makes the test too slow, therefore
+            # the vertices are limited to those of index `i < 10`.
+            for i in range(1, min((n + 1)//2 + 1, 10)):
+                if 1 == gcd(i, n):
+                    x = i*pi/n
+                    s1 = sin(x).rewrite(sqrt)
+                    c1 = cos(x).rewrite(sqrt)
+                    assert not s1.has(cos, sin), "fails for %d*pi/%d" % (i, n)
+                    assert not c1.has(cos, sin), "fails for %d*pi/%d" % (i, n)
+                    assert 1e-3 > abs(sin(x.evalf(5)) - s1.evalf(2)), "fails for %d*pi/%d" % (i, n)
+                    assert 1e-3 > abs(cos(x.evalf(5)) - c1.evalf(2)), "fails for %d*pi/%d" % (i, n)
+    assert cos(pi/14).rewrite(sqrt) == sqrt(cos(pi/7)/2 + S.Half)
+    assert cos(pi*Rational(-15, 2)/11, evaluate=False).rewrite(
+        sqrt) == -sqrt(-cos(pi*Rational(4, 11))/2 + S.Half)
+    assert cos(Mul(2, pi, S.Half, evaluate=False), evaluate=False).rewrite(
+        sqrt) == -1
+    e = cos(pi/3/17)  # don't use pi/15 since that is caught at instantiation
+    a = (
+        -3*sqrt(-sqrt(17) + 17)*sqrt(sqrt(17) + 17)/64 -
+        3*sqrt(34)*sqrt(sqrt(17) + 17)/128 - sqrt(sqrt(17) +
+        17)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) + 17)
+        + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 - sqrt(-sqrt(17)
+        + 17)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/128 - Rational(1, 32) +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 +
+        3*sqrt(2)*sqrt(sqrt(17) + 17)/128 + sqrt(34)*sqrt(-sqrt(17) + 17)/128
+        + 13*sqrt(2)*sqrt(-sqrt(17) + 17)/128 + sqrt(17)*sqrt(-sqrt(17) +
+        17)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) + 17)
+        + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/128 + 5*sqrt(17)/32
+        + sqrt(3)*sqrt(-sqrt(2)*sqrt(sqrt(17) + 17)*sqrt(sqrt(17)/32 +
+        sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 + Rational(15, 32))/8 -
+        5*sqrt(2)*sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 +
+        Rational(15, 32))*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 -
+        3*sqrt(2)*sqrt(-sqrt(17) + 17)*sqrt(sqrt(17)/32 +
+        sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 + Rational(15, 32))/32
+        + sqrt(34)*sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 +
+        Rational(15, 32))*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 +
+        sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 + Rational(15, 32))/2 +
+        S.Half + sqrt(-sqrt(17) + 17)*sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) +
+        17)/32 + sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) -
+        sqrt(2)*sqrt(-sqrt(17) + 17) + sqrt(34)*sqrt(-sqrt(17) + 17) +
+        6*sqrt(17) + 34)/32 + Rational(15, 32))*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) -
+        sqrt(2)*sqrt(-sqrt(17) + 17) + sqrt(34)*sqrt(-sqrt(17) + 17) +
+        6*sqrt(17) + 34)/32 + sqrt(34)*sqrt(-sqrt(17) + 17)*sqrt(sqrt(17)/32 +
+        sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 +
+        Rational(15, 32))/32)/2)
+    assert e.rewrite(sqrt) == a
+    assert e.n() == a.n()
+    # coverage of fermatCoords: multiplicity > 1; the following could be
+    # different but that portion of the code should be tested in some way
+    assert cos(pi/9/17).rewrite(sqrt) == \
+        sin(pi/9)*sin(pi*Rational(2, 17)) + cos(pi/9)*cos(pi*Rational(2, 17))
+
+
+@slow
+def test_sincos_rewrite_sqrt_257():
+    assert cos(pi/257).rewrite(sqrt).evalf(64) == cos(pi/257).evalf(64)
+
+
+@slow
+def test_tancot_rewrite_sqrt():
+    # equivalent to testing rewrite(pow)
+    for p in [1, 3, 5, 17]:
+        for t in [1, 8]:
+            n = t*p
+            for i in range(1, min((n + 1)//2 + 1, 10)):
+                if 1 == gcd(i, n):
+                    x = i*pi/n
+                    if  2*i != n and 3*i != 2*n:
+                        t1 = tan(x).rewrite(sqrt)
+                        assert not t1.has(cot, tan), "fails for %d*pi/%d" % (i, n)
+                        assert 1e-3 > abs( tan(x.evalf(7)) - t1.evalf(4) ), "fails for %d*pi/%d" % (i, n)
+                    if  i != 0 and i != n:
+                        c1 = cot(x).rewrite(sqrt)
+                        assert not c1.has(cot, tan), "fails for %d*pi/%d" % (i, n)
+                        assert 1e-3 > abs( cot(x.evalf(7)) - c1.evalf(4) ), "fails for %d*pi/%d" % (i, n)
+
+
+def test_sec():
+    x = symbols('x', real=True)
+    z = symbols('z')
+
+    assert sec.nargs == FiniteSet(1)
+
+    assert sec(zoo) is nan
+    assert sec(0) == 1
+    assert sec(pi) == -1
+    assert sec(pi/2) is zoo
+    assert sec(-pi/2) is zoo
+    assert sec(pi/6) == 2*sqrt(3)/3
+    assert sec(pi/3) == 2
+    assert sec(pi*Rational(5, 2)) is zoo
+    assert sec(pi*Rational(9, 7)) == -sec(pi*Rational(2, 7))
+    assert sec(pi*Rational(3, 4)) == -sqrt(2)  # issue 8421
+    assert sec(I) == 1/cosh(1)
+    assert sec(x*I) == 1/cosh(x)
+    assert sec(-x) == sec(x)
+
+    assert sec(asec(x)) == x
+
+    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(x).is_extended_real == True
+    assert sec(z).is_real == None
+
+    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, evaluate=False).is_finite == True
+    assert sec(x).is_finite == None
+    assert sec(pi/2, evaluate=False).is_finite == 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 - pi*Rational(3, 2)) + (x - pi*Rational(3, 2))**Rational(3, 2)/12 +
+            (x - pi*Rational(3, 2))**Rational(7, 2)/160 + O((x - pi*Rational(3, 2))**4, (x, pi*Rational(3, 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
+
+
+def test_sec_rewrite():
+    assert sec(x).rewrite(exp) == 1/(exp(I*x)/2 + exp(-I*x)/2)
+    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(pow) == sec(x)
+    assert sec(x).rewrite(sqrt) == sec(x)
+    assert sec(z).rewrite(cot) == (cot(z/2)**2 + 1)/(cot(z/2)**2 - 1)
+    assert sec(x).rewrite(sin) == 1 / sin(x + pi / 2, evaluate=False)
+    assert sec(x).rewrite(tan) == (tan(x / 2)**2 + 1) / (-tan(x / 2)**2 + 1)
+    assert sec(x).rewrite(csc) == csc(-x + pi/2, evaluate=False)
+
+
+def test_sec_fdiff():
+    assert sec(x).fdiff() == tan(x)*sec(x)
+    raises(ArgumentIndexError, lambda: sec(x).fdiff(2))
+
+
+def test_csc():
+    x = symbols('x', real=True)
+    z = symbols('z')
+
+    # https://github.com/sympy/sympy/issues/6707
+    cosecant = csc('x')
+    alternate = 1/sin('x')
+    assert cosecant.equals(alternate) == True
+    assert alternate.equals(cosecant) == True
+
+    assert csc.nargs == FiniteSet(1)
+
+    assert csc(0) is zoo
+    assert csc(pi) is zoo
+    assert csc(zoo) is nan
+
+    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(pi*Rational(5, 2)) == 1
+    assert csc(pi*Rational(9, 7)) == -csc(pi*Rational(2, 7))
+    assert csc(pi*Rational(3, 4)) == sqrt(2)  # issue 8421
+    assert csc(I) == -I/sinh(1)
+    assert csc(x*I) == -I/sinh(x)
+    assert csc(-x) == -csc(x)
+
+    assert csc(acsc(x)) == x
+
+    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(x).is_extended_real == True
+    assert csc(z).is_real == None
+
+    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, evaluate=False).is_finite == False
+    assert csc(x).is_finite == None
+    assert csc(pi/2, evaluate=False).is_finite == True
+
+    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(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
+    raises(ArgumentIndexError, lambda: csc(x).fdiff(2))
+
+
+def test_asec():
+    z = Symbol('z', zero=True)
+    assert asec(z) is zoo
+    assert asec(nan) is nan
+    assert asec(1) == 0
+    assert asec(-1) == pi
+    assert asec(oo) == pi/2
+    assert asec(-oo) == pi/2
+    assert asec(zoo) == pi/2
+
+    assert asec(sec(pi*Rational(13, 4))) == pi*Rational(3, 4)
+    assert asec(1 + sqrt(5)) == pi*Rational(2, 5)
+    assert asec(2/sqrt(3)) == pi/6
+    assert asec(sqrt(4 - 2*sqrt(2))) == pi/8
+    assert asec(-sqrt(4 + 2*sqrt(2))) == pi*Rational(5, 8)
+    assert asec(sqrt(2 + 2*sqrt(5)/5)) == pi*Rational(3, 10)
+    assert asec(-sqrt(2 + 2*sqrt(5)/5)) == pi*Rational(7, 10)
+    assert asec(sqrt(2) - sqrt(6)) == pi*Rational(11, 12)
+
+    assert asec(x).diff(x) == 1/(x**2*sqrt(1 - 1/x**2))
+
+    assert asec(x).rewrite(log) == I*log(sqrt(1 - 1/x**2) + I/x) + pi/2
+    assert asec(x).rewrite(asin) == -asin(1/x) + pi/2
+    assert asec(x).rewrite(acos) == acos(1/x)
+    assert asec(x).rewrite(atan) == \
+        pi*(1 - sqrt(x**2)/x)/2 + sqrt(x**2)*atan(sqrt(x**2 - 1))/x
+    assert asec(x).rewrite(acot) == \
+        pi*(1 - sqrt(x**2)/x)/2 + sqrt(x**2)*acot(1/sqrt(x**2 - 1))/x
+    assert asec(x).rewrite(acsc) == -acsc(x) + pi/2
+    raises(ArgumentIndexError, lambda: asec(x).fdiff(2))
+
+
+def test_asec_is_real():
+    assert asec(S.Half).is_real is False
+    n = Symbol('n', positive=True, integer=True)
+    assert asec(n).is_extended_real is True
+    assert asec(x).is_real is None
+    assert asec(r).is_real is None
+    t = Symbol('t', real=False, finite=True)
+    assert asec(t).is_real is False
+
+
+def test_asec_leading_term():
+    assert asec(1/x).as_leading_term(x) == pi/2
+    # Tests concerning branch points
+    assert asec(x + 1).as_leading_term(x) == sqrt(2)*sqrt(x)
+    assert asec(x - 1).as_leading_term(x) == pi
+    # Tests concerning points lying on branch cuts
+    assert asec(x).as_leading_term(x, cdir=1) == -I*log(x) + I*log(2)
+    assert asec(x).as_leading_term(x, cdir=-1) == I*log(x) + 2*pi - I*log(2)
+    assert asec(I*x + 1/2).as_leading_term(x, cdir=1) == asec(1/2)
+    assert asec(-I*x + 1/2).as_leading_term(x, cdir=1) == -asec(1/2)
+    assert asec(I*x - 1/2).as_leading_term(x, cdir=1) == 2*pi - asec(-1/2)
+    assert asec(-I*x - 1/2).as_leading_term(x, cdir=1) == asec(-1/2)
+    # Tests concerning im(ndir) == 0
+    assert asec(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=1) == pi + I*log(2 - sqrt(3))
+    assert asec(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=-1) == pi + I*log(2 - sqrt(3))
+
+
+def test_asec_series():
+    assert asec(x).series(x, 0, 9) == \
+        I*log(2) - I*log(x) - I*x**2/4 - 3*I*x**4/32 \
+        - 5*I*x**6/96 - 35*I*x**8/1024 + O(x**9)
+    t4 = asec(x).taylor_term(4, x)
+    assert t4 == -3*I*x**4/32
+    assert asec(x).taylor_term(6, x, t4, 0) == -5*I*x**6/96
+
+
+def test_acsc():
+    assert acsc(nan) is nan
+    assert acsc(1) == pi/2
+    assert acsc(-1) == -pi/2
+    assert acsc(oo) == 0
+    assert acsc(-oo) == 0
+    assert acsc(zoo) == 0
+    assert acsc(0) is zoo
+
+    assert acsc(csc(3)) == -3 + pi
+    assert acsc(csc(4)) == -4 + pi
+    assert acsc(csc(6)) == 6 - 2*pi
+    assert unchanged(acsc, csc(x))
+    assert unchanged(acsc, sec(x))
+
+    assert acsc(2/sqrt(3)) == pi/3
+    assert acsc(csc(pi*Rational(13, 4))) == -pi/4
+    assert acsc(sqrt(2 + 2*sqrt(5)/5)) == pi/5
+    assert acsc(-sqrt(2 + 2*sqrt(5)/5)) == -pi/5
+    assert acsc(-2) == -pi/6
+    assert acsc(-sqrt(4 + 2*sqrt(2))) == -pi/8
+    assert acsc(sqrt(4 - 2*sqrt(2))) == pi*Rational(3, 8)
+    assert acsc(1 + sqrt(5)) == pi/10
+    assert acsc(sqrt(2) - sqrt(6)) == pi*Rational(-5, 12)
+
+    assert acsc(x).diff(x) == -1/(x**2*sqrt(1 - 1/x**2))
+
+    assert acsc(x).rewrite(log) == -I*log(sqrt(1 - 1/x**2) + I/x)
+    assert acsc(x).rewrite(asin) == asin(1/x)
+    assert acsc(x).rewrite(acos) == -acos(1/x) + pi/2
+    assert acsc(x).rewrite(atan) == \
+        (-atan(sqrt(x**2 - 1)) + pi/2)*sqrt(x**2)/x
+    assert acsc(x).rewrite(acot) == (-acot(1/sqrt(x**2 - 1)) + pi/2)*sqrt(x**2)/x
+    assert acsc(x).rewrite(asec) == -asec(x) + pi/2
+    raises(ArgumentIndexError, lambda: acsc(x).fdiff(2))
+
+
+def test_csc_rewrite():
+    assert csc(x).rewrite(pow) == csc(x)
+    assert csc(x).rewrite(sqrt) == csc(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(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(x).rewrite(cos) == 1/cos(x - pi/2, evaluate=False)
+    assert csc(x).rewrite(sec) == sec(-x + pi/2, evaluate=False)
+
+    # issue 17349
+    assert csc(1 - exp(-besselj(I, I))).rewrite(cos) == \
+           -1/cos(-pi/2 - 1 + cos(I*besselj(I, I)) +
+                  I*cos(-pi/2 + I*besselj(I, I), evaluate=False), evaluate=False)
+
+
+def test_acsc_leading_term():
+    assert acsc(1/x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert acsc(x + 1).as_leading_term(x) == pi/2
+    assert acsc(x - 1).as_leading_term(x) == -pi/2
+    # Tests concerning points lying on branch cuts
+    assert acsc(x).as_leading_term(x, cdir=1) == I*log(x) + pi/2 - I*log(2)
+    assert acsc(x).as_leading_term(x, cdir=-1) == -I*log(x) - 3*pi/2 + I*log(2)
+    assert acsc(I*x + 1/2).as_leading_term(x, cdir=1) == acsc(1/2)
+    assert acsc(-I*x + 1/2).as_leading_term(x, cdir=1) == pi - acsc(1/2)
+    assert acsc(I*x - 1/2).as_leading_term(x, cdir=1) == -pi - acsc(-1/2)
+    assert acsc(-I*x - 1/2).as_leading_term(x, cdir=1) == -acsc(1/2)
+    # Tests concerning im(ndir) == 0
+    assert acsc(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=1) == -pi/2 + I*log(sqrt(3) + 2)
+    assert acsc(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=-1) == -pi/2 + I*log(sqrt(3) + 2)
+
+
+def test_acsc_series():
+    assert acsc(x).series(x, 0, 9) == \
+        -I*log(2) + pi/2 + I*log(x) + I*x**2/4 \
+        + 3*I*x**4/32 + 5*I*x**6/96 + 35*I*x**8/1024 + O(x**9)
+    t6 = acsc(x).taylor_term(6, x)
+    assert t6 == 5*I*x**6/96
+    assert acsc(x).taylor_term(8, x, t6, 0) == 35*I*x**8/1024
+
+
+def test_asin_nseries():
+    assert asin(x + 2)._eval_nseries(x, 4, None, I) == -asin(2) + pi + \
+    sqrt(3)*I*x/3 - sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert asin(x + 2)._eval_nseries(x, 4, None, -I) == asin(2) - \
+    sqrt(3)*I*x/3 + sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert asin(x - 2)._eval_nseries(x, 4, None, I) == -asin(2) - \
+    sqrt(3)*I*x/3 - sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert asin(x - 2)._eval_nseries(x, 4, None, -I) == asin(2) - pi + \
+    sqrt(3)*I*x/3 + sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    # testing nseries for asin at branch points
+    assert asin(1 + x)._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(-x) - \
+    sqrt(2)*(-x)**(S(3)/2)/12 - 3*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert asin(-1 + x)._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(x) + \
+    sqrt(2)*x**(S(3)/2)/12 + 3*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert asin(exp(x))._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(-x) + \
+    sqrt(2)*(-x)**(S(3)/2)/6 - sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+    assert asin(-exp(x))._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(-x) - \
+    sqrt(2)*(-x)**(S(3)/2)/6 + sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+
+
+def test_acos_nseries():
+    assert acos(x + 2)._eval_nseries(x, 4, None, I) == -acos(2) - sqrt(3)*I*x/3 + \
+    sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert acos(x + 2)._eval_nseries(x, 4, None, -I) == acos(2) + sqrt(3)*I*x/3 - \
+    sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert acos(x - 2)._eval_nseries(x, 4, None, I) == acos(-2) + sqrt(3)*I*x/3 + \
+    sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert acos(x - 2)._eval_nseries(x, 4, None, -I) == -acos(-2) + 2*pi - \
+    sqrt(3)*I*x/3 - sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    # testing nseries for acos at branch points
+    assert acos(1 + x)._eval_nseries(x, 3, None) == sqrt(2)*sqrt(-x) + \
+    sqrt(2)*(-x)**(S(3)/2)/12 + 3*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert acos(-1 + x)._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(x) - \
+    sqrt(2)*x**(S(3)/2)/12 - 3*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert acos(exp(x))._eval_nseries(x, 3, None) == sqrt(2)*sqrt(-x) - \
+    sqrt(2)*(-x)**(S(3)/2)/6 + sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+    assert acos(-exp(x))._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(-x) + \
+    sqrt(2)*(-x)**(S(3)/2)/6 - sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+
+
+def test_atan_nseries():
+    assert atan(x + 2*I)._eval_nseries(x, 4, None, 1) == I*atanh(2) - x/3 - \
+    2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(x + 2*I)._eval_nseries(x, 4, None, -1) == I*atanh(2) - pi - \
+    x/3 - 2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(x - 2*I)._eval_nseries(x, 4, None, 1) == -I*atanh(2) + pi - \
+    x/3 + 2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(x - 2*I)._eval_nseries(x, 4, None, -1) == -I*atanh(2) - x/3 + \
+    2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(1/x)._eval_nseries(x, 2, None, 1) == pi/2 - x + O(x**2)
+    assert atan(1/x)._eval_nseries(x, 2, None, -1) == -pi/2 - x + O(x**2)
+    # testing nseries for atan at branch points
+    assert atan(x + I)._eval_nseries(x, 4, None) == I*log(2)/2 + pi/4 - \
+    I*log(x)/2 + x/4 + I*x**2/16 - x**3/48 + O(x**4)
+    assert atan(x - I)._eval_nseries(x, 4, None) == -I*log(2)/2 + pi/4 + \
+    I*log(x)/2 + x/4 - I*x**2/16 - x**3/48 + O(x**4)
+
+
+def test_acot_nseries():
+    assert acot(x + S(1)/2*I)._eval_nseries(x, 4, None, 1) == -I*acoth(S(1)/2) + \
+    pi - 4*x/3 + 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x + S(1)/2*I)._eval_nseries(x, 4, None, -1) == -I*acoth(S(1)/2) - \
+    4*x/3 + 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x - S(1)/2*I)._eval_nseries(x, 4, None, 1) == I*acoth(S(1)/2) - \
+    4*x/3 - 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x - S(1)/2*I)._eval_nseries(x, 4, None, -1) == I*acoth(S(1)/2) - \
+    pi - 4*x/3 - 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x)._eval_nseries(x, 2, None, 1) == pi/2 - x + O(x**2)
+    assert acot(x)._eval_nseries(x, 2, None, -1) == -pi/2 - x + O(x**2)
+    # testing nseries for acot at branch points
+    assert acot(x + I)._eval_nseries(x, 4, None) == -I*log(2)/2 + pi/4 + \
+    I*log(x)/2 - x/4 - I*x**2/16 + x**3/48 + O(x**4)
+    assert acot(x - I)._eval_nseries(x, 4, None) == I*log(2)/2 + pi/4 - \
+    I*log(x)/2 - x/4 + I*x**2/16 + x**3/48 + O(x**4)
+
+
+def test_asec_nseries():
+    assert asec(x + S(1)/2)._eval_nseries(x, 4, None, I) == asec(S(1)/2) - \
+    4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert asec(x + S(1)/2)._eval_nseries(x, 4, None, -I) == -asec(S(1)/2) + \
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert asec(x - S(1)/2)._eval_nseries(x, 4, None, I) == -asec(-S(1)/2) + \
+    2*pi + 4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert asec(x - S(1)/2)._eval_nseries(x, 4, None, -I) == asec(-S(1)/2) - \
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    # testing nseries for asec at branch points
+    assert asec(1 + x)._eval_nseries(x, 3, None) == sqrt(2)*sqrt(x) - \
+    5*sqrt(2)*x**(S(3)/2)/12 + 43*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert asec(-1 + x)._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(-x) + \
+    5*sqrt(2)*(-x)**(S(3)/2)/12 - 43*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert asec(exp(x))._eval_nseries(x, 3, None) == sqrt(2)*sqrt(x) - \
+    sqrt(2)*x**(S(3)/2)/6 + sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+    assert asec(-exp(x))._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(x) + \
+    sqrt(2)*x**(S(3)/2)/6 - sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+
+
+def test_acsc_nseries():
+    assert acsc(x + S(1)/2)._eval_nseries(x, 4, None, I) == acsc(S(1)/2) + \
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsc(x + S(1)/2)._eval_nseries(x, 4, None, -I) == -acsc(S(1)/2) + \
+    pi - 4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsc(x - S(1)/2)._eval_nseries(x, 4, None, I) == acsc(S(1)/2) - pi -\
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsc(x - S(1)/2)._eval_nseries(x, 4, None, -I) == -acsc(S(1)/2) + \
+    4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    # testing nseries for acsc at branch points
+    assert acsc(1 + x)._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(x) + \
+    5*sqrt(2)*x**(S(3)/2)/12 - 43*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert acsc(-1 + x)._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(-x) - \
+    5*sqrt(2)*(-x)**(S(3)/2)/12 + 43*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert acsc(exp(x))._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(x) + \
+    sqrt(2)*x**(S(3)/2)/6 - sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+    assert acsc(-exp(x))._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(x) - \
+    sqrt(2)*x**(S(3)/2)/6 + sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+
+
+def test_issue_8653():
+    n = Symbol('n', integer=True)
+    assert sin(n).is_irrational is None
+    assert cos(n).is_irrational is None
+    assert tan(n).is_irrational is None
+
+
+def test_issue_9157():
+    n = Symbol('n', integer=True, positive=True)
+    assert atan(n - 1).is_nonnegative is True
+
+
+def test_trig_period():
+    x, y = symbols('x, y')
+
+    assert sin(x).period() == 2*pi
+    assert cos(x).period() == 2*pi
+    assert tan(x).period() == pi
+    assert cot(x).period() == pi
+    assert sec(x).period() == 2*pi
+    assert csc(x).period() == 2*pi
+    assert sin(2*x).period() == pi
+    assert cot(4*x - 6).period() == pi/4
+    assert cos((-3)*x).period() == pi*Rational(2, 3)
+    assert cos(x*y).period(x) == 2*pi/abs(y)
+    assert sin(3*x*y + 2*pi).period(y) == 2*pi/abs(3*x)
+    assert tan(3*x).period(y) is S.Zero
+    raises(NotImplementedError, lambda: sin(x**2).period(x))
+
+
+def test_issue_7171():
+    assert sin(x).rewrite(sqrt) == sin(x)
+    assert sin(x).rewrite(pow) == sin(x)
+
+
+def test_issue_11864():
+    w, k = symbols('w, k', real=True)
+    F = Piecewise((1, Eq(2*pi*k, 0)), (sin(pi*k)/(pi*k), True))
+    soln = Piecewise((1, Eq(2*pi*k, 0)), (sinc(pi*k), True))
+    assert F.rewrite(sinc) == soln
+
+def test_real_assumptions():
+    z = Symbol('z', real=False, finite=True)
+    assert sin(z).is_real is None
+    assert cos(z).is_real is None
+    assert tan(z).is_real is False
+    assert sec(z).is_real is None
+    assert csc(z).is_real is None
+    assert cot(z).is_real is False
+    assert asin(p).is_real is None
+    assert asin(n).is_real is None
+    assert asec(p).is_real is None
+    assert asec(n).is_real is None
+    assert acos(p).is_real is None
+    assert acos(n).is_real is None
+    assert acsc(p).is_real is None
+    assert acsc(n).is_real is None
+    assert atan(p).is_positive is True
+    assert atan(n).is_negative is True
+    assert acot(p).is_positive is True
+    assert acot(n).is_negative is True
+
+def test_issue_14320():
+    assert asin(sin(2)) == -2 + pi and (-pi/2 <= -2 + pi <= pi/2) and sin(2) == sin(-2 + pi)
+    assert asin(cos(2)) == -2 + pi/2 and (-pi/2 <= -2 + pi/2 <= pi/2) and cos(2) == sin(-2 + pi/2)
+    assert acos(sin(2)) == -pi/2 + 2 and (0 <= -pi/2 + 2 <= pi) and sin(2) == cos(-pi/2 + 2)
+    assert acos(cos(20)) == -6*pi + 20 and (0 <= -6*pi + 20 <= pi) and cos(20) == cos(-6*pi + 20)
+    assert acos(cos(30)) == -30 + 10*pi and (0 <= -30 + 10*pi <= pi) and cos(30) == cos(-30 + 10*pi)
+
+    assert atan(tan(17)) == -5*pi + 17 and (-pi/2 < -5*pi + 17 < pi/2) and tan(17) == tan(-5*pi + 17)
+    assert atan(tan(15)) == -5*pi + 15 and (-pi/2 < -5*pi + 15 < pi/2) and tan(15) == tan(-5*pi + 15)
+    assert atan(cot(12)) == -12 + pi*Rational(7, 2) and (-pi/2 < -12 + pi*Rational(7, 2) < pi/2) and cot(12) == tan(-12 + pi*Rational(7, 2))
+    assert acot(cot(15)) == -5*pi + 15 and (-pi/2 < -5*pi + 15 <= pi/2) and cot(15) == cot(-5*pi + 15)
+    assert acot(tan(19)) == -19 + pi*Rational(13, 2) and (-pi/2 < -19 + pi*Rational(13, 2) <= pi/2) and tan(19) == cot(-19 + pi*Rational(13, 2))
+
+    assert asec(sec(11)) == -11 + 4*pi and (0 <= -11 + 4*pi <= pi) and cos(11) == cos(-11 + 4*pi)
+    assert asec(csc(13)) == -13 + pi*Rational(9, 2) and (0 <= -13 + pi*Rational(9, 2) <= pi) and sin(13) == cos(-13 + pi*Rational(9, 2))
+    assert acsc(csc(14)) == -4*pi + 14 and (-pi/2 <= -4*pi + 14 <= pi/2) and sin(14) == sin(-4*pi + 14)
+    assert acsc(sec(10)) == pi*Rational(-7, 2) + 10 and (-pi/2 <= pi*Rational(-7, 2) + 10 <= pi/2) and cos(10) == sin(pi*Rational(-7, 2) + 10)
+
+def test_issue_14543():
+    assert sec(2*pi + 11) == sec(11)
+    assert sec(2*pi - 11) == sec(11)
+    assert sec(pi + 11) == -sec(11)
+    assert sec(pi - 11) == -sec(11)
+
+    assert csc(2*pi + 17) == csc(17)
+    assert csc(2*pi - 17) == -csc(17)
+    assert csc(pi + 17) == -csc(17)
+    assert csc(pi - 17) == csc(17)
+
+    x = Symbol('x')
+    assert csc(pi/2 + x) == sec(x)
+    assert csc(pi/2 - x) == sec(x)
+    assert csc(pi*Rational(3, 2) + x) == -sec(x)
+    assert csc(pi*Rational(3, 2) - x) == -sec(x)
+
+    assert sec(pi/2 - x) == csc(x)
+    assert sec(pi/2 + x) == -csc(x)
+    assert sec(pi*Rational(3, 2) + x) == csc(x)
+    assert sec(pi*Rational(3, 2) - x) == -csc(x)
+
+
+def test_as_real_imag():
+    # This is for https://github.com/sympy/sympy/issues/17142
+    # If it start failing again in irrelevant builds or in the master
+    # please open up the issue again.
+    expr = atan(I/(I + I*tan(1)))
+    assert expr.as_real_imag() == (expr, 0)
+
+
+def test_issue_18746():
+    e3 = cos(S.Pi*(x/4 + 1/4))
+    assert e3.period() == 8