Add files using upload-large-folder tool

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/combinatorial/__init__.py

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

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/combinatorial/factorials.py

@@ -0,0 +1,1133 @@
+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 DefinedFunction, 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 gmpy as _gmpy
+from sympy.ntheory import sieve
+from sympy.ntheory.residue_ntheory import binomial_mod
+from sympy.polys.polytools import Poly
+
+from math import factorial as _factorial, prod, sqrt as _sqrt
+
+class CombinatorialFunction(DefinedFunction):
+    """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
+                    #
+                    # XXX: There is a sympy.external.gmpy.factorial function
+                    # which provides gmpy.fac if available or the flint version
+                    # if flint is used. It could be used here to avoid the
+                    # conditional logic but it needs to be checked whether the
+                    # pure Python fallback used there is as fast as the
+                    # fallback used here (perhaps the fallback here should be
+                    # moved to sympy.external.ntheory).
+                    elif _gmpy is not None:
+                        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, cdir):
+        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
+
+    In many cases, we can also compute binomial coefficients modulo a
+    prime p quickly using Lucas' Theorem [2]_, though we need to include
+    `evaluate=False` to postpone evaluation:
+
+    >>> from sympy import Mod
+    >>> Mod(binomial(156675, 4433, evaluate=False), 10**5 + 3)
+    28625
+
+    Using a generalisation of Lucas's Theorem given by Granville [3]_,
+    we can extend this to arbitrary n:
+
+    >>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2)
+    3744312326
+
+    References
+    ==========
+
+    .. [1] https://www.johndcook.com/blog/binomial_coefficients/
+    .. [2] https://en.wikipedia.org/wiki/Lucas%27s_theorem
+    .. [3] Binomial coefficients modulo prime powers, Andrew Granville,
+        Available: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf
+    """
+
+    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
+
+                # XXX: This conditional logic should be moved to
+                # sympy.external.gmpy and the pure Python version of bincoef
+                # should be moved to sympy.external.ntheory.
+                if _gmpy is not None:
+                    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
+
+            elif _sqrt(q) < k and q != 1:
+                res = binomial_mod(n, k, q)
+
+            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, cdir):
+        from sympy.functions.special.gamma_functions import gamma
+        return self.rewrite(gamma)._eval_as_leading_term(x, logx=logx, cdir=cdir)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/__init__.py

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

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/_trigonometric_special.py

@@ -0,0 +1,261 @@
+r"""A module for special angle formulas for trigonometric functions
+
+TODO
+====
+
+This module should be developed in the future to contain direct square 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.intfunc import igcdex
+from sympy.core.numbers import 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 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 existence 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
+    }

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/complexes.py

@@ -0,0 +1,1492 @@
+from __future__ import annotations
+
+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 (DefinedFunction, Derivative, ArgumentIndexError,
+    AppliedUndef, expand_mul, PoleError)
+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(DefinedFunction):
+    """
+    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: tuple[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(DefinedFunction):
+    """
+    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: tuple[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(DefinedFunction):
+    """
+    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(DefinedFunction):
+    """
+    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: tuple[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(DefinedFunction):
+    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, exp_polar
+        if isinstance(arg, exp_polar):
+            return periodic_argument(arg, oo)
+        elif isinstance(arg, exp):
+            i_ = im(arg.args[0])
+            if i_.is_comparable:
+                i_ %= 2*S.Pi
+                if i_ > S.Pi:
+                    i_ -= 2*S.Pi
+                return i_
+
+        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)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg0 = self.args[0]
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg0.subs(x, cdir*t)
+        if z.is_positive:
+            return S.Zero
+        elif z.is_negative:
+            return S.Pi
+        else:
+            raise PoleError("Cannot expand %s around 0" % (self))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        if n <= 0:
+            return Order(1)
+        return self._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+
+class conjugate(DefinedFunction):
+    """
+    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(DefinedFunction):
+    """
+    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(DefinedFunction):
+    """
+    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(DefinedFunction):
+    """
+    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(DefinedFunction):
+    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(DefinedFunction):
+    """
+    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})

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/exponential.py

@@ -0,0 +1,1286 @@
+from __future__ import annotations
+from itertools import product
+
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import (DefinedFunction, 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
+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(DefinedFunction):
+
+    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
+        if not self.is_commutative:
+            return self, S.One
+        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.matrixbase 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 super()._eval_subs(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
+        if arg0.is_infinite:
+            raise PoleError("Cannot expand %s around 0" % (self))
+        # checking for indecisiveness/ sign terms in arg0
+        if any(isinstance(arg, sign) 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, cdir):
+        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(DefinedFunction):
+    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: tuple[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])
+
+    @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).cancel()._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[ex] = terms.get(ex, S.Zero) + coeff*pk[ex]
+            pk = mul(pk, pterms)
+            k += S.One
+
+        res = log(a) - b*log(cdir) + b*logx
+        for ex in terms:
+            res += terms[ex].cancel()*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, cdir):
+        # 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(DefinedFunction):
+    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 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, cdir):
+        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)
+    }

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/hyperbolic.py

@@ -0,0 +1,2285 @@
+from sympy.core import S, sympify, cacheit
+from sympy.core.add import Add
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.logic import fuzzy_or, fuzzy_and, fuzzy_not, 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(DefinedFunction):
+    """
+    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, cdir):
+        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, evaluate=False)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return 1 / sec(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return -I*sinh(arg + pi*I/2, evaluate=False)
+
+    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, cdir):
+        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, evaluate=False)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        return -I / cot(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I*sinh(arg)/sinh(pi*I/2 - arg, evaluate=False)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I*cosh(pi*I/2 - arg, evaluate=False)/cosh(arg)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        return 1/coth(arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        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, evaluate=False)/sinh(arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return -I*cosh(arg)/cosh(pi*I/2 - arg, evaluate=False)
+
+    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, cdir):
+        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, cdir):
+        return (1/self._reciprocal_of(self.args[0]))._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    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, evaluate=False)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return I * csc(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I / cosh(arg + I * pi / 2, evaluate=False)
+
+    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, evaluate=False)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return sec(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I / sinh(arg + I * pi /2, evaluate=False)
+
+    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(DefinedFunction):
+    """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, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # 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 = super()._eval_nseries(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, evaluate=False)
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return I * acos(I * x, evaluate=False) - 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
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+
+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, cdir):
+        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)
+
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # 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 = super()._eval_nseries(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, evaluate=False))
+
+    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
+
+    def _eval_is_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, (self.args[0] - 1).is_extended_nonnegative])
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+
+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, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # 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 = super()._eval_nseries(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_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, (1 - self.args[0]).is_nonnegative, (self.args[0] + 1).is_nonnegative])
+
+    def _eval_is_finite(self):
+        return fuzzy_not(fuzzy_or([(self.args[0] - 1).is_zero, (self.args[0] + 1).is_zero]))
+
+    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, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # 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 = super()._eval_nseries(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
+
+    def _eval_is_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, fuzzy_or([(self.args[0] - 1).is_extended_nonnegative, (self.args[0] + 1).is_extended_nonpositive])])
+
+    def _eval_is_finite(self):
+        return fuzzy_not(fuzzy_or([(self.args[0] - 1).is_zero, (self.args[0] + 1).is_zero]))
+
+
+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, cdir):
+        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)
+
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # 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 = super()._eval_nseries(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, evaluate=False)
+                                                + 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, evaluate=False))
+
+    def _eval_is_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, self.args[0].is_nonnegative, (1 - self.args[0]).is_nonnegative])
+
+    def _eval_is_finite(self):
+        return fuzzy_not(self.args[0].is_zero)
+
+
+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, cdir):
+        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.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        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 = super()._eval_nseries(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, evaluate=False) - 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
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_finite(self):
+        return fuzzy_not(self.args[0].is_zero)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/integers.py

@@ -0,0 +1,710 @@
+from __future__ import annotations
+
+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 DefinedFunction
+from sympy.core.logic import fuzzy_or, fuzzy_and
+from sympy.core.numbers import Integer, int_valued
+from sympy.core.relational import Gt, Lt, Ge, Le, Relational, is_eq, is_le, is_lt
+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(DefinedFunction):
+    """Abstract base class for rounding functions."""
+
+    args: tuple[Expr]
+
+    @classmethod
+    def eval(cls, arg):
+        if (v := cls._eval_number(arg)) is not None:
+            return v
+        if (v := cls._eval_const_number(arg)) 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
+        intof = lambda x: int(x) if int_valued(x) else (
+            x if x.is_integer else None)
+        for t in Add.make_args(arg):
+            if t.is_imaginary and (i := intof(im(t))) is not None:
+                ipart += i*S.ImaginaryUnit
+            elif (i := intof(t)) is not None:
+                ipart += i
+            elif t.is_number:
+                npart += t
+            else:
+                spart += 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()
+        if 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]
+
+    @classmethod
+    def _eval_const_number(cls, arg):
+        if arg.is_real:
+            if arg.is_zero:
+                return S.Zero
+            if arg.is_positive:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # 0 <= num/den < 1 -> 0
+                if is_lt(num, den):
+                    return S.Zero
+                # 1 <= num/den < 2 -> 1
+                if fuzzy_and([is_le(den, num), is_lt(num, 2*den)]):
+                    return S.One
+            if arg.is_negative:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # -1 <= num/den < 0 -> -1
+                if is_le(-den, num):
+                    return S.NegativeOne
+                # -2 <= num/den < -1 -> -2
+                if fuzzy_and([is_le(-2*den, num), is_lt(num, -den)]):
+                    return Integer(-2)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        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 if cdir != 0 else 1)
+                if ndir.is_negative:
+                    return r - 1
+                elif ndir.is_positive:
+                    return r
+                else:
+                    raise NotImplementedError("Not sure of sign of %s" % ndir)
+            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)
+            if ndir.is_negative:
+                return r - 1
+            elif ndir.is_positive:
+                return r
+            else:
+                raise NotImplementedError("Not sure of sign of %s" % ndir)
+        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 and other.is_noninteger:
+            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 and other.is_noninteger:
+            return S.true
+        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()
+        if 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]
+
+    @classmethod
+    def _eval_const_number(cls, arg):
+        if arg.is_real:
+            if arg.is_zero:
+                return S.Zero
+            if arg.is_positive:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # 0 < num/den <= 1 -> 1
+                if is_le(num, den):
+                    return S.One
+                # 1 < num/den <= 2 -> 2
+                if fuzzy_and([is_lt(den, num), is_le(num, 2*den)]):
+                    return Integer(2)
+            if arg.is_negative:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # -1 < num/den <= 0 -> 0
+                if is_lt(-den, num):
+                    return S.Zero
+                # -2 < num/den <= -1 -> -1
+                if fuzzy_and([is_lt(-2*den, num), is_le(num, -den)]):
+                    return S.NegativeOne
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        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 if cdir != 0 else 1)
+                if ndir.is_negative:
+                    return r
+                elif ndir.is_positive:
+                    return r + 1
+                else:
+                    raise NotImplementedError("Not sure of sign of %s" % ndir)
+            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)
+            if ndir.is_negative:
+                return r
+            elif ndir.is_positive:
+                return r + 1
+            else:
+                raise NotImplementedError("Not sure of sign of %s" % ndir)
+        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 and other.is_noninteger:
+            return S.true
+        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 and other.is_noninteger:
+            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(DefinedFunction):
+    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)
+
+        real, imag = S.Zero, S.Zero
+        for t in Add.make_args(arg):
+            # 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, cdir):
+        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

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/miscellaneous.py

@@ -0,0 +1,915 @@
+from sympy.core import 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, DefinedFunction)
+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.intfunc.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.intfunc.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 = super().fdiff(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(DefinedFunction):
+    """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

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/piecewise.py

@@ -0,0 +1,1517 @@
+from sympy.core import S, diff, Tuple, Dummy, Mul
+from sympy.core.basic import Basic, as_Basic
+from sympy.core.function import DefinedFunction
+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(DefinedFunction):
+    """
+    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, cdir):
+        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
+
+            upper = 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, **kwargs):
+        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 = Min(a, 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
+                try:
+                    a = cset.inf
+                except NotImplementedError:
+                    pass # continue with the given `a`
+                else:
+                    incl_a = include(c, x, a)
+                if incl_a and incl_b:
+                    if a.is_infinite and b.is_infinite:
+                        c = S.true
+                    elif b.is_infinite:
+                        c = (x > a) if a in covered else (x >= a)
+                    elif a.is_infinite:
+                        c = (x <= b)
+                    elif a in covered:
+                        c = And(a < x, x <= b)
+                    else:
+                        c = And(a <= x, x <= b)
+                elif incl_a:
+                    if a.is_infinite:
+                        c = (x < b)
+                    elif a in covered:
+                        c = And(a < x, x < b)
+                    else:
+                        c = And(a <= x, x < b)
+                elif incl_b:
+                    if b.is_infinite:
+                        c = (x > a)
+                    else:
+                        c = And(a < x, 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

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_complexes.py

@@ -0,0 +1,1030 @@
+from sympy.core.function import (Derivative, Function, Lambda, expand, PoleError)
+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.elementary.hyperbolic import sinh
+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.series.order import Order
+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)
+
+    assert arg(exp(I*pi/7)) == pi/7     # issue 17300
+    assert arg(exp(16*I)) == 16 - 6*pi
+    assert arg(exp(13*I*pi/12)) == -11*pi/12
+    assert arg(exp(123 - 5*I)) == -5 + 2*pi
+    assert arg(exp(sin(1 + 3*I))) == -2*pi + cos(1)*sinh(3)
+    r = Symbol('r', real=True)
+    assert arg(exp(r - 2*I)) == -2
+
+    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_arg_leading_term_and_series():
+    x = Symbol('x')
+    assert arg(x).as_leading_term(x, cdir = 1) == 0
+    assert arg(x).as_leading_term(x, cdir = -1) == pi
+    raises(PoleError, lambda: arg(x + I).as_leading_term(x, cdir = 1))
+    raises(PoleError, lambda: arg(2*x).as_leading_term(x, cdir = I))
+
+    assert arg(x).nseries(x) == 0
+    assert arg(x).nseries(x, n=0) == Order(1)
+
+
+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) == conjugate(x) + conjugate(y)
+    assert adjoint(x - y) == conjugate(x) - conjugate(y)
+    assert adjoint(x * y) == conjugate(x) * conjugate(y)
+    assert adjoint(x / y) == conjugate(x) / conjugate(y)
+    assert adjoint(-x) == -conjugate(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', commutative=False)
+    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)
+
+    x = Symbol('x')
+    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) == x + y
+    assert transpose(x - y) == x - y
+    assert transpose(x * y) == x * y
+    assert transpose(x / y) == x / y
+    assert transpose(-x) == -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))

URSA/.venv_ursa/lib/python3.12/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)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/__init__.py

@@ -0,0 +1 @@
+# Stub __init__.py for the sympy.functions.special package

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/bessel.py

@@ -0,0 +1,2208 @@
+from functools import wraps
+
+from sympy.core import S
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, ArgumentIndexError, _mexpand
+from sympy.core.logic import fuzzy_or, fuzzy_not
+from sympy.core.numbers import Rational, pi, I
+from sympy.core.power import Pow
+from sympy.core.symbol import Dummy, uniquely_named_symbol, Wild
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial, RisingFactorial
+from sympy.functions.elementary.trigonometric import sin, cos, csc, cot
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import cbrt, sqrt, root
+from sympy.functions.elementary.complexes import (Abs, re, im, polar_lift, unpolarify)
+from sympy.functions.special.gamma_functions import gamma, digamma, uppergamma
+from sympy.functions.special.hyper import hyper
+from sympy.polys.orthopolys import spherical_bessel_fn
+
+from mpmath import mp, workprec
+
+# TODO
+# o Scorer functions G1 and G2
+# o Asymptotic expansions
+#   These are possible, e.g. for fixed order, but since the bessel type
+#   functions are oscillatory they are not actually tractable at
+#   infinity, so this is not particularly useful right now.
+# o Nicer series expansions.
+# o More rewriting.
+# o Add solvers to ode.py (or rather add solvers for the hypergeometric equation).
+
+
+class BesselBase(DefinedFunction):
+    """
+    Abstract base class for Bessel-type functions.
+
+    This class is meant to reduce code duplication.
+    All Bessel-type functions can 1) be differentiated, with the derivatives
+    expressed in terms of similar functions, and 2) be rewritten in terms
+    of other Bessel-type functions.
+
+    Here, Bessel-type functions are assumed to have one complex parameter.
+
+    To use this base class, define class attributes ``_a`` and ``_b`` such that
+    ``2*F_n' = -_a*F_{n+1} + b*F_{n-1}``.
+
+    """
+
+    @property
+    def order(self):
+        """ The order of the Bessel-type function. """
+        return self.args[0]
+
+    @property
+    def argument(self):
+        """ The argument of the Bessel-type function. """
+        return self.args[1]
+
+    @classmethod
+    def eval(cls, nu, z):
+        return
+
+    def fdiff(self, argindex=2):
+        if argindex != 2:
+            raise ArgumentIndexError(self, argindex)
+        return (self._b/2 * self.__class__(self.order - 1, self.argument) -
+                self._a/2 * self.__class__(self.order + 1, self.argument))
+
+    def _eval_conjugate(self):
+        z = self.argument
+        if z.is_extended_negative is False:
+            return self.__class__(self.order.conjugate(), z.conjugate())
+
+    def _eval_is_meromorphic(self, x, a):
+        nu, z = self.order, self.argument
+
+        if nu.has(x):
+            return False
+        if not z._eval_is_meromorphic(x, a):
+            return None
+        z0 = z.subs(x, a)
+        if nu.is_integer:
+            if isinstance(self, (besselj, besseli, hn1, hn2, jn, yn)) or not nu.is_zero:
+                return fuzzy_not(z0.is_infinite)
+        return fuzzy_not(fuzzy_or([z0.is_zero, z0.is_infinite]))
+
+    def _eval_expand_func(self, **hints):
+        nu, z, f = self.order, self.argument, self.__class__
+        if nu.is_real:
+            if (nu - 1).is_positive:
+                return (-self._a*self._b*f(nu - 2, z)._eval_expand_func() +
+                        2*self._a*(nu - 1)*f(nu - 1, z)._eval_expand_func()/z)
+            elif (nu + 1).is_negative:
+                return (2*self._b*(nu + 1)*f(nu + 1, z)._eval_expand_func()/z -
+                        self._a*self._b*f(nu + 2, z)._eval_expand_func())
+        return self
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import besselsimp
+        return besselsimp(self)
+
+
+class besselj(BesselBase):
+    r"""
+    Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    The Bessel $J$ function of order $\nu$ is defined to be the function
+    satisfying Bessel's differential equation
+
+    .. math ::
+        z^2 \frac{\mathrm{d}^2 w}{\mathrm{d}z^2}
+        + z \frac{\mathrm{d}w}{\mathrm{d}z} + (z^2 - \nu^2) w = 0,
+
+    with Laurent expansion
+
+    .. math ::
+        J_\nu(z) = z^\nu \left(\frac{1}{\Gamma(\nu + 1) 2^\nu} + O(z^2) \right),
+
+    if $\nu$ is not a negative integer. If $\nu=-n \in \mathbb{Z}_{<0}$
+    *is* a negative integer, then the definition is
+
+    .. math ::
+        J_{-n}(z) = (-1)^n J_n(z).
+
+    Examples
+    ========
+
+    Create a Bessel function object:
+
+    >>> from sympy import besselj, jn
+    >>> from sympy.abc import z, n
+    >>> b = besselj(n, z)
+
+    Differentiate it:
+
+    >>> b.diff(z)
+    besselj(n - 1, z)/2 - besselj(n + 1, z)/2
+
+    Rewrite in terms of spherical Bessel functions:
+
+    >>> b.rewrite(jn)
+    sqrt(2)*sqrt(z)*jn(n - 1/2, z)/sqrt(pi)
+
+    Access the parameter and argument:
+
+    >>> b.order
+    n
+    >>> b.argument
+    z
+
+    See Also
+    ========
+
+    bessely, besseli, besselk
+
+    References
+    ==========
+
+    .. [1] Abramowitz, Milton; Stegun, Irene A., eds. (1965), "Chapter 9",
+           Handbook of Mathematical Functions with Formulas, Graphs, and
+           Mathematical Tables
+    .. [2] Luke, Y. L. (1969), The Special Functions and Their
+           Approximations, Volume 1
+    .. [3] https://en.wikipedia.org/wiki/Bessel_function
+    .. [4] https://functions.wolfram.com/Bessel-TypeFunctions/BesselJ/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.One
+            elif (nu.is_integer and nu.is_zero is False) or re(nu).is_positive:
+                return S.Zero
+            elif re(nu).is_negative and not (nu.is_integer is True):
+                return S.ComplexInfinity
+            elif nu.is_imaginary:
+                return S.NaN
+        if z in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+
+        if z.could_extract_minus_sign():
+            return (z)**nu*(-z)**(-nu)*besselj(nu, -z)
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return S.NegativeOne**(-nu)*besselj(-nu, z)
+            newz = z.extract_multiplicatively(I)
+            if newz:  # NOTE we don't want to change the function if z==0
+                return I**(nu)*besseli(nu, newz)
+
+        # branch handling:
+        if nu.is_integer:
+            newz = unpolarify(z)
+            if newz != z:
+                return besselj(nu, newz)
+        else:
+            newz, n = z.extract_branch_factor()
+            if n != 0:
+                return exp(2*n*pi*nu*I)*besselj(nu, newz)
+        nnu = unpolarify(nu)
+        if nu != nnu:
+            return besselj(nnu, z)
+
+    def _eval_rewrite_as_besseli(self, nu, z, **kwargs):
+        return exp(I*pi*nu/2)*besseli(nu, polar_lift(-I)*z)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        if nu.is_integer is False:
+            return csc(pi*nu)*bessely(-nu, z) - cot(pi*nu)*bessely(nu, z)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        return sqrt(2*z/pi)*jn(nu - S.Half, self.argument)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        c, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            return arg**nu/(2**nu*gamma(nu + 1))
+        elif e.is_negative:
+            cdir = 1 if cdir == 0 else cdir
+            sign = c*cdir**e
+            if not sign.is_negative:
+                # Refer Abramowitz and Stegun 1965, p. 364 for more information on
+                # asymptotic approximation of besselj function.
+                return sqrt(2)*cos(z - pi*(2*nu + 1)/4)/sqrt(pi*z)
+            return self
+
+        return super(besselj, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_extended_real:
+            return True
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # Refer https://functions.wolfram.com/Bessel-TypeFunctions/BesselJ/06/01/04/01/01/0003/
+        # for more information on nseries expansion of besselj function.
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        if exp.is_positive:
+            newn = ceiling(n/exp)
+            o = Order(x**n, x)
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return o
+            t = (_mexpand(r**2) + o).removeO()
+
+            term = r**nu/gamma(nu + 1)
+            s = [term]
+            for k in range(1, (newn + 1)//2):
+                term *= -t/(k*(nu + k))
+                term = (_mexpand(term) + o).removeO()
+                s.append(term)
+            return Add(*s) + o
+
+        return super(besselj, self)._eval_nseries(x, n, logx, cdir)
+
+
+class bessely(BesselBase):
+    r"""
+    Bessel function of the second kind.
+
+    Explanation
+    ===========
+
+    The Bessel $Y$ function of order $\nu$ is defined as
+
+    .. math ::
+        Y_\nu(z) = \lim_{\mu \to \nu} \frac{J_\mu(z) \cos(\pi \mu)
+                                            - J_{-\mu}(z)}{\sin(\pi \mu)},
+
+    where $J_\mu(z)$ is the Bessel function of the first kind.
+
+    It is a solution to Bessel's equation, and linearly independent from
+    $J_\nu$.
+
+    Examples
+    ========
+
+    >>> from sympy import bessely, yn
+    >>> from sympy.abc import z, n
+    >>> b = bessely(n, z)
+    >>> b.diff(z)
+    bessely(n - 1, z)/2 - bessely(n + 1, z)/2
+    >>> b.rewrite(yn)
+    sqrt(2)*sqrt(z)*yn(n - 1/2, z)/sqrt(pi)
+
+    See Also
+    ========
+
+    besselj, besseli, besselk
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/BesselY/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.NegativeInfinity
+            elif re(nu).is_zero is False:
+                return S.ComplexInfinity
+            elif re(nu).is_zero:
+                return S.NaN
+        if z in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+        if z == I*S.Infinity:
+            return exp(I*pi*(nu + 1)/2) * S.Infinity
+        if z == I*S.NegativeInfinity:
+            return exp(-I*pi*(nu + 1)/2) * S.Infinity
+
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return S.NegativeOne**(-nu)*bessely(-nu, z)
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        if nu.is_integer is False:
+            return csc(pi*nu)*(cos(pi*nu)*besselj(nu, z) - besselj(-nu, z))
+
+    def _eval_rewrite_as_besseli(self, nu, z, **kwargs):
+        aj = self._eval_rewrite_as_besselj(*self.args)
+        if aj:
+            return aj.rewrite(besseli)
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        return sqrt(2*z/pi) * yn(nu - S.Half, self.argument)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        c, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            term_one = ((2/pi)*log(z/2)*besselj(nu, z))
+            term_two = -(z/2)**(-nu)*factorial(nu - 1)/pi if (nu).is_positive else S.Zero
+            term_three = -(z/2)**nu/(pi*factorial(nu))*(digamma(nu + 1) - S.EulerGamma)
+            arg = Add(*[term_one, term_two, term_three]).as_leading_term(x, logx=logx)
+            return arg
+        elif e.is_negative:
+            cdir = 1 if cdir == 0 else cdir
+            sign = c*cdir**e
+            if not sign.is_negative:
+                # Refer Abramowitz and Stegun 1965, p. 364 for more information on
+                # asymptotic approximation of bessely function.
+                return sqrt(2)*(-sin(pi*nu/2 - z + pi/4) + 3*cos(pi*nu/2 - z + pi/4)/(8*z))*sqrt(1/z)/sqrt(pi)
+            return self
+
+        return super(bessely, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_positive:
+            return True
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # Refer https://functions.wolfram.com/Bessel-TypeFunctions/BesselY/06/01/04/01/02/0008/
+        # for more information on nseries expansion of bessely function.
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        if exp.is_positive and nu.is_integer:
+            newn = ceiling(n/exp)
+            bn = besselj(nu, z)
+            a = ((2/pi)*log(z/2)*bn)._eval_nseries(x, n, logx, cdir)
+
+            b, c = [], []
+            o = Order(x**n, x)
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return o
+            t = (_mexpand(r**2) + o).removeO()
+
+            if nu > S.Zero:
+                term = r**(-nu)*factorial(nu - 1)/pi
+                b.append(term)
+                for k in range(1, nu):
+                    denom = (nu - k)*k
+                    if denom == S.Zero:
+                        term *= t/k
+                    else:
+                        term *= t/denom
+                    term = (_mexpand(term) + o).removeO()
+                    b.append(term)
+
+            p = r**nu/(pi*factorial(nu))
+            term = p*(digamma(nu + 1) - S.EulerGamma)
+            c.append(term)
+            for k in range(1, (newn + 1)//2):
+                p *= -t/(k*(k + nu))
+                p = (_mexpand(p) + o).removeO()
+                term = p*(digamma(k + nu + 1) + digamma(k + 1))
+                c.append(term)
+            return a - Add(*b) - Add(*c) # Order term comes from a
+
+        return super(bessely, self)._eval_nseries(x, n, logx, cdir)
+
+
+class besseli(BesselBase):
+    r"""
+    Modified Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    The Bessel $I$ function is a solution to the modified Bessel equation
+
+    .. math ::
+        z^2 \frac{\mathrm{d}^2 w}{\mathrm{d}z^2}
+        + z \frac{\mathrm{d}w}{\mathrm{d}z} + (z^2 + \nu^2)^2 w = 0.
+
+    It can be defined as
+
+    .. math ::
+        I_\nu(z) = i^{-\nu} J_\nu(iz),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind.
+
+    Examples
+    ========
+
+    >>> from sympy import besseli
+    >>> from sympy.abc import z, n
+    >>> besseli(n, z).diff(z)
+    besseli(n - 1, z)/2 + besseli(n + 1, z)/2
+
+    See Also
+    ========
+
+    besselj, bessely, besselk
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/BesselI/
+
+    """
+
+    _a = -S.One
+    _b = S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.One
+            elif (nu.is_integer and nu.is_zero is False) or re(nu).is_positive:
+                return S.Zero
+            elif re(nu).is_negative and not (nu.is_integer is True):
+                return S.ComplexInfinity
+            elif nu.is_imaginary:
+                return S.NaN
+        if im(z) in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+        if z is S.Infinity:
+            return S.Infinity
+        if z is S.NegativeInfinity:
+            return (-1)**nu*S.Infinity
+
+        if z.could_extract_minus_sign():
+            return (z)**nu*(-z)**(-nu)*besseli(nu, -z)
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return besseli(-nu, z)
+            newz = z.extract_multiplicatively(I)
+            if newz:  # NOTE we don't want to change the function if z==0
+                return I**(-nu)*besselj(nu, -newz)
+
+        # branch handling:
+        if nu.is_integer:
+            newz = unpolarify(z)
+            if newz != z:
+                return besseli(nu, newz)
+        else:
+            newz, n = z.extract_branch_factor()
+            if n != 0:
+                return exp(2*n*pi*nu*I)*besseli(nu, newz)
+        nnu = unpolarify(nu)
+        if nu != nnu:
+            return besseli(nnu, z)
+
+    def _eval_rewrite_as_tractable(self, nu, z, limitvar=None, **kwargs):
+        if z.is_extended_real:
+            return exp(z)*_besseli(nu, z)
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        return exp(-I*pi*nu/2)*besselj(nu, polar_lift(I)*z)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        aj = self._eval_rewrite_as_besselj(*self.args)
+        if aj:
+            return aj.rewrite(bessely)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        return self._eval_rewrite_as_besselj(*self.args).rewrite(jn)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_extended_real:
+            return True
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        c, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            return arg**nu/(2**nu*gamma(nu + 1))
+        elif e.is_negative:
+            cdir = 1 if cdir == 0 else cdir
+            sign = c*cdir**e
+            if not sign.is_negative:
+                # Refer Abramowitz and Stegun 1965, p. 377 for more information on
+                # asymptotic approximation of besseli function.
+                return exp(z)/sqrt(2*pi*z)
+            return self
+
+        return super(besseli, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # Refer https://functions.wolfram.com/Bessel-TypeFunctions/BesselI/06/01/04/01/01/0003/
+        # for more information on nseries expansion of besseli function.
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        if exp.is_positive:
+            newn = ceiling(n/exp)
+            o = Order(x**n, x)
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return o
+            t = (_mexpand(r**2) + o).removeO()
+
+            term = r**nu/gamma(nu + 1)
+            s = [term]
+            for k in range(1, (newn + 1)//2):
+                term *= t/(k*(nu + k))
+                term = (_mexpand(term) + o).removeO()
+                s.append(term)
+            return Add(*s) + o
+
+        return super(besseli, self)._eval_nseries(x, n, logx, cdir)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            s = [(RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(Rational(2*nu + 1, 2), k))/\
+            ((2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k)) for k in range(n)] + [Order(1/z**(Rational(2*n + 1, 2)), x)]
+            return exp(z)/sqrt(2*pi) * (Add(*s))
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+class besselk(BesselBase):
+    r"""
+    Modified Bessel function of the second kind.
+
+    Explanation
+    ===========
+
+    The Bessel $K$ function of order $\nu$ is defined as
+
+    .. math ::
+        K_\nu(z) = \lim_{\mu \to \nu} \frac{\pi}{2}
+                   \frac{I_{-\mu}(z) -I_\mu(z)}{\sin(\pi \mu)},
+
+    where $I_\mu(z)$ is the modified Bessel function of the first kind.
+
+    It is a solution of the modified Bessel equation, and linearly independent
+    from $Y_\nu$.
+
+    Examples
+    ========
+
+    >>> from sympy import besselk
+    >>> from sympy.abc import z, n
+    >>> besselk(n, z).diff(z)
+    -besselk(n - 1, z)/2 - besselk(n + 1, z)/2
+
+    See Also
+    ========
+
+    besselj, besseli, bessely
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/BesselK/
+
+    """
+
+    _a = S.One
+    _b = -S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.Infinity
+            elif re(nu).is_zero is False:
+                return S.ComplexInfinity
+            elif re(nu).is_zero:
+                return S.NaN
+        if z in (S.Infinity, I*S.Infinity, I*S.NegativeInfinity):
+            return S.Zero
+
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return besselk(-nu, z)
+
+    def _eval_rewrite_as_besseli(self, nu, z, **kwargs):
+        if nu.is_integer is False:
+            return pi*csc(pi*nu)*(besseli(-nu, z) - besseli(nu, z))/2
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        ai = self._eval_rewrite_as_besseli(*self.args)
+        if ai:
+            return ai.rewrite(besselj)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        aj = self._eval_rewrite_as_besselj(*self.args)
+        if aj:
+            return aj.rewrite(bessely)
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        ay = self._eval_rewrite_as_bessely(*self.args)
+        if ay:
+            return ay.rewrite(yn)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_positive:
+            return True
+
+    def _eval_rewrite_as_tractable(self, nu, z, limitvar=None, **kwargs):
+        if z.is_extended_real:
+            return exp(-z)*_besselk(nu, z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        _, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            if nu.is_zero:
+                # Equation 9.6.8 of Abramowitz and Stegun (10th ed, 1972).
+                term = -log(z) - S.EulerGamma + log(2)
+            elif nu.is_nonzero:
+                # Equation 9.6.9 of Abramowitz and Stegun (10th ed, 1972).
+                term = gamma(Abs(nu))*(z/2)**(-Abs(nu))/2
+            else:
+                raise NotImplementedError(f"Cannot proceed without knowing if {nu} is zero or not.")
+
+            return term.as_leading_term(x, logx=logx)
+        elif e.is_negative:
+            # Equation 9.7.2 of Abramowitz and Stegun (10th ed, 1972).
+            return sqrt(pi)*exp(-arg)/sqrt(2*arg)
+        else:
+            return self.func(nu, arg)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        if exp.is_positive:
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return Order(z**(-nu) + z**nu, x)
+
+            o = Order(x**n, x)
+            if nu.is_integer:
+                # Reference: https://functions.wolfram.com/Bessel-TypeFunctions/BesselK/06/01/04/01/02/0008/ (only for integer order)
+                newn = ceiling(n/exp)
+                bn = besseli(nu, z)
+                a = ((-1)**(nu - 1)*log(z/2)*bn)._eval_nseries(x, n, logx, cdir)
+
+                b, c = [], []
+                t = _mexpand(r**2)
+
+                if nu > S.Zero:
+                    term = r**(-nu)*factorial(nu - 1)/2
+                    b.append(term)
+                    for k in range(1, nu):
+                        term *= t/((k - nu)*k)
+                        term = (_mexpand(term) + o).removeO()
+                        b.append(term)
+
+                p = r**nu*(-1)**nu/(2*factorial(nu))
+                term = p*(digamma(nu + 1) - S.EulerGamma)
+                c.append(term)
+                for k in range(1, (newn + 1)//2):
+                    p *= t/(k*(k + nu))
+                    p = (_mexpand(p) + o).removeO()
+                    term = p*(digamma(k + nu + 1) + digamma(k + 1))
+                    c.append(term)
+                return a + Add(*b) + Add(*c) + o
+            elif nu.is_noninteger:
+                # Reference: https://functions.wolfram.com/Bessel-TypeFunctions/BesselK/06/01/04/01/01/0003/
+                # (only for non-integer order).
+                # While the expression in the reference above seems correct
+                # for non-real order as well, it would need some manipulation
+                # (not implemented) to be written as a power series in x with
+                # real exponents [e.g. Dunster 1990. "Bessel functions
+                # of purely imaginary order, with an application to second-order
+                # linear differential equations having a large parameter".
+                # SIAM J. Math. Anal. Vol 21, No. 4, pp 995-1018.].
+                newn_a = ceiling((n+nu)/exp)
+                newn_b = ceiling((n-nu)/exp)
+
+                a, b = [], []
+                for k in range((newn_a+1)//2):
+                    term = gamma(nu)*r**(2*k-nu)/(2*RisingFactorial(1-nu, k)*factorial(k))
+                    a.append(_mexpand(term))
+                for k in range((newn_b+1)//2):
+                    term = gamma(-nu)*r**(2*k+nu)/(2*RisingFactorial(nu+1, k)*factorial(k))
+                    b.append(_mexpand(term))
+                return Add(*a) + Add(*b) + o
+            else:
+                raise NotImplementedError("besselk expansion is only implemented for real order")
+
+        return super(besselk, self)._eval_nseries(x, n, logx, cdir)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            s = [(RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(Rational(2*nu + 1, 2), k))/\
+            ((-2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k)) for k in range(n)] +[Order(1/z**(Rational(2*n + 1, 2)), x)]
+            return (exp(-z)*sqrt(pi/2))*Add(*s)
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+class hankel1(BesselBase):
+    r"""
+    Hankel function of the first kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math ::
+        H_\nu^{(1)} = J_\nu(z) + iY_\nu(z),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind, and
+    $Y_\nu(z)$ is the Bessel function of the second kind.
+
+    It is a solution to Bessel's equation.
+
+    Examples
+    ========
+
+    >>> from sympy import hankel1
+    >>> from sympy.abc import z, n
+    >>> hankel1(n, z).diff(z)
+    hankel1(n - 1, z)/2 - hankel1(n + 1, z)/2
+
+    See Also
+    ========
+
+    hankel2, besselj, bessely
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/HankelH1/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    def _eval_conjugate(self):
+        z = self.argument
+        if z.is_extended_negative is False:
+            return hankel2(self.order.conjugate(), z.conjugate())
+
+
+class hankel2(BesselBase):
+    r"""
+    Hankel function of the second kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math ::
+        H_\nu^{(2)} = J_\nu(z) - iY_\nu(z),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind, and
+    $Y_\nu(z)$ is the Bessel function of the second kind.
+
+    It is a solution to Bessel's equation, and linearly independent from
+    $H_\nu^{(1)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import hankel2
+    >>> from sympy.abc import z, n
+    >>> hankel2(n, z).diff(z)
+    hankel2(n - 1, z)/2 - hankel2(n + 1, z)/2
+
+    See Also
+    ========
+
+    hankel1, besselj, bessely
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/HankelH2/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    def _eval_conjugate(self):
+        z = self.argument
+        if z.is_extended_negative is False:
+            return hankel1(self.order.conjugate(), z.conjugate())
+
+
+def assume_integer_order(fn):
+    @wraps(fn)
+    def g(self, nu, z):
+        if nu.is_integer:
+            return fn(self, nu, z)
+    return g
+
+
+class SphericalBesselBase(BesselBase):
+    """
+    Base class for spherical Bessel functions.
+
+    These are thin wrappers around ordinary Bessel functions,
+    since spherical Bessel functions differ from the ordinary
+    ones just by a slight change in order.
+
+    To use this class, define the ``_eval_evalf()`` and ``_expand()`` methods.
+
+    """
+
+    def _expand(self, **hints):
+        """ Expand self into a polynomial. Nu is guaranteed to be Integer. """
+        raise NotImplementedError('expansion')
+
+    def _eval_expand_func(self, **hints):
+        if self.order.is_Integer:
+            return self._expand(**hints)
+        return self
+
+    def fdiff(self, argindex=2):
+        if argindex != 2:
+            raise ArgumentIndexError(self, argindex)
+        return self.__class__(self.order - 1, self.argument) - \
+            self * (self.order + 1)/self.argument
+
+
+def _jn(n, z):
+    return (spherical_bessel_fn(n, z)*sin(z) +
+            S.NegativeOne**(n + 1)*spherical_bessel_fn(-n - 1, z)*cos(z))
+
+
+def _yn(n, z):
+    # (-1)**(n + 1) * _jn(-n - 1, z)
+    return (S.NegativeOne**(n + 1) * spherical_bessel_fn(-n - 1, z)*sin(z) -
+            spherical_bessel_fn(n, z)*cos(z))
+
+
+class jn(SphericalBesselBase):
+    r"""
+    Spherical Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    This function is a solution to the spherical Bessel equation
+
+    .. math ::
+        z^2 \frac{\mathrm{d}^2 w}{\mathrm{d}z^2}
+          + 2z \frac{\mathrm{d}w}{\mathrm{d}z} + (z^2 - \nu(\nu + 1)) w = 0.
+
+    It can be defined as
+
+    .. math ::
+        j_\nu(z) = \sqrt{\frac{\pi}{2z}} J_{\nu + \frac{1}{2}}(z),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind.
+
+    The spherical Bessel functions of integral order are
+    calculated using the formula:
+
+    .. math:: j_n(z) = f_n(z) \sin{z} + (-1)^{n+1} f_{-n-1}(z) \cos{z},
+
+    where the coefficients $f_n(z)$ are available as
+    :func:`sympy.polys.orthopolys.spherical_bessel_fn`.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, jn, sin, cos, expand_func, besselj, bessely
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(jn(0, z)))
+    sin(z)/z
+    >>> expand_func(jn(1, z)) == sin(z)/z**2 - cos(z)/z
+    True
+    >>> expand_func(jn(3, z))
+    (-6/z**2 + 15/z**4)*sin(z) + (1/z - 15/z**3)*cos(z)
+    >>> jn(nu, z).rewrite(besselj)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*besselj(nu + 1/2, z)/2
+    >>> jn(nu, z).rewrite(bessely)
+    (-1)**nu*sqrt(2)*sqrt(pi)*sqrt(1/z)*bessely(-nu - 1/2, z)/2
+    >>> jn(2, 5.2+0.3j).evalf(20)
+    0.099419756723640344491 - 0.054525080242173562897*I
+
+    See Also
+    ========
+
+    besselj, bessely, besselk, yn
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.One
+            elif nu.is_integer:
+                if nu.is_positive:
+                    return S.Zero
+                else:
+                    return S.ComplexInfinity
+        if z in (S.NegativeInfinity, S.Infinity):
+            return S.Zero
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z)) * besselj(nu + S.Half, z)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        return S.NegativeOne**nu * sqrt(pi/(2*z)) * bessely(-nu - S.Half, z)
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        return S.NegativeOne**(nu) * yn(-nu - 1, z)
+
+    def _expand(self, **hints):
+        return _jn(self.order, self.argument)
+
+    def _eval_evalf(self, prec):
+        if self.order.is_Integer:
+            return self.rewrite(besselj)._eval_evalf(prec)
+
+
+class yn(SphericalBesselBase):
+    r"""
+    Spherical Bessel function of the second kind.
+
+    Explanation
+    ===========
+
+    This function is another solution to the spherical Bessel equation, and
+    linearly independent from $j_n$. It can be defined as
+
+    .. math ::
+        y_\nu(z) = \sqrt{\frac{\pi}{2z}} Y_{\nu + \frac{1}{2}}(z),
+
+    where $Y_\nu(z)$ is the Bessel function of the second kind.
+
+    For integral orders $n$, $y_n$ is calculated using the formula:
+
+    .. math:: y_n(z) = (-1)^{n+1} j_{-n-1}(z)
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, yn, sin, cos, expand_func, besselj, bessely
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(yn(0, z)))
+    -cos(z)/z
+    >>> expand_func(yn(1, z)) == -cos(z)/z**2-sin(z)/z
+    True
+    >>> yn(nu, z).rewrite(besselj)
+    (-1)**(nu + 1)*sqrt(2)*sqrt(pi)*sqrt(1/z)*besselj(-nu - 1/2, z)/2
+    >>> yn(nu, z).rewrite(bessely)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*bessely(nu + 1/2, z)/2
+    >>> yn(2, 5.2+0.3j).evalf(20)
+    0.18525034196069722536 + 0.014895573969924817587*I
+
+    See Also
+    ========
+
+    besselj, bessely, besselk, jn
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+    @assume_integer_order
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        return S.NegativeOne**(nu+1) * sqrt(pi/(2*z)) * besselj(-nu - S.Half, z)
+
+    @assume_integer_order
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z)) * bessely(nu + S.Half, z)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        return S.NegativeOne**(nu + 1) * jn(-nu - 1, z)
+
+    def _expand(self, **hints):
+        return _yn(self.order, self.argument)
+
+    def _eval_evalf(self, prec):
+        if self.order.is_Integer:
+            return self.rewrite(bessely)._eval_evalf(prec)
+
+
+class SphericalHankelBase(SphericalBesselBase):
+
+    @assume_integer_order
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        # jn +- I*yn
+        # jn as beeselj: sqrt(pi/(2*z)) * besselj(nu + S.Half, z)
+        # yn as besselj: (-1)**(nu+1) * sqrt(pi/(2*z)) * besselj(-nu - S.Half, z)
+        hks = self._hankel_kind_sign
+        return sqrt(pi/(2*z))*(besselj(nu + S.Half, z) +
+                               hks*I*S.NegativeOne**(nu+1)*besselj(-nu - S.Half, z))
+
+    @assume_integer_order
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        # jn +- I*yn
+        # jn as bessely: (-1)**nu * sqrt(pi/(2*z)) * bessely(-nu - S.Half, z)
+        # yn as bessely: sqrt(pi/(2*z)) * bessely(nu + S.Half, z)
+        hks = self._hankel_kind_sign
+        return sqrt(pi/(2*z))*(S.NegativeOne**nu*bessely(-nu - S.Half, z) +
+                               hks*I*bessely(nu + S.Half, z))
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        hks = self._hankel_kind_sign
+        return jn(nu, z).rewrite(yn) + hks*I*yn(nu, z)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        hks = self._hankel_kind_sign
+        return jn(nu, z) + hks*I*yn(nu, z).rewrite(jn)
+
+    def _eval_expand_func(self, **hints):
+        if self.order.is_Integer:
+            return self._expand(**hints)
+        else:
+            nu = self.order
+            z = self.argument
+            hks = self._hankel_kind_sign
+            return jn(nu, z) + hks*I*yn(nu, z)
+
+    def _expand(self, **hints):
+        n = self.order
+        z = self.argument
+        hks = self._hankel_kind_sign
+
+        # fully expanded version
+        # return ((fn(n, z) * sin(z) +
+        #          (-1)**(n + 1) * fn(-n - 1, z) * cos(z)) +  # jn
+        #         (hks * I * (-1)**(n + 1) *
+        #          (fn(-n - 1, z) * hk * I * sin(z) +
+        #           (-1)**(-n) * fn(n, z) * I * cos(z)))  # +-I*yn
+        #         )
+
+        return (_jn(n, z) + hks*I*_yn(n, z)).expand()
+
+    def _eval_evalf(self, prec):
+        if self.order.is_Integer:
+            return self.rewrite(besselj)._eval_evalf(prec)
+
+
+class hn1(SphericalHankelBase):
+    r"""
+    Spherical Hankel function of the first kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math:: h_\nu^(1)(z) = j_\nu(z) + i y_\nu(z),
+
+    where $j_\nu(z)$ and $y_\nu(z)$ are the spherical
+    Bessel function of the first and second kinds.
+
+    For integral orders $n$, $h_n^(1)$ is calculated using the formula:
+
+    .. math:: h_n^(1)(z) = j_{n}(z) + i (-1)^{n+1} j_{-n-1}(z)
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, hn1, hankel1, expand_func, yn, jn
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(hn1(nu, z)))
+    jn(nu, z) + I*yn(nu, z)
+    >>> print(expand_func(hn1(0, z)))
+    sin(z)/z - I*cos(z)/z
+    >>> print(expand_func(hn1(1, z)))
+    -I*sin(z)/z - cos(z)/z + sin(z)/z**2 - I*cos(z)/z**2
+    >>> hn1(nu, z).rewrite(jn)
+    (-1)**(nu + 1)*I*jn(-nu - 1, z) + jn(nu, z)
+    >>> hn1(nu, z).rewrite(yn)
+    (-1)**nu*yn(-nu - 1, z) + I*yn(nu, z)
+    >>> hn1(nu, z).rewrite(hankel1)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*hankel1(nu, z)/2
+
+    See Also
+    ========
+
+    hn2, jn, yn, hankel1, hankel2
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+
+    _hankel_kind_sign = S.One
+
+    @assume_integer_order
+    def _eval_rewrite_as_hankel1(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z))*hankel1(nu, z)
+
+
+class hn2(SphericalHankelBase):
+    r"""
+    Spherical Hankel function of the second kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math:: h_\nu^(2)(z) = j_\nu(z) - i y_\nu(z),
+
+    where $j_\nu(z)$ and $y_\nu(z)$ are the spherical
+    Bessel function of the first and second kinds.
+
+    For integral orders $n$, $h_n^(2)$ is calculated using the formula:
+
+    .. math:: h_n^(2)(z) = j_{n} - i (-1)^{n+1} j_{-n-1}(z)
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, hn2, hankel2, expand_func, jn, yn
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(hn2(nu, z)))
+    jn(nu, z) - I*yn(nu, z)
+    >>> print(expand_func(hn2(0, z)))
+    sin(z)/z + I*cos(z)/z
+    >>> print(expand_func(hn2(1, z)))
+    I*sin(z)/z - cos(z)/z + sin(z)/z**2 + I*cos(z)/z**2
+    >>> hn2(nu, z).rewrite(hankel2)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*hankel2(nu, z)/2
+    >>> hn2(nu, z).rewrite(jn)
+    -(-1)**(nu + 1)*I*jn(-nu - 1, z) + jn(nu, z)
+    >>> hn2(nu, z).rewrite(yn)
+    (-1)**nu*yn(-nu - 1, z) - I*yn(nu, z)
+
+    See Also
+    ========
+
+    hn1, jn, yn, hankel1, hankel2
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+
+    _hankel_kind_sign = -S.One
+
+    @assume_integer_order
+    def _eval_rewrite_as_hankel2(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z))*hankel2(nu, z)
+
+
+def jn_zeros(n, k, method="sympy", dps=15):
+    """
+    Zeros of the spherical Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    This returns an array of zeros of $jn$ up to the $k$-th zero.
+
+    * method = "sympy": uses `mpmath.besseljzero
+      <https://mpmath.org/doc/current/functions/bessel.html#mpmath.besseljzero>`_
+    * method = "scipy": uses the
+      `SciPy's sph_jn <https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.jn_zeros.html>`_
+      and
+      `newton <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html>`_
+      to find all
+      roots, which is faster than computing the zeros using a general
+      numerical solver, but it requires SciPy and only works with low
+      precision floating point numbers. (The function used with
+      method="sympy" is a recent addition to mpmath; before that a general
+      solver was used.)
+
+    Examples
+    ========
+
+    >>> from sympy import jn_zeros
+    >>> jn_zeros(2, 4, dps=5)
+    [5.7635, 9.095, 12.323, 15.515]
+
+    See Also
+    ========
+
+    jn, yn, besselj, besselk, bessely
+
+    Parameters
+    ==========
+
+    n : integer
+        order of Bessel function
+
+    k : integer
+        number of zeros to return
+
+
+    """
+    from math import pi as math_pi
+
+    if method == "sympy":
+        from mpmath import besseljzero
+        from mpmath.libmp.libmpf import dps_to_prec
+        prec = dps_to_prec(dps)
+        return [Expr._from_mpmath(besseljzero(S(n + 0.5)._to_mpmath(prec),
+                                              int(l)), prec)
+                for l in range(1, k + 1)]
+    elif method == "scipy":
+        from scipy.optimize import newton
+        try:
+            from scipy.special import spherical_jn
+            f = lambda x: spherical_jn(n, x)
+        except ImportError:
+            from scipy.special import sph_jn
+            f = lambda x: sph_jn(n, x)[0][-1]
+    else:
+        raise NotImplementedError("Unknown method.")
+
+    def solver(f, x):
+        if method == "scipy":
+            root = newton(f, x)
+        else:
+            raise NotImplementedError("Unknown method.")
+        return root
+
+    # we need to approximate the position of the first root:
+    root = n + math_pi
+    # determine the first root exactly:
+    root = solver(f, root)
+    roots = [root]
+    for i in range(k - 1):
+        # estimate the position of the next root using the last root + pi:
+        root = solver(f, root + math_pi)
+        roots.append(root)
+    return roots
+
+
+class AiryBase(DefinedFunction):
+    """
+    Abstract base class for Airy functions.
+
+    This class is meant to reduce code duplication.
+
+    """
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def as_real_imag(self, deep=True, **hints):
+        z = self.args[0]
+        zc = z.conjugate()
+        f = self.func
+        u = (f(z)+f(zc))/2
+        v = I*(f(zc)-f(z))/2
+        return u, v
+
+    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
+
+
+class airyai(AiryBase):
+    r"""
+    The Airy function $\operatorname{Ai}$ of the first kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Ai}(z)$ is defined to be the function
+    satisfying Airy's differential equation
+
+    .. math::
+        \frac{\mathrm{d}^2 w(z)}{\mathrm{d}z^2} - z w(z) = 0.
+
+    Equivalently, for real $z$
+
+    .. math::
+        \operatorname{Ai}(z) := \frac{1}{\pi}
+        \int_0^\infty \cos\left(\frac{t^3}{3} + z t\right) \mathrm{d}t.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airyai
+    >>> from sympy.abc import z
+
+    >>> airyai(z)
+    airyai(z)
+
+    Several special values are known:
+
+    >>> airyai(0)
+    3**(1/3)/(3*gamma(2/3))
+    >>> from sympy import oo
+    >>> airyai(oo)
+    0
+    >>> airyai(-oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airyai(z))
+    airyai(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airyai(z), z)
+    airyaiprime(z)
+    >>> diff(airyai(z), z, 2)
+    z*airyai(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airyai(z), z, 0, 3)
+    3**(5/6)*gamma(1/3)/(6*pi) - 3**(1/6)*z*gamma(2/3)/(2*pi) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airyai(-2).evalf(50)
+    0.22740742820168557599192443603787379946077222541710
+
+    Rewrite $\operatorname{Ai}(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airyai(z).rewrite(hyper)
+    -3**(2/3)*z*hyper((), (4/3,), z**3/9)/(3*gamma(1/3)) + 3**(1/3)*hyper((), (2/3,), z**3/9)/(3*gamma(2/3))
+
+    See Also
+    ========
+
+    airybi: Airy function of the second kind.
+    airyaiprime: Derivative of the Airy function of the first kind.
+    airybiprime: Derivative of the Airy function of the second kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @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.One / (3**Rational(2, 3) * gamma(Rational(2, 3)))
+        if arg.is_zero:
+            return S.One / (3**Rational(2, 3) * gamma(Rational(2, 3)))
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return airyaiprime(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return ((cbrt(3)*x)**(-n)*(cbrt(3)*x)**(n + 1)*sin(pi*(n*Rational(2, 3) + Rational(4, 3)))*factorial(n) *
+                        gamma(n/3 + Rational(2, 3))/(sin(pi*(n*Rational(2, 3) + Rational(2, 3)))*factorial(n + 1)*gamma(n/3 + Rational(1, 3))) * p)
+            else:
+                return (S.One/(3**Rational(2, 3)*pi) * gamma((n+S.One)/S(3)) * sin(Rational(2, 3)*pi*(n+S.One)) /
+                        factorial(n) * (cbrt(3)*x)**n)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return ot*sqrt(-z) * (besselj(-ot, tt*a) + besselj(ot, tt*a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return ot*sqrt(z) * (besseli(-ot, tt*a) - besseli(ot, tt*a))
+        else:
+            return ot*(Pow(a, ot)*besseli(-ot, tt*a) - z*Pow(a, -ot)*besseli(ot, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = S.One / (3**Rational(2, 3)*gamma(Rational(2, 3)))
+        pf2 = z / (root(3, 3)*gamma(Rational(1, 3)))
+        return pf1 * hyper([], [Rational(2, 3)], z**3/9) - pf2 * hyper([], [Rational(4, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is given by 03.05.16.0001.01
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryAi/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d * z**n)**m / (d**m * z**(m*n))
+                    newarg = c * d**m * z**(m*n)
+                    return S.Half * ((pf + S.One)*airyai(newarg) - (pf - S.One)/sqrt(3)*airybi(newarg))
+
+
+class airybi(AiryBase):
+    r"""
+    The Airy function $\operatorname{Bi}$ of the second kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Bi}(z)$ is defined to be the function
+    satisfying Airy's differential equation
+
+    .. math::
+        \frac{\mathrm{d}^2 w(z)}{\mathrm{d}z^2} - z w(z) = 0.
+
+    Equivalently, for real $z$
+
+    .. math::
+        \operatorname{Bi}(z) := \frac{1}{\pi}
+                 \int_0^\infty
+                   \exp\left(-\frac{t^3}{3} + z t\right)
+                   + \sin\left(\frac{t^3}{3} + z t\right) \mathrm{d}t.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airybi
+    >>> from sympy.abc import z
+
+    >>> airybi(z)
+    airybi(z)
+
+    Several special values are known:
+
+    >>> airybi(0)
+    3**(5/6)/(3*gamma(2/3))
+    >>> from sympy import oo
+    >>> airybi(oo)
+    oo
+    >>> airybi(-oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airybi(z))
+    airybi(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airybi(z), z)
+    airybiprime(z)
+    >>> diff(airybi(z), z, 2)
+    z*airybi(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airybi(z), z, 0, 3)
+    3**(1/3)*gamma(1/3)/(2*pi) + 3**(2/3)*z*gamma(2/3)/(2*pi) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airybi(-2).evalf(50)
+    -0.41230258795639848808323405461146104203453483447240
+
+    Rewrite $\operatorname{Bi}(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airybi(z).rewrite(hyper)
+    3**(1/6)*z*hyper((), (4/3,), z**3/9)/gamma(1/3) + 3**(5/6)*hyper((), (2/3,), z**3/9)/(3*gamma(2/3))
+
+    See Also
+    ========
+
+    airyai: Airy function of the first kind.
+    airyaiprime: Derivative of the Airy function of the first kind.
+    airybiprime: Derivative of the Airy function of the second kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @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.Zero
+            elif arg.is_zero:
+                return S.One / (3**Rational(1, 6) * gamma(Rational(2, 3)))
+
+        if arg.is_zero:
+            return S.One / (3**Rational(1, 6) * gamma(Rational(2, 3)))
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return airybiprime(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return (cbrt(3)*x * Abs(sin(Rational(2, 3)*pi*(n + S.One))) * factorial((n - S.One)/S(3)) /
+                        ((n + S.One) * Abs(cos(Rational(2, 3)*pi*(n + S.Half))) * factorial((n - 2)/S(3))) * p)
+            else:
+                return (S.One/(root(3, 6)*pi) * gamma((n + S.One)/S(3)) * Abs(sin(Rational(2, 3)*pi*(n + S.One))) /
+                        factorial(n) * (cbrt(3)*x)**n)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return sqrt(-z/3) * (besselj(-ot, tt*a) - besselj(ot, tt*a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return sqrt(z)/sqrt(3) * (besseli(-ot, tt*a) + besseli(ot, tt*a))
+        else:
+            b = Pow(a, ot)
+            c = Pow(a, -ot)
+            return sqrt(ot)*(b*besseli(-ot, tt*a) + z*c*besseli(ot, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = S.One / (root(3, 6)*gamma(Rational(2, 3)))
+        pf2 = z*root(3, 6) / gamma(Rational(1, 3))
+        return pf1 * hyper([], [Rational(2, 3)], z**3/9) + pf2 * hyper([], [Rational(4, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is given by 03.06.16.0001.01
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryBi/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d * z**n)**m / (d**m * z**(m*n))
+                    newarg = c * d**m * z**(m*n)
+                    return S.Half * (sqrt(3)*(S.One - pf)*airyai(newarg) + (S.One + pf)*airybi(newarg))
+
+
+class airyaiprime(AiryBase):
+    r"""
+    The derivative $\operatorname{Ai}^\prime$ of the Airy function of the first
+    kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Ai}^\prime(z)$ is defined to be the
+    function
+
+    .. math::
+        \operatorname{Ai}^\prime(z) := \frac{\mathrm{d} \operatorname{Ai}(z)}{\mathrm{d} z}.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airyaiprime
+    >>> from sympy.abc import z
+
+    >>> airyaiprime(z)
+    airyaiprime(z)
+
+    Several special values are known:
+
+    >>> airyaiprime(0)
+    -3**(2/3)/(3*gamma(1/3))
+    >>> from sympy import oo
+    >>> airyaiprime(oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airyaiprime(z))
+    airyaiprime(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airyaiprime(z), z)
+    z*airyai(z)
+    >>> diff(airyaiprime(z), z, 2)
+    z*airyaiprime(z) + airyai(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airyaiprime(z), z, 0, 3)
+    -3**(2/3)/(3*gamma(1/3)) + 3**(1/3)*z**2/(6*gamma(2/3)) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airyaiprime(-2).evalf(50)
+    0.61825902074169104140626429133247528291577794512415
+
+    Rewrite $\operatorname{Ai}^\prime(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airyaiprime(z).rewrite(hyper)
+    3**(1/3)*z**2*hyper((), (5/3,), z**3/9)/(6*gamma(2/3)) - 3**(2/3)*hyper((), (1/3,), z**3/9)/(3*gamma(1/3))
+
+    See Also
+    ========
+
+    airyai: Airy function of the first kind.
+    airybi: Airy function of the second kind.
+    airybiprime: Derivative of the Airy function of the second kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @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
+
+        if arg.is_zero:
+            return S.NegativeOne / (3**Rational(1, 3) * gamma(Rational(1, 3)))
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self.args[0]*airyai(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        z = self.args[0]._to_mpmath(prec)
+        with workprec(prec):
+            res = mp.airyai(z, derivative=1)
+        return Expr._from_mpmath(res, prec)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        tt = Rational(2, 3)
+        a = Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return z/3 * (besselj(-tt, tt*a) - besselj(tt, tt*a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = tt * Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return z/3 * (besseli(tt, a) - besseli(-tt, a))
+        else:
+            a = Pow(z, Rational(3, 2))
+            b = Pow(a, tt)
+            c = Pow(a, -tt)
+            return ot * (z**2*c*besseli(tt, tt*a) - b*besseli(-ot, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = z**2 / (2*3**Rational(2, 3)*gamma(Rational(2, 3)))
+        pf2 = 1 / (root(3, 3)*gamma(Rational(1, 3)))
+        return pf1 * hyper([], [Rational(5, 3)], z**3/9) - pf2 * hyper([], [Rational(1, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is in principle
+                # given by 03.07.16.0001.01 but note
+                # that there is an error in this formula.
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryAiPrime/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d**m * z**(n*m)) / (d * z**n)**m
+                    newarg = c * d**m * z**(n*m)
+                    return S.Half * ((pf + S.One)*airyaiprime(newarg) + (pf - S.One)/sqrt(3)*airybiprime(newarg))
+
+
+class airybiprime(AiryBase):
+    r"""
+    The derivative $\operatorname{Bi}^\prime$ of the Airy function of the first
+    kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Bi}^\prime(z)$ is defined to be the
+    function
+
+    .. math::
+        \operatorname{Bi}^\prime(z) := \frac{\mathrm{d} \operatorname{Bi}(z)}{\mathrm{d} z}.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airybiprime
+    >>> from sympy.abc import z
+
+    >>> airybiprime(z)
+    airybiprime(z)
+
+    Several special values are known:
+
+    >>> airybiprime(0)
+    3**(1/6)/gamma(1/3)
+    >>> from sympy import oo
+    >>> airybiprime(oo)
+    oo
+    >>> airybiprime(-oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airybiprime(z))
+    airybiprime(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airybiprime(z), z)
+    z*airybi(z)
+    >>> diff(airybiprime(z), z, 2)
+    z*airybiprime(z) + airybi(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airybiprime(z), z, 0, 3)
+    3**(1/6)/gamma(1/3) + 3**(5/6)*z**2/(6*gamma(2/3)) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airybiprime(-2).evalf(50)
+    0.27879516692116952268509756941098324140300059345163
+
+    Rewrite $\operatorname{Bi}^\prime(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airybiprime(z).rewrite(hyper)
+    3**(5/6)*z**2*hyper((), (5/3,), z**3/9)/(6*gamma(2/3)) + 3**(1/6)*hyper((), (1/3,), z**3/9)/gamma(1/3)
+
+    See Also
+    ========
+
+    airyai: Airy function of the first kind.
+    airybi: Airy function of the second kind.
+    airyaiprime: Derivative of the Airy function of the first kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @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.Zero
+            elif arg.is_zero:
+                return 3**Rational(1, 6) / gamma(Rational(1, 3))
+
+        if arg.is_zero:
+            return 3**Rational(1, 6) / gamma(Rational(1, 3))
+
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self.args[0]*airybi(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        z = self.args[0]._to_mpmath(prec)
+        with workprec(prec):
+            res = mp.airybi(z, derivative=1)
+        return Expr._from_mpmath(res, prec)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        tt = Rational(2, 3)
+        a = tt * Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return -z/sqrt(3) * (besselj(-tt, a) + besselj(tt, a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = tt * Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return z/sqrt(3) * (besseli(-tt, a) + besseli(tt, a))
+        else:
+            a = Pow(z, Rational(3, 2))
+            b = Pow(a, tt)
+            c = Pow(a, -tt)
+            return sqrt(ot) * (b*besseli(-tt, tt*a) + z**2*c*besseli(tt, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = z**2 / (2*root(3, 6)*gamma(Rational(2, 3)))
+        pf2 = root(3, 6) / gamma(Rational(1, 3))
+        return pf1 * hyper([], [Rational(5, 3)], z**3/9) + pf2 * hyper([], [Rational(1, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is in principle
+                # given by 03.08.16.0001.01 but note
+                # that there is an error in this formula.
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryBiPrime/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d**m * z**(n*m)) / (d * z**n)**m
+                    newarg = c * d**m * z**(n*m)
+                    return S.Half * (sqrt(3)*(pf - S.One)*airyaiprime(newarg) + (pf + S.One)*airybiprime(newarg))
+
+
+class marcumq(DefinedFunction):
+    r"""
+    The Marcum Q-function.
+
+    Explanation
+    ===========
+
+    The Marcum Q-function is defined by the meromorphic continuation of
+
+    .. math::
+        Q_m(a, b) = a^{- m + 1} \int_{b}^{\infty} x^{m} e^{- \frac{a^{2}}{2} - \frac{x^{2}}{2}} I_{m - 1}\left(a x\right)\, dx
+
+    Examples
+    ========
+
+    >>> from sympy import marcumq
+    >>> from sympy.abc import m, a, b
+    >>> marcumq(m, a, b)
+    marcumq(m, a, b)
+
+    Special values:
+
+    >>> marcumq(m, 0, b)
+    uppergamma(m, b**2/2)/gamma(m)
+    >>> marcumq(0, 0, 0)
+    0
+    >>> marcumq(0, a, 0)
+    1 - exp(-a**2/2)
+    >>> marcumq(1, a, a)
+    1/2 + exp(-a**2)*besseli(0, a**2)/2
+    >>> marcumq(2, a, a)
+    1/2 + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2)
+
+    Differentiation with respect to $a$ and $b$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(marcumq(m, a, b), a)
+    a*(-marcumq(m, a, b) + marcumq(m + 1, a, b))
+    >>> diff(marcumq(m, a, b), b)
+    -a**(1 - m)*b**m*exp(-a**2/2 - b**2/2)*besseli(m - 1, a*b)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Marcum_Q-function
+    .. [2] https://mathworld.wolfram.com/MarcumQ-Function.html
+
+    """
+
+    @classmethod
+    def eval(cls, m, a, b):
+        if a is S.Zero:
+            if m is S.Zero and b is S.Zero:
+                return S.Zero
+            return uppergamma(m, b**2 * S.Half) / gamma(m)
+
+        if m is S.Zero and b is S.Zero:
+            return 1 - 1 / exp(a**2 * S.Half)
+
+        if a == b:
+            if m is S.One:
+                return (1 + exp(-a**2) * besseli(0, a**2))*S.Half
+            if m == 2:
+                return S.Half + S.Half * exp(-a**2) * besseli(0, a**2) + exp(-a**2) * besseli(1, a**2)
+
+        if a.is_zero:
+            if m.is_zero and b.is_zero:
+                return S.Zero
+            return uppergamma(m, b**2*S.Half) / gamma(m)
+
+        if m.is_zero and b.is_zero:
+            return 1 - 1 / exp(a**2*S.Half)
+
+    def fdiff(self, argindex=2):
+        m, a, b = self.args
+        if argindex == 2:
+            return a * (-marcumq(m, a, b) + marcumq(1+m, a, b))
+        elif argindex == 3:
+            return (-b**m / a**(m-1)) * exp(-(a**2 + b**2)/2) * besseli(m-1, a*b)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Integral(self, m, a, b, **kwargs):
+        from sympy.integrals.integrals import Integral
+        x = kwargs.get('x', Dummy(uniquely_named_symbol('x').name))
+        return a ** (1 - m) * \
+               Integral(x**m * exp(-(x**2 + a**2)/2) * besseli(m-1, a*x), [x, b, S.Infinity])
+
+    def _eval_rewrite_as_Sum(self, m, a, b, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = kwargs.get('k', Dummy('k'))
+        return exp(-(a**2 + b**2) / 2) * Sum((a/b)**k * besseli(k, a*b), [k, 1-m, S.Infinity])
+
+    def _eval_rewrite_as_besseli(self, m, a, b, **kwargs):
+        if a == b:
+            if m == 1:
+                return (1 + exp(-a**2) * besseli(0, a**2)) / 2
+            if m.is_Integer and m >= 2:
+                s = sum(besseli(i, a**2) for i in range(1, m))
+                return S.Half + exp(-a**2) * besseli(0, a**2) / 2 + exp(-a**2) * s
+
+    def _eval_is_zero(self):
+        if all(arg.is_zero for arg in self.args):
+            return True
+
+class _besseli(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{besseli}(nu, z)$
+    function tractable for the Gruntz algorithm.
+
+    """
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            l = [((RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(
+                    Rational(2*nu + 1, 2), k))/((2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k))) for k in range(n)]
+            return sqrt(pi/(2))*(Add(*l)) + Order(1/z**(Rational(2*n + 1, 2)), x)
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_intractable(self, nu, z, **kwargs):
+        return exp(-z)*besseli(nu, z)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+
+class _besselk(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{besselk}(nu, z)$
+    function tractable for the Gruntz algorithm.
+
+    """
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            l = [((RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(
+                    Rational(2*nu + 1, 2), k))/((-2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k))) for k in range(n)]
+            return sqrt(pi/(2))*(Add(*l)) + Order(1/z**(Rational(2*n + 1, 2)), x)
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_intractable(self,nu, z, **kwargs):
+        return exp(z)*besselk(nu, z)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/beta_functions.py

@@ -0,0 +1,389 @@
+from sympy.core import S
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.symbol import Dummy, uniquely_named_symbol
+from sympy.functions.special.gamma_functions import gamma, digamma
+from sympy.functions.combinatorial.numbers import catalan
+from sympy.functions.elementary.complexes import conjugate
+
+# See mpmath #569 and SymPy #20569
+def betainc_mpmath_fix(a, b, x1, x2, reg=0):
+    from mpmath import betainc, mpf
+    if x1 == x2:
+        return mpf(0)
+    else:
+        return betainc(a, b, x1, x2, reg)
+
+###############################################################################
+############################ COMPLETE BETA  FUNCTION ##########################
+###############################################################################
+
+class beta(DefinedFunction):
+    r"""
+    The beta integral is called the Eulerian integral of the first kind by
+    Legendre:
+
+    .. math::
+        \mathrm{B}(x,y)  \int^{1}_{0} t^{x-1} (1-t)^{y-1} \mathrm{d}t.
+
+    Explanation
+    ===========
+
+    The Beta function or Euler's first integral is closely associated
+    with the gamma function. The Beta function is often used in probability
+    theory and mathematical statistics. It satisfies properties like:
+
+    .. math::
+        \mathrm{B}(a,1) = \frac{1}{a} \\
+        \mathrm{B}(a,b) = \mathrm{B}(b,a)  \\
+        \mathrm{B}(a,b) = \frac{\Gamma(a) \Gamma(b)}{\Gamma(a+b)}
+
+    Therefore for integral values of $a$ and $b$:
+
+    .. math::
+        \mathrm{B} = \frac{(a-1)! (b-1)!}{(a+b-1)!}
+
+    A special case of the Beta function when `x = y` is the
+    Central Beta function. It satisfies properties like:
+
+    .. math::
+        \mathrm{B}(x) = 2^{1 - 2x}\mathrm{B}(x, \frac{1}{2})
+        \mathrm{B}(x) = 2^{1 - 2x} cos(\pi x) \mathrm{B}(\frac{1}{2} - x, x)
+        \mathrm{B}(x) = \int_{0}^{1} \frac{t^x}{(1 + t)^{2x}} dt
+        \mathrm{B}(x) = \frac{2}{x} \prod_{n = 1}^{\infty} \frac{n(n + 2x)}{(n + x)^2}
+
+    Examples
+    ========
+
+    >>> from sympy import I, pi
+    >>> from sympy.abc import x, y
+
+    The Beta function obeys the mirror symmetry:
+
+    >>> from sympy import beta, conjugate
+    >>> conjugate(beta(x, y))
+    beta(conjugate(x), conjugate(y))
+
+    Differentiation with respect to both $x$ and $y$ is supported:
+
+    >>> from sympy import beta, diff
+    >>> diff(beta(x, y), x)
+    (polygamma(0, x) - polygamma(0, x + y))*beta(x, y)
+
+    >>> diff(beta(x, y), y)
+    (polygamma(0, y) - polygamma(0, x + y))*beta(x, y)
+
+    >>> diff(beta(x), x)
+    2*(polygamma(0, x) - polygamma(0, 2*x))*beta(x, x)
+
+    We can numerically evaluate the Beta function to
+    arbitrary precision for any complex numbers x and y:
+
+    >>> from sympy import beta
+    >>> beta(pi).evalf(40)
+    0.02671848900111377452242355235388489324562
+
+    >>> beta(1 + I).evalf(20)
+    -0.2112723729365330143 - 0.7655283165378005676*I
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    uppergamma: Upper incomplete gamma function.
+    lowergamma: Lower incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Beta_function
+    .. [2] https://mathworld.wolfram.com/BetaFunction.html
+    .. [3] https://dlmf.nist.gov/5.12
+
+    """
+    unbranched = True
+
+    def fdiff(self, argindex):
+        x, y = self.args
+        if argindex == 1:
+            # Diff wrt x
+            return beta(x, y)*(digamma(x) - digamma(x + y))
+        elif argindex == 2:
+            # Diff wrt y
+            return beta(x, y)*(digamma(y) - digamma(x + y))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, y=None):
+        if y is None:
+            return beta(x, x)
+        if x.is_Number and y.is_Number:
+            return beta(x, y, evaluate=False).doit()
+
+    def doit(self, **hints):
+        x = xold = self.args[0]
+        # Deal with unevaluated single argument beta
+        single_argument = len(self.args) == 1
+        y = yold = self.args[0] if single_argument else self.args[1]
+        if hints.get('deep', True):
+            x = x.doit(**hints)
+            y = y.doit(**hints)
+        if y.is_zero or x.is_zero:
+            return S.ComplexInfinity
+        if y is S.One:
+            return 1/x
+        if x is S.One:
+            return 1/y
+        if y == x + 1:
+            return 1/(x*y*catalan(x))
+        s = x + y
+        if (s.is_integer and s.is_negative and x.is_integer is False and
+            y.is_integer is False):
+            return S.Zero
+        if x == xold and y == yold and not single_argument:
+            return self
+        return beta(x, y)
+
+    def _eval_expand_func(self, **hints):
+        x, y = self.args
+        return gamma(x)*gamma(y) / gamma(x + y)
+
+    def _eval_is_real(self):
+        return self.args[0].is_real and self.args[1].is_real
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate(), self.args[1].conjugate())
+
+    def _eval_rewrite_as_gamma(self, x, y, piecewise=True, **kwargs):
+        return self._eval_expand_func(**kwargs)
+
+    def _eval_rewrite_as_Integral(self, x, y, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [x, y]).name)
+        return Integral(t**(x - 1)*(1 - t)**(y - 1), (t, 0, 1))
+
+###############################################################################
+########################## INCOMPLETE BETA FUNCTION ###########################
+###############################################################################
+
+class betainc(DefinedFunction):
+    r"""
+    The Generalized Incomplete Beta function is defined as
+
+    .. math::
+        \mathrm{B}_{(x_1, x_2)}(a, b) = \int_{x_1}^{x_2} t^{a - 1} (1 - t)^{b - 1} dt
+
+    The Incomplete Beta function is a special case
+    of the Generalized Incomplete Beta function :
+
+    .. math:: \mathrm{B}_z (a, b) = \mathrm{B}_{(0, z)}(a, b)
+
+    The Incomplete Beta function satisfies :
+
+    .. math:: \mathrm{B}_z (a, b) = (-1)^a \mathrm{B}_{\frac{z}{z - 1}} (a, 1 - a - b)
+
+    The Beta function is a special case of the Incomplete Beta function :
+
+    .. math:: \mathrm{B}(a, b) = \mathrm{B}_{1}(a, b)
+
+    Examples
+    ========
+
+    >>> from sympy import betainc, symbols, conjugate
+    >>> a, b, x, x1, x2 = symbols('a b x x1 x2')
+
+    The Generalized Incomplete Beta function is given by:
+
+    >>> betainc(a, b, x1, x2)
+    betainc(a, b, x1, x2)
+
+    The Incomplete Beta function can be obtained as follows:
+
+    >>> betainc(a, b, 0, x)
+    betainc(a, b, 0, x)
+
+    The Incomplete Beta function obeys the mirror symmetry:
+
+    >>> conjugate(betainc(a, b, x1, x2))
+    betainc(conjugate(a), conjugate(b), conjugate(x1), conjugate(x2))
+
+    We can numerically evaluate the Incomplete Beta function to
+    arbitrary precision for any complex numbers a, b, x1 and x2:
+
+    >>> from sympy import betainc, I
+    >>> betainc(2, 3, 4, 5).evalf(10)
+    56.08333333
+    >>> betainc(0.75, 1 - 4*I, 0, 2 + 3*I).evalf(25)
+    0.2241657956955709603655887 + 0.3619619242700451992411724*I
+
+    The Generalized Incomplete Beta function can be expressed
+    in terms of the Generalized Hypergeometric function.
+
+    >>> from sympy import hyper
+    >>> betainc(a, b, x1, x2).rewrite(hyper)
+    (-x1**a*hyper((a, 1 - b), (a + 1,), x1) + x2**a*hyper((a, 1 - b), (a + 1,), x2))/a
+
+    See Also
+    ========
+
+    beta: Beta function
+    hyper: Generalized Hypergeometric function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function
+    .. [2] https://dlmf.nist.gov/8.17
+    .. [3] https://functions.wolfram.com/GammaBetaErf/Beta4/
+    .. [4] https://functions.wolfram.com/GammaBetaErf/BetaRegularized4/02/
+
+    """
+    nargs = 4
+    unbranched = True
+
+    def fdiff(self, argindex):
+        a, b, x1, x2 = self.args
+        if argindex == 3:
+            # Diff wrt x1
+            return -(1 - x1)**(b - 1)*x1**(a - 1)
+        elif argindex == 4:
+            # Diff wrt x2
+            return (1 - x2)**(b - 1)*x2**(a - 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_mpmath(self):
+        return betainc_mpmath_fix, self.args
+
+    def _eval_is_real(self):
+        if all(arg.is_real for arg in self.args):
+            return True
+
+    def _eval_conjugate(self):
+        return self.func(*map(conjugate, self.args))
+
+    def _eval_rewrite_as_Integral(self, a, b, x1, x2, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [a, b, x1, x2]).name)
+        return Integral(t**(a - 1)*(1 - t)**(b - 1), (t, x1, x2))
+
+    def _eval_rewrite_as_hyper(self, a, b, x1, x2, **kwargs):
+        from sympy.functions.special.hyper import hyper
+        return (x2**a * hyper((a, 1 - b), (a + 1,), x2) - x1**a * hyper((a, 1 - b), (a + 1,), x1)) / a
+
+###############################################################################
+#################### REGULARIZED INCOMPLETE BETA FUNCTION #####################
+###############################################################################
+
+class betainc_regularized(DefinedFunction):
+    r"""
+    The Generalized Regularized Incomplete Beta function is given by
+
+    .. math::
+        \mathrm{I}_{(x_1, x_2)}(a, b) = \frac{\mathrm{B}_{(x_1, x_2)}(a, b)}{\mathrm{B}(a, b)}
+
+    The Regularized Incomplete Beta function is a special case
+    of the Generalized Regularized Incomplete Beta function :
+
+    .. math:: \mathrm{I}_z (a, b) = \mathrm{I}_{(0, z)}(a, b)
+
+    The Regularized Incomplete Beta function is the cumulative distribution
+    function of the beta distribution.
+
+    Examples
+    ========
+
+    >>> from sympy import betainc_regularized, symbols, conjugate
+    >>> a, b, x, x1, x2 = symbols('a b x x1 x2')
+
+    The Generalized Regularized Incomplete Beta
+    function is given by:
+
+    >>> betainc_regularized(a, b, x1, x2)
+    betainc_regularized(a, b, x1, x2)
+
+    The Regularized Incomplete Beta function
+    can be obtained as follows:
+
+    >>> betainc_regularized(a, b, 0, x)
+    betainc_regularized(a, b, 0, x)
+
+    The Regularized Incomplete Beta function
+    obeys the mirror symmetry:
+
+    >>> conjugate(betainc_regularized(a, b, x1, x2))
+    betainc_regularized(conjugate(a), conjugate(b), conjugate(x1), conjugate(x2))
+
+    We can numerically evaluate the Regularized Incomplete Beta function
+    to arbitrary precision for any complex numbers a, b, x1 and x2:
+
+    >>> from sympy import betainc_regularized, pi, E
+    >>> betainc_regularized(1, 2, 0, 0.25).evalf(10)
+    0.4375000000
+    >>> betainc_regularized(pi, E, 0, 1).evalf(5)
+    1.00000
+
+    The Generalized Regularized Incomplete Beta function can be
+    expressed in terms of the Generalized Hypergeometric function.
+
+    >>> from sympy import hyper
+    >>> betainc_regularized(a, b, x1, x2).rewrite(hyper)
+    (-x1**a*hyper((a, 1 - b), (a + 1,), x1) + x2**a*hyper((a, 1 - b), (a + 1,), x2))/(a*beta(a, b))
+
+    See Also
+    ========
+
+    beta: Beta function
+    hyper: Generalized Hypergeometric function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function
+    .. [2] https://dlmf.nist.gov/8.17
+    .. [3] https://functions.wolfram.com/GammaBetaErf/Beta4/
+    .. [4] https://functions.wolfram.com/GammaBetaErf/BetaRegularized4/02/
+
+    """
+    nargs = 4
+    unbranched = True
+
+    def __new__(cls, a, b, x1, x2):
+        return super().__new__(cls, a, b, x1, x2)
+
+    def _eval_mpmath(self):
+        return betainc_mpmath_fix, (*self.args, S(1))
+
+    def fdiff(self, argindex):
+        a, b, x1, x2 = self.args
+        if argindex == 3:
+            # Diff wrt x1
+            return -(1 - x1)**(b - 1)*x1**(a - 1) / beta(a, b)
+        elif argindex == 4:
+            # Diff wrt x2
+            return (1 - x2)**(b - 1)*x2**(a - 1) / beta(a, b)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_real(self):
+        if all(arg.is_real for arg in self.args):
+            return True
+
+    def _eval_conjugate(self):
+        return self.func(*map(conjugate, self.args))
+
+    def _eval_rewrite_as_Integral(self, a, b, x1, x2, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [a, b, x1, x2]).name)
+        integrand = t**(a - 1)*(1 - t)**(b - 1)
+        expr = Integral(integrand, (t, x1, x2))
+        return expr / Integral(integrand, (t, 0, 1))
+
+    def _eval_rewrite_as_hyper(self, a, b, x1, x2, **kwargs):
+        from sympy.functions.special.hyper import hyper
+        expr = (x2**a * hyper((a, 1 - b), (a + 1,), x2) - x1**a * hyper((a, 1 - b), (a + 1,), x1)) / a
+        return expr / beta(a, b)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/bsplines.py

@@ -0,0 +1,348 @@
+from sympy.core import S, sympify
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions import Piecewise, piecewise_fold
+from sympy.logic.boolalg import And
+from sympy.sets.sets import Interval
+
+from functools import lru_cache
+
+
+def _ivl(cond, x):
+    """return the interval corresponding to the condition
+
+    Conditions in spline's Piecewise give the range over
+    which an expression is valid like (lo <= x) & (x <= hi).
+    This function returns (lo, hi).
+    """
+    if isinstance(cond, And) and len(cond.args) == 2:
+        a, b = cond.args
+        if a.lts == x:
+            a, b = b, a
+        return a.lts, b.gts
+    raise TypeError('unexpected cond type: %s' % cond)
+
+
+def _add_splines(c, b1, d, b2, x):
+    """Construct c*b1 + d*b2."""
+
+    if S.Zero in (b1, c):
+        rv = piecewise_fold(d * b2)
+    elif S.Zero in (b2, d):
+        rv = piecewise_fold(c * b1)
+    else:
+        new_args = []
+        # Just combining the Piecewise without any fancy optimization
+        p1 = piecewise_fold(c * b1)
+        p2 = piecewise_fold(d * b2)
+
+        # Search all Piecewise arguments except (0, True)
+        p2args = list(p2.args[:-1])
+
+        # This merging algorithm assumes the conditions in
+        # p1 and p2 are sorted
+        for arg in p1.args[:-1]:
+            expr = arg.expr
+            cond = arg.cond
+
+            lower = _ivl(cond, x)[0]
+
+            # Check p2 for matching conditions that can be merged
+            for i, arg2 in enumerate(p2args):
+                expr2 = arg2.expr
+                cond2 = arg2.cond
+
+                lower_2, upper_2 = _ivl(cond2, x)
+                if cond2 == cond:
+                    # Conditions match, join expressions
+                    expr += expr2
+                    # Remove matching element
+                    del p2args[i]
+                    # No need to check the rest
+                    break
+                elif lower_2 < lower and upper_2 <= lower:
+                    # Check if arg2 condition smaller than arg1,
+                    # add to new_args by itself (no match expected
+                    # in p1)
+                    new_args.append(arg2)
+                    del p2args[i]
+                    break
+
+            # Checked all, add expr and cond
+            new_args.append((expr, cond))
+
+        # Add remaining items from p2args
+        new_args.extend(p2args)
+
+        # Add final (0, True)
+        new_args.append((0, True))
+
+        rv = Piecewise(*new_args, evaluate=False)
+
+    return rv.expand()
+
+
+@lru_cache(maxsize=128)
+def bspline_basis(d, knots, n, x):
+    """
+    The $n$-th B-spline at $x$ of degree $d$ with knots.
+
+    Explanation
+    ===========
+
+    B-Splines are piecewise polynomials of degree $d$. They are defined on a
+    set of knots, which is a sequence of integers or floats.
+
+    Examples
+    ========
+
+    The 0th degree splines have a value of 1 on a single interval:
+
+        >>> from sympy import bspline_basis
+        >>> from sympy.abc import x
+        >>> d = 0
+        >>> knots = tuple(range(5))
+        >>> bspline_basis(d, knots, 0, x)
+        Piecewise((1, (x >= 0) & (x <= 1)), (0, True))
+
+    For a given ``(d, knots)`` there are ``len(knots)-d-1`` B-splines
+    defined, that are indexed by ``n`` (starting at 0).
+
+    Here is an example of a cubic B-spline:
+
+        >>> bspline_basis(3, tuple(range(5)), 0, x)
+        Piecewise((x**3/6, (x >= 0) & (x <= 1)),
+                  (-x**3/2 + 2*x**2 - 2*x + 2/3,
+                  (x >= 1) & (x <= 2)),
+                  (x**3/2 - 4*x**2 + 10*x - 22/3,
+                  (x >= 2) & (x <= 3)),
+                  (-x**3/6 + 2*x**2 - 8*x + 32/3,
+                  (x >= 3) & (x <= 4)),
+                  (0, True))
+
+    By repeating knot points, you can introduce discontinuities in the
+    B-splines and their derivatives:
+
+        >>> d = 1
+        >>> knots = (0, 0, 2, 3, 4)
+        >>> bspline_basis(d, knots, 0, x)
+        Piecewise((1 - x/2, (x >= 0) & (x <= 2)), (0, True))
+
+    It is quite time consuming to construct and evaluate B-splines. If
+    you need to evaluate a B-spline many times, it is best to lambdify them
+    first:
+
+        >>> from sympy import lambdify
+        >>> d = 3
+        >>> knots = tuple(range(10))
+        >>> b0 = bspline_basis(d, knots, 0, x)
+        >>> f = lambdify(x, b0)
+        >>> y = f(0.5)
+
+    Parameters
+    ==========
+
+    d : integer
+        degree of bspline
+
+    knots : list of integer values
+        list of knots points of bspline
+
+    n : integer
+        $n$-th B-spline
+
+    x : symbol
+
+    See Also
+    ========
+
+    bspline_basis_set
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/B-spline
+
+    """
+    # make sure x has no assumptions so conditions don't evaluate
+    xvar = x
+    x = Dummy()
+
+    knots = tuple(sympify(k) for k in knots)
+    d = int(d)
+    n = int(n)
+    n_knots = len(knots)
+    n_intervals = n_knots - 1
+    if n + d + 1 > n_intervals:
+        raise ValueError("n + d + 1 must not exceed len(knots) - 1")
+    if d == 0:
+        result = Piecewise(
+            (S.One, Interval(knots[n], knots[n + 1]).contains(x)), (0, True)
+        )
+    elif d > 0:
+        denom = knots[n + d + 1] - knots[n + 1]
+        if denom != S.Zero:
+            B = (knots[n + d + 1] - x) / denom
+            b2 = bspline_basis(d - 1, knots, n + 1, x)
+        else:
+            b2 = B = S.Zero
+
+        denom = knots[n + d] - knots[n]
+        if denom != S.Zero:
+            A = (x - knots[n]) / denom
+            b1 = bspline_basis(d - 1, knots, n, x)
+        else:
+            b1 = A = S.Zero
+
+        result = _add_splines(A, b1, B, b2, x)
+    else:
+        raise ValueError("degree must be non-negative: %r" % n)
+
+    # return result with user-given x
+    return result.xreplace({x: xvar})
+
+
+def bspline_basis_set(d, knots, x):
+    """
+    Return the ``len(knots)-d-1`` B-splines at *x* of degree *d*
+    with *knots*.
+
+    Explanation
+    ===========
+
+    This function returns a list of piecewise polynomials that are the
+    ``len(knots)-d-1`` B-splines of degree *d* for the given knots.
+    This function calls ``bspline_basis(d, knots, n, x)`` for different
+    values of *n*.
+
+    Examples
+    ========
+
+    >>> from sympy import bspline_basis_set
+    >>> from sympy.abc import x
+    >>> d = 2
+    >>> knots = range(5)
+    >>> splines = bspline_basis_set(d, knots, x)
+    >>> splines
+    [Piecewise((x**2/2, (x >= 0) & (x <= 1)),
+               (-x**2 + 3*x - 3/2, (x >= 1) & (x <= 2)),
+               (x**2/2 - 3*x + 9/2, (x >= 2) & (x <= 3)),
+               (0, True)),
+    Piecewise((x**2/2 - x + 1/2, (x >= 1) & (x <= 2)),
+              (-x**2 + 5*x - 11/2, (x >= 2) & (x <= 3)),
+              (x**2/2 - 4*x + 8, (x >= 3) & (x <= 4)),
+              (0, True))]
+
+    Parameters
+    ==========
+
+    d : integer
+        degree of bspline
+
+    knots : list of integers
+        list of knots points of bspline
+
+    x : symbol
+
+    See Also
+    ========
+
+    bspline_basis
+
+    """
+    n_splines = len(knots) - d - 1
+    return [bspline_basis(d, tuple(knots), i, x) for i in range(n_splines)]
+
+
+def interpolating_spline(d, x, X, Y):
+    """
+    Return spline of degree *d*, passing through the given *X*
+    and *Y* values.
+
+    Explanation
+    ===========
+
+    This function returns a piecewise function such that each part is
+    a polynomial of degree not greater than *d*. The value of *d*
+    must be 1 or greater and the values of *X* must be strictly
+    increasing.
+
+    Examples
+    ========
+
+    >>> from sympy import interpolating_spline
+    >>> from sympy.abc import x
+    >>> interpolating_spline(1, x, [1, 2, 4, 7], [3, 6, 5, 7])
+    Piecewise((3*x, (x >= 1) & (x <= 2)),
+            (7 - x/2, (x >= 2) & (x <= 4)),
+            (2*x/3 + 7/3, (x >= 4) & (x <= 7)))
+    >>> interpolating_spline(3, x, [-2, 0, 1, 3, 4], [4, 2, 1, 1, 3])
+    Piecewise((7*x**3/117 + 7*x**2/117 - 131*x/117 + 2, (x >= -2) & (x <= 1)),
+            (10*x**3/117 - 2*x**2/117 - 122*x/117 + 77/39, (x >= 1) & (x <= 4)))
+
+    Parameters
+    ==========
+
+    d : integer
+        Degree of Bspline strictly greater than equal to one
+
+    x : symbol
+
+    X : list of strictly increasing real values
+        list of X coordinates through which the spline passes
+
+    Y : list of real values
+        list of corresponding Y coordinates through which the spline passes
+
+    See Also
+    ========
+
+    bspline_basis_set, interpolating_poly
+
+    """
+    from sympy.solvers.solveset import linsolve
+    from sympy.matrices.dense import Matrix
+
+    # Input sanitization
+    d = sympify(d)
+    if not (d.is_Integer and d.is_positive):
+        raise ValueError("Spline degree must be a positive integer, not %s." % d)
+    if len(X) != len(Y):
+        raise ValueError("Number of X and Y coordinates must be the same.")
+    if len(X) < d + 1:
+        raise ValueError("Degree must be less than the number of control points.")
+    if not all(a < b for a, b in zip(X, X[1:])):
+        raise ValueError("The x-coordinates must be strictly increasing.")
+    X = [sympify(i) for i in X]
+
+    # Evaluating knots value
+    if d.is_odd:
+        j = (d + 1) // 2
+        interior_knots = X[j:-j]
+    else:
+        j = d // 2
+        interior_knots = [
+            (a + b)/2 for a, b in zip(X[j : -j - 1], X[j + 1 : -j])
+        ]
+
+    knots = [X[0]] * (d + 1) + list(interior_knots) + [X[-1]] * (d + 1)
+
+    basis = bspline_basis_set(d, knots, x)
+
+    A = [[b.subs(x, v) for b in basis] for v in X]
+
+    coeff = linsolve((Matrix(A), Matrix(Y)), symbols("c0:{}".format(len(X)), cls=Dummy))
+    coeff = list(coeff)[0]
+    intervals = {c for b in basis for (e, c) in b.args if c != True}
+
+    # Sorting the intervals
+    #  ival contains the end-points of each interval
+    intervals = sorted(intervals, key=lambda c: _ivl(c, x))
+
+    basis_dicts = [{c: e for (e, c) in b.args} for b in basis]
+    spline = []
+    for i in intervals:
+        piece = sum(
+            [c * d.get(i, S.Zero) for (c, d) in zip(coeff, basis_dicts)], S.Zero
+        )
+        spline.append((piece, i))
+    return Piecewise(*spline)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/delta_functions.py

@@ -0,0 +1,664 @@
+from sympy.core import S, diff
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.logic import fuzzy_not
+from sympy.core.relational import Eq, Ne
+from sympy.functions.elementary.complexes import im, sign
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.polys.polyerrors import PolynomialError
+from sympy.polys.polyroots import roots
+from sympy.utilities.misc import filldedent
+
+
+###############################################################################
+################################ DELTA FUNCTION ###############################
+###############################################################################
+
+
+class DiracDelta(DefinedFunction):
+    r"""
+    The DiracDelta function and its derivatives.
+
+    Explanation
+    ===========
+
+    DiracDelta is not an ordinary function. It can be rigorously defined either
+    as a distribution or as a measure.
+
+    DiracDelta only makes sense in definite integrals, and in particular,
+    integrals of the form ``Integral(f(x)*DiracDelta(x - x0), (x, a, b))``,
+    where it equals ``f(x0)`` if ``a <= x0 <= b`` and ``0`` otherwise. Formally,
+    DiracDelta acts in some ways like a function that is ``0`` everywhere except
+    at ``0``, but in many ways it also does not. It can often be useful to treat
+    DiracDelta in formal ways, building up and manipulating expressions with
+    delta functions (which may eventually be integrated), but care must be taken
+    to not treat it as a real function. SymPy's ``oo`` is similar. It only
+    truly makes sense formally in certain contexts (such as integration limits),
+    but SymPy allows its use everywhere, and it tries to be consistent with
+    operations on it (like ``1/oo``), but it is easy to get into trouble and get
+    wrong results if ``oo`` is treated too much like a number. Similarly, if
+    DiracDelta is treated too much like a function, it is easy to get wrong or
+    nonsensical results.
+
+    DiracDelta function has the following properties:
+
+    1) $\frac{d}{d x} \theta(x) = \delta(x)$
+    2) $\int_{-\infty}^\infty \delta(x - a)f(x)\, dx = f(a)$ and $\int_{a-
+       \epsilon}^{a+\epsilon} \delta(x - a)f(x)\, dx = f(a)$
+    3) $\delta(x) = 0$ for all $x \neq 0$
+    4) $\delta(g(x)) = \sum_i \frac{\delta(x - x_i)}{\|g'(x_i)\|}$ where $x_i$
+       are the roots of $g$
+    5) $\delta(-x) = \delta(x)$
+
+    Derivatives of ``k``-th order of DiracDelta have the following properties:
+
+    6) $\delta(x, k) = 0$ for all $x \neq 0$
+    7) $\delta(-x, k) = -\delta(x, k)$ for odd $k$
+    8) $\delta(-x, k) = \delta(x, k)$ for even $k$
+
+    Examples
+    ========
+
+    >>> from sympy import DiracDelta, diff, pi
+    >>> from sympy.abc import x, y
+
+    >>> DiracDelta(x)
+    DiracDelta(x)
+    >>> DiracDelta(1)
+    0
+    >>> DiracDelta(-1)
+    0
+    >>> DiracDelta(pi)
+    0
+    >>> DiracDelta(x - 4).subs(x, 4)
+    DiracDelta(0)
+    >>> diff(DiracDelta(x))
+    DiracDelta(x, 1)
+    >>> diff(DiracDelta(x - 1), x, 2)
+    DiracDelta(x - 1, 2)
+    >>> diff(DiracDelta(x**2 - 1), x, 2)
+    2*(2*x**2*DiracDelta(x**2 - 1, 2) + DiracDelta(x**2 - 1, 1))
+    >>> DiracDelta(3*x).is_simple(x)
+    True
+    >>> DiracDelta(x**2).is_simple(x)
+    False
+    >>> DiracDelta((x**2 - 1)*y).expand(diracdelta=True, wrt=x)
+    DiracDelta(x - 1)/(2*Abs(y)) + DiracDelta(x + 1)/(2*Abs(y))
+
+    See Also
+    ========
+
+    Heaviside
+    sympy.simplify.simplify.simplify, is_simple
+    sympy.functions.special.tensor_functions.KroneckerDelta
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/DeltaFunction.html
+
+    """
+
+    is_real = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of a DiracDelta Function.
+
+        Explanation
+        ===========
+
+        The difference between ``diff()`` and ``fdiff()`` is: ``diff()`` is the
+        user-level function and ``fdiff()`` is an object method. ``fdiff()`` is
+        a convenience method available in the ``Function`` class. It returns
+        the derivative of the function without considering the chain rule.
+        ``diff(function, x)`` calls ``Function._eval_derivative`` which in turn
+        calls ``fdiff()`` internally to compute the derivative of the function.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, diff
+        >>> from sympy.abc import x
+
+        >>> DiracDelta(x).fdiff()
+        DiracDelta(x, 1)
+
+        >>> DiracDelta(x, 1).fdiff()
+        DiracDelta(x, 2)
+
+        >>> DiracDelta(x**2 - 1).fdiff()
+        DiracDelta(x**2 - 1, 1)
+
+        >>> diff(DiracDelta(x, 1)).fdiff()
+        DiracDelta(x, 3)
+
+        Parameters
+        ==========
+
+        argindex : integer
+            degree of derivative
+
+        """
+        if argindex == 1:
+            #I didn't know if there is a better way to handle default arguments
+            k = 0
+            if len(self.args) > 1:
+                k = self.args[1]
+            return self.func(self.args[0], k + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg, k=S.Zero):
+        """
+        Returns a simplified form or a value of DiracDelta depending on the
+        argument passed by the DiracDelta object.
+
+        Explanation
+        ===========
+
+        The ``eval()`` method is automatically called when the ``DiracDelta``
+        class is about to be instantiated and it returns either some simplified
+        instance or the unevaluated instance depending on the argument passed.
+        In other words, ``eval()`` method is not needed to be called explicitly,
+        it is being called and evaluated once the object is called.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, S
+        >>> from sympy.abc import x
+
+        >>> DiracDelta(x)
+        DiracDelta(x)
+
+        >>> DiracDelta(-x, 1)
+        -DiracDelta(x, 1)
+
+        >>> DiracDelta(1)
+        0
+
+        >>> DiracDelta(5, 1)
+        0
+
+        >>> DiracDelta(0)
+        DiracDelta(0)
+
+        >>> DiracDelta(-1)
+        0
+
+        >>> DiracDelta(S.NaN)
+        nan
+
+        >>> DiracDelta(x - 100).subs(x, 5)
+        0
+
+        >>> DiracDelta(x - 100).subs(x, 100)
+        DiracDelta(0)
+
+        Parameters
+        ==========
+
+        k : integer
+            order of derivative
+
+        arg : argument passed to DiracDelta
+
+        """
+        if not k.is_Integer or k.is_negative:
+            raise ValueError("Error: the second argument of DiracDelta must be \
+            a non-negative integer, %s given instead." % (k,))
+        if arg is S.NaN:
+            return S.NaN
+        if arg.is_nonzero:
+            return S.Zero
+        if fuzzy_not(im(arg).is_zero):
+            raise ValueError(filldedent('''
+                Function defined only for Real Values.
+                Complex part: %s  found in %s .''' % (
+                repr(im(arg)), repr(arg))))
+        c, nc = arg.args_cnc()
+        if c and c[0] is S.NegativeOne:
+            # keep this fast and simple instead of using
+            # could_extract_minus_sign
+            if k.is_odd:
+                return -cls(-arg, k)
+            elif k.is_even:
+                return cls(-arg, k) if k else cls(-arg)
+        elif k.is_zero:
+            return cls(arg, evaluate=False)
+
+    def _eval_expand_diracdelta(self, **hints):
+        """
+        Compute a simplified representation of the function using
+        property number 4. Pass ``wrt`` as a hint to expand the expression
+        with respect to a particular variable.
+
+        Explanation
+        ===========
+
+        ``wrt`` is:
+
+        - a variable with respect to which a DiracDelta expression will
+        get expanded.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta
+        >>> from sympy.abc import x, y
+
+        >>> DiracDelta(x*y).expand(diracdelta=True, wrt=x)
+        DiracDelta(x)/Abs(y)
+        >>> DiracDelta(x*y).expand(diracdelta=True, wrt=y)
+        DiracDelta(y)/Abs(x)
+
+        >>> DiracDelta(x**2 + x - 2).expand(diracdelta=True, wrt=x)
+        DiracDelta(x - 1)/3 + DiracDelta(x + 2)/3
+
+        See Also
+        ========
+
+        is_simple, Diracdelta
+
+        """
+        wrt = hints.get('wrt', None)
+        if wrt is None:
+            free = self.free_symbols
+            if len(free) == 1:
+                wrt = free.pop()
+            else:
+                raise TypeError(filldedent('''
+            When there is more than 1 free symbol or variable in the expression,
+            the 'wrt' keyword is required as a hint to expand when using the
+            DiracDelta hint.'''))
+
+        if not self.args[0].has(wrt) or (len(self.args) > 1 and self.args[1] != 0 ):
+            return self
+        try:
+            argroots = roots(self.args[0], wrt)
+            result = 0
+            valid = True
+            darg = abs(diff(self.args[0], wrt))
+            for r, m in argroots.items():
+                if r.is_real is not False and m == 1:
+                    result += self.func(wrt - r)/darg.subs(wrt, r)
+                else:
+                    # don't handle non-real and if m != 1 then
+                    # a polynomial will have a zero in the derivative (darg)
+                    # at r
+                    valid = False
+                    break
+            if valid:
+                return result
+        except PolynomialError:
+            pass
+        return self
+
+    def is_simple(self, x):
+        """
+        Tells whether the argument(args[0]) of DiracDelta is a linear
+        expression in *x*.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, cos
+        >>> from sympy.abc import x, y
+
+        >>> DiracDelta(x*y).is_simple(x)
+        True
+        >>> DiracDelta(x*y).is_simple(y)
+        True
+
+        >>> DiracDelta(x**2 + x - 2).is_simple(x)
+        False
+
+        >>> DiracDelta(cos(x)).is_simple(x)
+        False
+
+        Parameters
+        ==========
+
+        x : can be a symbol
+
+        See Also
+        ========
+
+        sympy.simplify.simplify.simplify, DiracDelta
+
+        """
+        p = self.args[0].as_poly(x)
+        if p:
+            return p.degree() == 1
+        return False
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        """
+        Represents DiracDelta in a piecewise form.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, Piecewise, Symbol
+        >>> x = Symbol('x')
+
+        >>> DiracDelta(x).rewrite(Piecewise)
+        Piecewise((DiracDelta(0), Eq(x, 0)), (0, True))
+
+        >>> DiracDelta(x - 5).rewrite(Piecewise)
+        Piecewise((DiracDelta(0), Eq(x, 5)), (0, True))
+
+        >>> DiracDelta(x**2 - 5).rewrite(Piecewise)
+           Piecewise((DiracDelta(0), Eq(x**2, 5)), (0, True))
+
+        >>> DiracDelta(x - 5, 4).rewrite(Piecewise)
+        DiracDelta(x - 5, 4)
+
+        """
+        if len(args) == 1:
+            return Piecewise((DiracDelta(0), Eq(args[0], 0)), (0, True))
+
+    def _eval_rewrite_as_SingularityFunction(self, *args, **kwargs):
+        """
+        Returns the DiracDelta expression written in the form of Singularity
+        Functions.
+
+        """
+        from sympy.solvers import solve
+        from sympy.functions.special.singularity_functions import SingularityFunction
+        if self == DiracDelta(0):
+            return SingularityFunction(0, 0, -1)
+        if self == DiracDelta(0, 1):
+            return SingularityFunction(0, 0, -2)
+        free = self.free_symbols
+        if len(free) == 1:
+            x = (free.pop())
+            if len(args) == 1:
+                return SingularityFunction(x, solve(args[0], x)[0], -1)
+            return SingularityFunction(x, solve(args[0], x)[0], -args[1] - 1)
+        else:
+            # I don't know how to handle the case for DiracDelta expressions
+            # having arguments with more than one variable.
+            raise TypeError(filldedent('''
+                rewrite(SingularityFunction) does not support
+                arguments with more that one variable.'''))
+
+
+###############################################################################
+############################## HEAVISIDE FUNCTION #############################
+###############################################################################
+
+
+class Heaviside(DefinedFunction):
+    r"""
+    Heaviside step function.
+
+    Explanation
+    ===========
+
+    The Heaviside step function has the following properties:
+
+    1) $\frac{d}{d x} \theta(x) = \delta(x)$
+    2) $\theta(x) = \begin{cases} 0 & \text{for}\: x < 0 \\ \frac{1}{2} &
+       \text{for}\: x = 0 \\1 & \text{for}\: x > 0 \end{cases}$
+    3) $\frac{d}{d x} \max(x, 0) = \theta(x)$
+
+    Heaviside(x) is printed as $\theta(x)$ with the SymPy LaTeX printer.
+
+    The value at 0 is set differently in different fields. SymPy uses 1/2,
+    which is a convention from electronics and signal processing, and is
+    consistent with solving improper integrals by Fourier transform and
+    convolution.
+
+    To specify a different value of Heaviside at ``x=0``, a second argument
+    can be given. Using ``Heaviside(x, nan)`` gives an expression that will
+    evaluate to nan for x=0.
+
+    .. versionchanged:: 1.9 ``Heaviside(0)`` now returns 1/2 (before: undefined)
+
+    Examples
+    ========
+
+    >>> from sympy import Heaviside, nan
+    >>> from sympy.abc import x
+    >>> Heaviside(9)
+    1
+    >>> Heaviside(-9)
+    0
+    >>> Heaviside(0)
+    1/2
+    >>> Heaviside(0, nan)
+    nan
+    >>> (Heaviside(x) + 1).replace(Heaviside(x), Heaviside(x, 1))
+    Heaviside(x, 1) + 1
+
+    See Also
+    ========
+
+    DiracDelta
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HeavisideStepFunction.html
+    .. [2] https://dlmf.nist.gov/1.16#iv
+
+    """
+
+    is_real = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of a Heaviside Function.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, diff
+        >>> from sympy.abc import x
+
+        >>> Heaviside(x).fdiff()
+        DiracDelta(x)
+
+        >>> Heaviside(x**2 - 1).fdiff()
+        DiracDelta(x**2 - 1)
+
+        >>> diff(Heaviside(x)).fdiff()
+        DiracDelta(x, 1)
+
+        Parameters
+        ==========
+
+        argindex : integer
+            order of derivative
+
+        """
+        if argindex == 1:
+            return DiracDelta(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def __new__(cls, arg, H0=S.Half, **options):
+        if isinstance(H0, Heaviside) and len(H0.args) == 1:
+            H0 = S.Half
+        return super(cls, cls).__new__(cls, arg, H0, **options)
+
+    @property
+    def pargs(self):
+        """Args without default S.Half"""
+        args = self.args
+        if args[1] is S.Half:
+            args = args[:1]
+        return args
+
+    @classmethod
+    def eval(cls, arg, H0=S.Half):
+        """
+        Returns a simplified form or a value of Heaviside depending on the
+        argument passed by the Heaviside object.
+
+        Explanation
+        ===========
+
+        The ``eval()`` method is automatically called when the ``Heaviside``
+        class is about to be instantiated and it returns either some simplified
+        instance or the unevaluated instance depending on the argument passed.
+        In other words, ``eval()`` method is not needed to be called explicitly,
+        it is being called and evaluated once the object is called.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, S
+        >>> from sympy.abc import x
+
+        >>> Heaviside(x)
+        Heaviside(x)
+
+        >>> Heaviside(19)
+        1
+
+        >>> Heaviside(0)
+        1/2
+
+        >>> Heaviside(0, 1)
+        1
+
+        >>> Heaviside(-5)
+        0
+
+        >>> Heaviside(S.NaN)
+        nan
+
+        >>> Heaviside(x - 100).subs(x, 5)
+        0
+
+        >>> Heaviside(x - 100).subs(x, 105)
+        1
+
+        Parameters
+        ==========
+
+        arg : argument passed by Heaviside object
+
+        H0 : value of Heaviside(0)
+
+        """
+        if arg.is_extended_negative:
+            return S.Zero
+        elif arg.is_extended_positive:
+            return S.One
+        elif arg.is_zero:
+            return H0
+        elif arg is S.NaN:
+            return S.NaN
+        elif fuzzy_not(im(arg).is_zero):
+            raise ValueError("Function defined only for Real Values. Complex part: %s  found in %s ." % (repr(im(arg)), repr(arg)) )
+
+    def _eval_rewrite_as_Piecewise(self, arg, H0=None, **kwargs):
+        """
+        Represents Heaviside in a Piecewise form.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, Piecewise, Symbol, nan
+        >>> x = Symbol('x')
+
+        >>> Heaviside(x).rewrite(Piecewise)
+        Piecewise((0, x < 0), (1/2, Eq(x, 0)), (1, True))
+
+        >>> Heaviside(x,nan).rewrite(Piecewise)
+        Piecewise((0, x < 0), (nan, Eq(x, 0)), (1, True))
+
+        >>> Heaviside(x - 5).rewrite(Piecewise)
+        Piecewise((0, x < 5), (1/2, Eq(x, 5)), (1, True))
+
+        >>> Heaviside(x**2 - 1).rewrite(Piecewise)
+        Piecewise((0, x**2 < 1), (1/2, Eq(x**2, 1)), (1, True))
+
+        """
+        if H0 == 0:
+            return Piecewise((0, arg <= 0), (1, True))
+        if H0 == 1:
+            return Piecewise((0, arg < 0), (1, True))
+        return Piecewise((0, arg < 0), (H0, Eq(arg, 0)), (1, True))
+
+    def _eval_rewrite_as_sign(self, arg, H0=S.Half, **kwargs):
+        """
+        Represents the Heaviside function in the form of sign function.
+
+        Explanation
+        ===========
+
+        The value of Heaviside(0) must be 1/2 for rewriting as sign to be
+        strictly equivalent. For easier usage, we also allow this rewriting
+        when Heaviside(0) is undefined.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, Symbol, sign, nan
+        >>> x = Symbol('x', real=True)
+        >>> y = Symbol('y')
+
+        >>> Heaviside(x).rewrite(sign)
+        sign(x)/2 + 1/2
+
+        >>> Heaviside(x, 0).rewrite(sign)
+        Piecewise((sign(x)/2 + 1/2, Ne(x, 0)), (0, True))
+
+        >>> Heaviside(x, nan).rewrite(sign)
+        Piecewise((sign(x)/2 + 1/2, Ne(x, 0)), (nan, True))
+
+        >>> Heaviside(x - 2).rewrite(sign)
+        sign(x - 2)/2 + 1/2
+
+        >>> Heaviside(x**2 - 2*x + 1).rewrite(sign)
+        sign(x**2 - 2*x + 1)/2 + 1/2
+
+        >>> Heaviside(y).rewrite(sign)
+        Heaviside(y)
+
+        >>> Heaviside(y**2 - 2*y + 1).rewrite(sign)
+        Heaviside(y**2 - 2*y + 1)
+
+        See Also
+        ========
+
+        sign
+
+        """
+        if arg.is_extended_real:
+            pw1 = Piecewise(
+                ((sign(arg) + 1)/2, Ne(arg, 0)),
+                (Heaviside(0, H0=H0), True))
+            pw2 = Piecewise(
+                ((sign(arg) + 1)/2, Eq(Heaviside(0, H0=H0), S.Half)),
+                (pw1, True))
+            return pw2
+
+    def _eval_rewrite_as_SingularityFunction(self, args, H0=S.Half, **kwargs):
+        """
+        Returns the Heaviside expression written in the form of Singularity
+        Functions.
+
+        """
+        from sympy.solvers import solve
+        from sympy.functions.special.singularity_functions import SingularityFunction
+        if self == Heaviside(0):
+            return SingularityFunction(0, 0, 0)
+        free = self.free_symbols
+        if len(free) == 1:
+            x = (free.pop())
+            return SingularityFunction(x, solve(args, x)[0], 0)
+            # TODO
+            # ((x - 5)**3*Heaviside(x - 5)).rewrite(SingularityFunction) should output
+            # SingularityFunction(x, 5, 0) instead of (x - 5)**3*SingularityFunction(x, 5, 0)
+        else:
+            # I don't know how to handle the case for Heaviside expressions
+            # having arguments with more than one variable.
+            raise TypeError(filldedent('''
+                rewrite(SingularityFunction) does not
+                support arguments with more that one variable.'''))

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/elliptic_integrals.py

@@ -0,0 +1,445 @@
+""" Elliptic Integrals. """
+
+from sympy.core import S, pi, I, Rational
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.symbol import Dummy,uniquely_named_symbol
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.hyperbolic import atanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, tan
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper, meijerg
+
+class elliptic_k(DefinedFunction):
+    r"""
+    The complete elliptic integral of the first kind, defined by
+
+    .. math:: K(m) = F\left(\tfrac{\pi}{2}\middle| m\right)
+
+    where $F\left(z\middle| m\right)$ is the Legendre incomplete
+    elliptic integral of the first kind.
+
+    Explanation
+    ===========
+
+    The function $K(m)$ is a single-valued function on the complex
+    plane with branch cut along the interval $(1, \infty)$.
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_k, I
+    >>> from sympy.abc import m
+    >>> elliptic_k(0)
+    pi/2
+    >>> elliptic_k(1.0 + I)
+    1.50923695405127 + 0.625146415202697*I
+    >>> elliptic_k(m).series(n=3)
+    pi/2 + pi*m/8 + 9*pi*m**2/128 + O(m**3)
+
+    See Also
+    ========
+
+    elliptic_f
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticK
+
+    """
+
+    @classmethod
+    def eval(cls, m):
+        if m.is_zero:
+            return pi*S.Half
+        elif m is S.Half:
+            return 8*pi**Rational(3, 2)/gamma(Rational(-1, 4))**2
+        elif m is S.One:
+            return S.ComplexInfinity
+        elif m is S.NegativeOne:
+            return gamma(Rational(1, 4))**2/(4*sqrt(2*pi))
+        elif m in (S.Infinity, S.NegativeInfinity, I*S.Infinity,
+                   I*S.NegativeInfinity, S.ComplexInfinity):
+            return S.Zero
+
+    def fdiff(self, argindex=1):
+        m = self.args[0]
+        return (elliptic_e(m) - (1 - m)*elliptic_k(m))/(2*m*(1 - m))
+
+    def _eval_conjugate(self):
+        m = self.args[0]
+        if (m.is_real and (m - 1).is_positive) is False:
+            return self.func(m.conjugate())
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.simplify import hyperexpand
+        return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n=n, logx=logx))
+
+    def _eval_rewrite_as_hyper(self, m, **kwargs):
+        return pi*S.Half*hyper((S.Half, S.Half), (S.One,), m)
+
+    def _eval_rewrite_as_meijerg(self, m, **kwargs):
+        return meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -m)/2
+
+    def _eval_is_zero(self):
+        m = self.args[0]
+        if m.is_infinite:
+            return True
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        m = self.args[0]
+        return Integral(1/sqrt(1 - m*sin(t)**2), (t, 0, pi/2))
+
+
+class elliptic_f(DefinedFunction):
+    r"""
+    The Legendre incomplete elliptic integral of the first
+    kind, defined by
+
+    .. math:: F\left(z\middle| m\right) =
+              \int_0^z \frac{dt}{\sqrt{1 - m \sin^2 t}}
+
+    Explanation
+    ===========
+
+    This function reduces to a complete elliptic integral of
+    the first kind, $K(m)$, when $z = \pi/2$.
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_f, I
+    >>> from sympy.abc import z, m
+    >>> elliptic_f(z, m).series(z)
+    z + z**5*(3*m**2/40 - m/30) + m*z**3/6 + O(z**6)
+    >>> elliptic_f(3.0 + I/2, 1.0 + I)
+    2.909449841483 + 1.74720545502474*I
+
+    See Also
+    ========
+
+    elliptic_k
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticF
+
+    """
+
+    @classmethod
+    def eval(cls, z, m):
+        if z.is_zero:
+            return S.Zero
+        if m.is_zero:
+            return z
+        k = 2*z/pi
+        if k.is_integer:
+            return k*elliptic_k(m)
+        elif m in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+        elif z.could_extract_minus_sign():
+            return -elliptic_f(-z, m)
+
+    def fdiff(self, argindex=1):
+        z, m = self.args
+        fm = sqrt(1 - m*sin(z)**2)
+        if argindex == 1:
+            return 1/fm
+        elif argindex == 2:
+            return (elliptic_e(z, m)/(2*m*(1 - m)) - elliptic_f(z, m)/(2*m) -
+                    sin(2*z)/(4*(1 - m)*fm))
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_conjugate(self):
+        z, m = self.args
+        if (m.is_real and (m - 1).is_positive) is False:
+            return self.func(z.conjugate(), m.conjugate())
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        z, m = self.args[0], self.args[1]
+        return Integral(1/(sqrt(1 - m*sin(t)**2)), (t, 0, z))
+
+    def _eval_is_zero(self):
+        z, m = self.args
+        if z.is_zero:
+            return True
+        if m.is_extended_real and m.is_infinite:
+            return True
+
+
+class elliptic_e(DefinedFunction):
+    r"""
+    Called with two arguments $z$ and $m$, evaluates the
+    incomplete elliptic integral of the second kind, defined by
+
+    .. math:: E\left(z\middle| m\right) = \int_0^z \sqrt{1 - m \sin^2 t} dt
+
+    Called with a single argument $m$, evaluates the Legendre complete
+    elliptic integral of the second kind
+
+    .. math:: E(m) = E\left(\tfrac{\pi}{2}\middle| m\right)
+
+    Explanation
+    ===========
+
+    The function $E(m)$ is a single-valued function on the complex
+    plane with branch cut along the interval $(1, \infty)$.
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_e, I
+    >>> from sympy.abc import z, m
+    >>> elliptic_e(z, m).series(z)
+    z + z**5*(-m**2/40 + m/30) - m*z**3/6 + O(z**6)
+    >>> elliptic_e(m).series(n=4)
+    pi/2 - pi*m/8 - 3*pi*m**2/128 - 5*pi*m**3/512 + O(m**4)
+    >>> elliptic_e(1 + I, 2 - I/2).n()
+    1.55203744279187 + 0.290764986058437*I
+    >>> elliptic_e(0)
+    pi/2
+    >>> elliptic_e(2.0 - I)
+    0.991052601328069 + 0.81879421395609*I
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticE2
+    .. [3] https://functions.wolfram.com/EllipticIntegrals/EllipticE
+
+    """
+
+    @classmethod
+    def eval(cls, m, z=None):
+        if z is not None:
+            z, m = m, z
+            k = 2*z/pi
+            if m.is_zero:
+                return z
+            if z.is_zero:
+                return S.Zero
+            elif k.is_integer:
+                return k*elliptic_e(m)
+            elif m in (S.Infinity, S.NegativeInfinity):
+                return S.ComplexInfinity
+            elif z.could_extract_minus_sign():
+                return -elliptic_e(-z, m)
+        else:
+            if m.is_zero:
+                return pi/2
+            elif m is S.One:
+                return S.One
+            elif m is S.Infinity:
+                return I*S.Infinity
+            elif m is S.NegativeInfinity:
+                return S.Infinity
+            elif m is S.ComplexInfinity:
+                return S.ComplexInfinity
+
+    def fdiff(self, argindex=1):
+        if len(self.args) == 2:
+            z, m = self.args
+            if argindex == 1:
+                return sqrt(1 - m*sin(z)**2)
+            elif argindex == 2:
+                return (elliptic_e(z, m) - elliptic_f(z, m))/(2*m)
+        else:
+            m = self.args[0]
+            if argindex == 1:
+                return (elliptic_e(m) - elliptic_k(m))/(2*m)
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_conjugate(self):
+        if len(self.args) == 2:
+            z, m = self.args
+            if (m.is_real and (m - 1).is_positive) is False:
+                return self.func(z.conjugate(), m.conjugate())
+        else:
+            m = self.args[0]
+            if (m.is_real and (m - 1).is_positive) is False:
+                return self.func(m.conjugate())
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.simplify import hyperexpand
+        if len(self.args) == 1:
+            return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n=n, logx=logx))
+        return super()._eval_nseries(x, n=n, logx=logx)
+
+    def _eval_rewrite_as_hyper(self, *args, **kwargs):
+        if len(args) == 1:
+            m = args[0]
+            return (pi/2)*hyper((Rational(-1, 2), S.Half), (S.One,), m)
+
+    def _eval_rewrite_as_meijerg(self, *args, **kwargs):
+        if len(args) == 1:
+            m = args[0]
+            return -meijerg(((S.Half, Rational(3, 2)), []), \
+                            ((S.Zero,), (S.Zero,)), -m)/4
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        z, m = (pi/2, self.args[0]) if len(self.args) == 1 else self.args
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        return Integral(sqrt(1 - m*sin(t)**2), (t, 0, z))
+
+
+class elliptic_pi(DefinedFunction):
+    r"""
+    Called with three arguments $n$, $z$ and $m$, evaluates the
+    Legendre incomplete elliptic integral of the third kind, defined by
+
+    .. math:: \Pi\left(n; z\middle| m\right) = \int_0^z \frac{dt}
+              {\left(1 - n \sin^2 t\right) \sqrt{1 - m \sin^2 t}}
+
+    Called with two arguments $n$ and $m$, evaluates the complete
+    elliptic integral of the third kind:
+
+    .. math:: \Pi\left(n\middle| m\right) =
+              \Pi\left(n; \tfrac{\pi}{2}\middle| m\right)
+
+    Explanation
+    ===========
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_pi, I
+    >>> from sympy.abc import z, n, m
+    >>> elliptic_pi(n, z, m).series(z, n=4)
+    z + z**3*(m/6 + n/3) + O(z**4)
+    >>> elliptic_pi(0.5 + I, 1.0 - I, 1.2)
+    2.50232379629182 - 0.760939574180767*I
+    >>> elliptic_pi(0, 0)
+    pi/2
+    >>> elliptic_pi(1.0 - I/3, 2.0 + I)
+    3.29136443417283 + 0.32555634906645*I
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticPi3
+    .. [3] https://functions.wolfram.com/EllipticIntegrals/EllipticPi
+
+    """
+
+    @classmethod
+    def eval(cls, n, m, z=None):
+        if z is not None:
+            z, m = m, z
+            if n.is_zero:
+                return elliptic_f(z, m)
+            elif n is S.One:
+                return (elliptic_f(z, m) +
+                        (sqrt(1 - m*sin(z)**2)*tan(z) -
+                         elliptic_e(z, m))/(1 - m))
+            k = 2*z/pi
+            if k.is_integer:
+                return k*elliptic_pi(n, m)
+            elif m.is_zero:
+                return atanh(sqrt(n - 1)*tan(z))/sqrt(n - 1)
+            elif n == m:
+                return (elliptic_f(z, n) - elliptic_pi(1, z, n) +
+                        tan(z)/sqrt(1 - n*sin(z)**2))
+            elif n in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            elif m in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            elif z.could_extract_minus_sign():
+                return -elliptic_pi(n, -z, m)
+            if n.is_zero:
+                return elliptic_f(z, m)
+            if m.is_extended_real and m.is_infinite or \
+                    n.is_extended_real and n.is_infinite:
+                return S.Zero
+        else:
+            if n.is_zero:
+                return elliptic_k(m)
+            elif n is S.One:
+                return S.ComplexInfinity
+            elif m.is_zero:
+                return pi/(2*sqrt(1 - n))
+            elif m == S.One:
+                return S.NegativeInfinity/sign(n - 1)
+            elif n == m:
+                return elliptic_e(n)/(1 - n)
+            elif n in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            elif m in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            if n.is_zero:
+                return elliptic_k(m)
+            if m.is_extended_real and m.is_infinite or \
+                    n.is_extended_real and n.is_infinite:
+                return S.Zero
+
+    def _eval_conjugate(self):
+        if len(self.args) == 3:
+            n, z, m = self.args
+            if (n.is_real and (n - 1).is_positive) is False and \
+               (m.is_real and (m - 1).is_positive) is False:
+                return self.func(n.conjugate(), z.conjugate(), m.conjugate())
+        else:
+            n, m = self.args
+            return self.func(n.conjugate(), m.conjugate())
+
+    def fdiff(self, argindex=1):
+        if len(self.args) == 3:
+            n, z, m = self.args
+            fm, fn = sqrt(1 - m*sin(z)**2), 1 - n*sin(z)**2
+            if argindex == 1:
+                return (elliptic_e(z, m) + (m - n)*elliptic_f(z, m)/n +
+                        (n**2 - m)*elliptic_pi(n, z, m)/n -
+                        n*fm*sin(2*z)/(2*fn))/(2*(m - n)*(n - 1))
+            elif argindex == 2:
+                return 1/(fm*fn)
+            elif argindex == 3:
+                return (elliptic_e(z, m)/(m - 1) +
+                        elliptic_pi(n, z, m) -
+                        m*sin(2*z)/(2*(m - 1)*fm))/(2*(n - m))
+        else:
+            n, m = self.args
+            if argindex == 1:
+                return (elliptic_e(m) + (m - n)*elliptic_k(m)/n +
+                        (n**2 - m)*elliptic_pi(n, m)/n)/(2*(m - n)*(n - 1))
+            elif argindex == 2:
+                return (elliptic_e(m)/(m - 1) + elliptic_pi(n, m))/(2*(n - m))
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        if len(self.args) == 2:
+            n, m, z = self.args[0], self.args[1], pi/2
+        else:
+            n, z, m = self.args
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        return Integral(1/((1 - n*sin(t)**2)*sqrt(1 - m*sin(t)**2)), (t, 0, z))

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/error_functions.py

@@ -0,0 +1,2801 @@
+""" This module contains various functions that are special cases
+    of incomplete gamma functions. It should probably be renamed. """
+
+from sympy.core import EulerGamma # Must be imported from core, not core.numbers
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.function import DefinedFunction, ArgumentIndexError, expand_mul
+from sympy.core.logic import fuzzy_or
+from sympy.core.numbers import I, pi, Rational, Integer
+from sympy.core.relational import is_eq
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, uniquely_named_symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial, factorial2, RisingFactorial
+from sympy.functions.elementary.complexes import  polar_lift, re, unpolarify
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import sqrt, root
+from sympy.functions.elementary.exponential import exp, log, exp_polar
+from sympy.functions.elementary.hyperbolic import cosh, sinh
+from sympy.functions.elementary.trigonometric import cos, sin, sinc
+from sympy.functions.special.hyper import hyper, meijerg
+
+# TODO series expansions
+# TODO see the "Note:" in Ei
+
+# Helper function
+def real_to_real_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:
+        x, y = self.args[0].expand(deep, **hints).as_real_imag()
+    else:
+        x, y = self.args[0].as_real_imag()
+    re = (self.func(x + I*y) + self.func(x - I*y))/2
+    im = (self.func(x + I*y) - self.func(x - I*y))/(2*I)
+    return (re, im)
+
+
+###############################################################################
+################################ ERROR FUNCTION ###############################
+###############################################################################
+
+
+class erf(DefinedFunction):
+    r"""
+    The Gauss error function.
+
+    Explanation
+    ===========
+
+    This function is defined as:
+
+    .. math ::
+        \mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} \mathrm{d}t.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, erf
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> erf(0)
+    0
+    >>> erf(oo)
+    1
+    >>> erf(-oo)
+    -1
+    >>> erf(I*oo)
+    oo*I
+    >>> erf(-I*oo)
+    -oo*I
+
+    In general one can pull out factors of -1 and $I$ from the argument:
+
+    >>> erf(-z)
+    -erf(z)
+
+    The error function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(erf(z))
+    erf(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erf(z), z)
+    2*exp(-z**2)/sqrt(pi)
+
+    We can numerically evaluate the error function to arbitrary precision
+    on the whole complex plane:
+
+    >>> erf(4).evalf(30)
+    0.999999984582742099719981147840
+
+    >>> erf(-4*I).evalf(30)
+    -1296959.73071763923152794095062*I
+
+    See Also
+    ========
+
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/Erf.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Erf
+
+    """
+
+    unbranched = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 2*exp(-self.args[0]**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erfinv
+
+    @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
+
+        if isinstance(arg, erfinv):
+            return arg.args[0]
+
+        if isinstance(arg, erfcinv):
+            return S.One - arg.args[0]
+
+        if arg.is_zero:
+            return S.Zero
+
+        # Only happens with unevaluated erf2inv
+        if isinstance(arg, erf2inv) and arg.args[0].is_zero:
+            return arg.args[1]
+
+        # Try to pull out factors of I
+        t = arg.extract_multiplicatively(I)
+        if t in (S.Infinity, S.NegativeInfinity):
+            return arg
+
+        # Try to pull out factors of -1
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = floor((n - 1)/S(2))
+            if len(previous_terms) > 2:
+                return -previous_terms[-2] * x**2 * (n - 2)/(n*k)
+            else:
+                return 2*S.NegativeOne**k * x**n/(n*factorial(k)*sqrt(pi))
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_real(self):
+        if self.args[0].is_extended_real is True:
+            return True
+        # There are cases where erf(z) becomes a real number
+        # even if z is a complex number
+
+    def _eval_is_imaginary(self):
+        if self.args[0].is_imaginary is True:
+            return True
+
+    def _eval_is_finite(self):
+        z = self.args[0]
+        return fuzzy_or([z.is_finite, z.is_extended_real])
+
+    def _eval_is_zero(self):
+        if self.args[0].is_extended_real is True:
+            return self.args[0].is_zero
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real is True:
+            return self.args[0].is_extended_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real is True:
+            return self.args[0].is_extended_negative
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return sqrt(z**2)/z*(S.One - uppergamma(S.Half, z**2)/sqrt(pi))
+
+    def _eval_rewrite_as_fresnels(self, z, **kwargs):
+        arg = (S.One - I)*z/sqrt(pi)
+        return (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_fresnelc(self, z, **kwargs):
+        arg = (S.One - I)*z/sqrt(pi)
+        return (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return z/sqrt(pi)*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return 2*z/sqrt(pi)*hyper([S.Half], [3*S.Half], -z**2)
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return sqrt(z**2)/z - z*expint(S.Half, z**2)/sqrt(pi)
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        from sympy.series.limits import limit
+        if limitvar:
+            lim = limit(z, limitvar, S.Infinity)
+            if lim is S.NegativeInfinity:
+                return S.NegativeOne + _erfs(-z)*exp(-z**2)
+        return S.One - _erfs(z)*exp(-z**2)
+
+    def _eval_rewrite_as_erfc(self, z, **kwargs):
+        return S.One - erfc(z)
+
+    def _eval_rewrite_as_erfi(self, z, **kwargs):
+        return -I*erfi(I*z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if cdir == -1 else '+')
+        if x in arg.free_symbols and arg0.is_zero:
+            return 2*arg/sqrt(pi)
+        else:
+            return self.func(arg0)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            z = self.args[0]
+
+            try:
+                _, ex = z.leadterm(x)
+            except (ValueError, NotImplementedError):
+                return self
+
+            ex = -ex # as x->1/x for aseries
+            if ex.is_positive:
+                newn = ceiling(n/ex)
+                s = [S.NegativeOne**k * factorial2(2*k - 1) / (z**(2*k + 1) * 2**k)
+                     for k in range(newn)] + [Order(1/z**newn, x)]
+                return S.One - (exp(-z**2)/sqrt(pi)) * Add(*s)
+
+        return super(erf, self)._eval_aseries(n, args0, x, logx)
+
+    as_real_imag = real_to_real_as_real_imag
+
+
+class erfc(DefinedFunction):
+    r"""
+    Complementary Error Function.
+
+    Explanation
+    ===========
+
+    The function is defined as:
+
+    .. math ::
+        \mathrm{erfc}(x) = \frac{2}{\sqrt{\pi}} \int_x^\infty e^{-t^2} \mathrm{d}t
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, erfc
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> erfc(0)
+    1
+    >>> erfc(oo)
+    0
+    >>> erfc(-oo)
+    2
+    >>> erfc(I*oo)
+    -oo*I
+    >>> erfc(-I*oo)
+    oo*I
+
+    The error function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(erfc(z))
+    erfc(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfc(z), z)
+    -2*exp(-z**2)/sqrt(pi)
+
+    It also follows
+
+    >>> erfc(-z)
+    2 - erfc(z)
+
+    We can numerically evaluate the complementary error function to arbitrary
+    precision on the whole complex plane:
+
+    >>> erfc(4).evalf(30)
+    0.0000000154172579002800188521596734869
+
+    >>> erfc(4*I).evalf(30)
+    1.0 - 1296959.73071763923152794095062*I
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/Erfc.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Erfc
+
+    """
+
+    unbranched = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -2*exp(-self.args[0]**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erfcinv
+
+    @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_zero:
+                return S.One
+
+        if isinstance(arg, erfinv):
+            return S.One - arg.args[0]
+
+        if isinstance(arg, erfcinv):
+            return arg.args[0]
+
+        if arg.is_zero:
+            return S.One
+
+        # Try to pull out factors of I
+        t = arg.extract_multiplicatively(I)
+        if t in (S.Infinity, S.NegativeInfinity):
+            return -arg
+
+        # Try to pull out factors of -1
+        if arg.could_extract_minus_sign():
+            return 2 - cls(-arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return S.One
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = floor((n - 1)/S(2))
+            if len(previous_terms) > 2:
+                return -previous_terms[-2] * x**2 * (n - 2)/(n*k)
+            else:
+                return -2*S.NegativeOne**k * x**n/(n*factorial(k)*sqrt(pi))
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_real(self):
+        if self.args[0].is_extended_real is True:
+            return True
+        if self.args[0].is_imaginary is True:
+            return False
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return self.rewrite(erf).rewrite("tractable", deep=True, limitvar=limitvar)
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return S.One - erf(z)
+
+    def _eval_rewrite_as_erfi(self, z, **kwargs):
+        return S.One + I*erfi(I*z)
+
+    def _eval_rewrite_as_fresnels(self, z, **kwargs):
+        arg = (S.One - I)*z/sqrt(pi)
+        return S.One - (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_fresnelc(self, z, **kwargs):
+        arg = (S.One-I)*z/sqrt(pi)
+        return S.One - (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return S.One - z/sqrt(pi)*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return S.One - 2*z/sqrt(pi)*hyper([S.Half], [3*S.Half], -z**2)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return S.One - sqrt(z**2)/z*(S.One - uppergamma(S.Half, z**2)/sqrt(pi))
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return S.One - sqrt(z**2)/z + z*expint(S.Half, z**2)/sqrt(pi)
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(erf)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if cdir == -1 else '+')
+        if arg0.is_zero:
+            return S.One
+        else:
+            return self.func(arg0)
+
+    as_real_imag = real_to_real_as_real_imag
+
+    def _eval_aseries(self, n, args0, x, logx):
+        return S.One - erf(*self.args)._eval_aseries(n, args0, x, logx)
+
+
+class erfi(DefinedFunction):
+    r"""
+    Imaginary error function.
+
+    Explanation
+    ===========
+
+    The function erfi is defined as:
+
+    .. math ::
+        \mathrm{erfi}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{t^2} \mathrm{d}t
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, erfi
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> erfi(0)
+    0
+    >>> erfi(oo)
+    oo
+    >>> erfi(-oo)
+    -oo
+    >>> erfi(I*oo)
+    I
+    >>> erfi(-I*oo)
+    -I
+
+    In general one can pull out factors of -1 and $I$ from the argument:
+
+    >>> erfi(-z)
+    -erfi(z)
+
+    >>> from sympy import conjugate
+    >>> conjugate(erfi(z))
+    erfi(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfi(z), z)
+    2*exp(z**2)/sqrt(pi)
+
+    We can numerically evaluate the imaginary error function to arbitrary
+    precision on the whole complex plane:
+
+    >>> erfi(2).evalf(30)
+    18.5648024145755525987042919132
+
+    >>> erfi(-2*I).evalf(30)
+    -0.995322265018952734162069256367*I
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function
+    .. [2] https://mathworld.wolfram.com/Erfi.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/Erfi
+
+    """
+
+    unbranched = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 2*exp(self.args[0]**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, z):
+        if z.is_Number:
+            if z is S.NaN:
+                return S.NaN
+            elif z.is_zero:
+                return S.Zero
+            elif z is S.Infinity:
+                return S.Infinity
+
+        if z.is_zero:
+            return S.Zero
+
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return -cls(-z)
+
+        # Try to pull out factors of I
+        nz = z.extract_multiplicatively(I)
+        if nz is not None:
+            if nz is S.Infinity:
+                return I
+            if isinstance(nz, erfinv):
+                return I*nz.args[0]
+            if isinstance(nz, erfcinv):
+                return I*(S.One - nz.args[0])
+            # Only happens with unevaluated erf2inv
+            if isinstance(nz, erf2inv) and nz.args[0].is_zero:
+                return I*nz.args[1]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = floor((n - 1)/S(2))
+            if len(previous_terms) > 2:
+                return previous_terms[-2] * x**2 * (n - 2)/(n*k)
+            else:
+                return 2 * x**n/(n*factorial(k)*sqrt(pi))
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return self.rewrite(erf).rewrite("tractable", deep=True, limitvar=limitvar)
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return -I*erf(I*z)
+
+    def _eval_rewrite_as_erfc(self, z, **kwargs):
+        return I*erfc(I*z) - I
+
+    def _eval_rewrite_as_fresnels(self, z, **kwargs):
+        arg = (S.One + I)*z/sqrt(pi)
+        return (S.One - I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_fresnelc(self, z, **kwargs):
+        arg = (S.One + I)*z/sqrt(pi)
+        return (S.One - I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return z/sqrt(pi)*meijerg([S.Half], [], [0], [Rational(-1, 2)], -z**2)
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return 2*z/sqrt(pi)*hyper([S.Half], [3*S.Half], z**2)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return sqrt(-z**2)/z*(uppergamma(S.Half, -z**2)/sqrt(pi) - S.One)
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return sqrt(-z**2)/z - z*expint(S.Half, -z**2)/sqrt(pi)
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(erf)
+
+    as_real_imag = real_to_real_as_real_imag
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if x in arg.free_symbols and arg0.is_zero:
+            return 2*arg/sqrt(pi)
+        elif arg0.is_finite:
+            return self.func(arg0)
+        return self.func(arg)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point is S.Infinity:
+            z = self.args[0]
+            s = [factorial2(2*k - 1) / (2**k * z**(2*k + 1))
+                    for k in range(n)] + [Order(1/z**n, x)]
+            return -I + (exp(z**2)/sqrt(pi)) * Add(*s)
+
+        return super(erfi, self)._eval_aseries(n, args0, x, logx)
+
+
+class erf2(DefinedFunction):
+    r"""
+    Two-argument error function.
+
+    Explanation
+    ===========
+
+    This function is defined as:
+
+    .. math ::
+        \mathrm{erf2}(x, y) = \frac{2}{\sqrt{\pi}} \int_x^y e^{-t^2} \mathrm{d}t
+
+    Examples
+    ========
+
+    >>> from sympy import oo, erf2
+    >>> from sympy.abc import x, y
+
+    Several special values are known:
+
+    >>> erf2(0, 0)
+    0
+    >>> erf2(x, x)
+    0
+    >>> erf2(x, oo)
+    1 - erf(x)
+    >>> erf2(x, -oo)
+    -erf(x) - 1
+    >>> erf2(oo, y)
+    erf(y) - 1
+    >>> erf2(-oo, y)
+    erf(y) + 1
+
+    In general one can pull out factors of -1:
+
+    >>> erf2(-x, -y)
+    -erf2(x, y)
+
+    The error function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(erf2(x, y))
+    erf2(conjugate(x), conjugate(y))
+
+    Differentiation with respect to $x$, $y$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erf2(x, y), x)
+    -2*exp(-x**2)/sqrt(pi)
+    >>> diff(erf2(x, y), y)
+    2*exp(-y**2)/sqrt(pi)
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/GammaBetaErf/Erf2/
+
+    """
+
+
+    def fdiff(self, argindex):
+        x, y = self.args
+        if argindex == 1:
+            return -2*exp(-x**2)/sqrt(pi)
+        elif argindex == 2:
+            return 2*exp(-y**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, y):
+        chk = (S.Infinity, S.NegativeInfinity, S.Zero)
+        if x is S.NaN or y is S.NaN:
+            return S.NaN
+        elif x == y:
+            return S.Zero
+        elif x in chk or y in chk:
+            return erf(y) - erf(x)
+
+        if isinstance(y, erf2inv) and y.args[0] == x:
+            return y.args[1]
+
+        if x.is_zero or y.is_zero or x.is_extended_real and x.is_infinite or \
+                y.is_extended_real and y.is_infinite:
+            return erf(y) - erf(x)
+
+        #Try to pull out -1 factor
+        sign_x = x.could_extract_minus_sign()
+        sign_y = y.could_extract_minus_sign()
+        if (sign_x and sign_y):
+            return -cls(-x, -y)
+        elif (sign_x or sign_y):
+            return erf(y)-erf(x)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate(), self.args[1].conjugate())
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real and self.args[1].is_extended_real
+
+    def _eval_rewrite_as_erf(self, x, y, **kwargs):
+        return erf(y) - erf(x)
+
+    def _eval_rewrite_as_erfc(self, x, y, **kwargs):
+        return erfc(x) - erfc(y)
+
+    def _eval_rewrite_as_erfi(self, x, y, **kwargs):
+        return I*(erfi(I*x)-erfi(I*y))
+
+    def _eval_rewrite_as_fresnels(self, x, y, **kwargs):
+        return erf(y).rewrite(fresnels) - erf(x).rewrite(fresnels)
+
+    def _eval_rewrite_as_fresnelc(self, x, y, **kwargs):
+        return erf(y).rewrite(fresnelc) - erf(x).rewrite(fresnelc)
+
+    def _eval_rewrite_as_meijerg(self, x, y, **kwargs):
+        return erf(y).rewrite(meijerg) - erf(x).rewrite(meijerg)
+
+    def _eval_rewrite_as_hyper(self, x, y, **kwargs):
+        return erf(y).rewrite(hyper) - erf(x).rewrite(hyper)
+
+    def _eval_rewrite_as_uppergamma(self, x, y, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return (sqrt(y**2)/y*(S.One - uppergamma(S.Half, y**2)/sqrt(pi)) -
+            sqrt(x**2)/x*(S.One - uppergamma(S.Half, x**2)/sqrt(pi)))
+
+    def _eval_rewrite_as_expint(self, x, y, **kwargs):
+        return erf(y).rewrite(expint) - erf(x).rewrite(expint)
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(erf)
+
+    def _eval_is_zero(self):
+        return is_eq(*self.args)
+
+class erfinv(DefinedFunction):
+    r"""
+    Inverse Error Function. The erfinv function is defined as:
+
+    .. math ::
+        \mathrm{erf}(x) = y \quad \Rightarrow \quad \mathrm{erfinv}(y) = x
+
+    Examples
+    ========
+
+    >>> from sympy import erfinv
+    >>> from sympy.abc import x
+
+    Several special values are known:
+
+    >>> erfinv(0)
+    0
+    >>> erfinv(1)
+    oo
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfinv(x), x)
+    sqrt(pi)*exp(erfinv(x)**2)/2
+
+    We can numerically evaluate the inverse error function to arbitrary
+    precision on [-1, 1]:
+
+    >>> erfinv(0.2).evalf(30)
+    0.179143454621291692285822705344
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function#Inverse_functions
+    .. [2] https://functions.wolfram.com/GammaBetaErf/InverseErf/
+
+    """
+
+
+    def fdiff(self, argindex =1):
+        if argindex == 1:
+            return sqrt(pi)*exp(self.func(self.args[0])**2)*S.Half
+        else :
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erf
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.NaN:
+            return S.NaN
+        elif z is S.NegativeOne:
+            return S.NegativeInfinity
+        elif z.is_zero:
+            return S.Zero
+        elif z is S.One:
+            return S.Infinity
+
+        if isinstance(z, erf) and z.args[0].is_extended_real:
+            return z.args[0]
+
+        if z.is_zero:
+            return S.Zero
+
+        # Try to pull out factors of -1
+        nz = z.extract_multiplicatively(-1)
+        if nz is not None and (isinstance(nz, erf) and (nz.args[0]).is_extended_real):
+            return -nz.args[0]
+
+    def _eval_rewrite_as_erfcinv(self, z, **kwargs):
+        return erfcinv(1-z)
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+
+class erfcinv (DefinedFunction):
+    r"""
+    Inverse Complementary Error Function. The erfcinv function is defined as:
+
+    .. math ::
+        \mathrm{erfc}(x) = y \quad \Rightarrow \quad \mathrm{erfcinv}(y) = x
+
+    Examples
+    ========
+
+    >>> from sympy import erfcinv
+    >>> from sympy.abc import x
+
+    Several special values are known:
+
+    >>> erfcinv(1)
+    0
+    >>> erfcinv(0)
+    oo
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfcinv(x), x)
+    -sqrt(pi)*exp(erfcinv(x)**2)/2
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function#Inverse_functions
+    .. [2] https://functions.wolfram.com/GammaBetaErf/InverseErfc/
+
+    """
+
+
+    def fdiff(self, argindex =1):
+        if argindex == 1:
+            return -sqrt(pi)*exp(self.func(self.args[0])**2)*S.Half
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erfc
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.NaN:
+            return S.NaN
+        elif z.is_zero:
+            return S.Infinity
+        elif z is S.One:
+            return S.Zero
+        elif z == 2:
+            return S.NegativeInfinity
+
+        if z.is_zero:
+            return S.Infinity
+
+    def _eval_rewrite_as_erfinv(self, z, **kwargs):
+        return erfinv(1-z)
+
+    def _eval_is_zero(self):
+        return (self.args[0] - 1).is_zero
+
+    def _eval_is_infinite(self):
+        z = self.args[0]
+        return fuzzy_or([z.is_zero, is_eq(z, Integer(2))])
+
+
+class erf2inv(DefinedFunction):
+    r"""
+    Two-argument Inverse error function. The erf2inv function is defined as:
+
+    .. math ::
+        \mathrm{erf2}(x, w) = y \quad \Rightarrow \quad \mathrm{erf2inv}(x, y) = w
+
+    Examples
+    ========
+
+    >>> from sympy import erf2inv, oo
+    >>> from sympy.abc import x, y
+
+    Several special values are known:
+
+    >>> erf2inv(0, 0)
+    0
+    >>> erf2inv(1, 0)
+    1
+    >>> erf2inv(0, 1)
+    oo
+    >>> erf2inv(0, y)
+    erfinv(y)
+    >>> erf2inv(oo, y)
+    erfcinv(-y)
+
+    Differentiation with respect to $x$ and $y$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erf2inv(x, y), x)
+    exp(-x**2 + erf2inv(x, y)**2)
+    >>> diff(erf2inv(x, y), y)
+    sqrt(pi)*exp(erf2inv(x, y)**2)/2
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse complementary error function.
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/GammaBetaErf/InverseErf2/
+
+    """
+
+
+    def fdiff(self, argindex):
+        x, y = self.args
+        if argindex == 1:
+            return exp(self.func(x,y)**2-x**2)
+        elif argindex == 2:
+            return sqrt(pi)*S.Half*exp(self.func(x,y)**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, y):
+        if x is S.NaN or y is S.NaN:
+            return S.NaN
+        elif x.is_zero and y.is_zero:
+            return S.Zero
+        elif x.is_zero and y is S.One:
+            return S.Infinity
+        elif x is S.One and y.is_zero:
+            return S.One
+        elif x.is_zero:
+            return erfinv(y)
+        elif x is S.Infinity:
+            return erfcinv(-y)
+        elif y.is_zero:
+            return x
+        elif y is S.Infinity:
+            return erfinv(x)
+
+        if x.is_zero:
+            if y.is_zero:
+                return S.Zero
+            else:
+                return erfinv(y)
+        if y.is_zero:
+            return x
+
+    def _eval_is_zero(self):
+        x, y = self.args
+        if x.is_zero and y.is_zero:
+            return True
+
+###############################################################################
+#################### EXPONENTIAL INTEGRALS ####################################
+###############################################################################
+
+class Ei(DefinedFunction):
+    r"""
+    The classical exponential integral.
+
+    Explanation
+    ===========
+
+    For use in SymPy, this function is defined as
+
+    .. math:: \operatorname{Ei}(x) = \sum_{n=1}^\infty \frac{x^n}{n\, n!}
+                                     + \log(x) + \gamma,
+
+    where $\gamma$ is the Euler-Mascheroni constant.
+
+    If $x$ is a polar number, this defines an analytic function on the
+    Riemann surface of the logarithm. Otherwise this defines an analytic
+    function in the cut plane $\mathbb{C} \setminus (-\infty, 0]$.
+
+    **Background**
+
+    The name exponential integral comes from the following statement:
+
+    .. math:: \operatorname{Ei}(x) = \int_{-\infty}^x \frac{e^t}{t} \mathrm{d}t
+
+    If the integral is interpreted as a Cauchy principal value, this statement
+    holds for $x > 0$ and $\operatorname{Ei}(x)$ as defined above.
+
+    Examples
+    ========
+
+    >>> from sympy import Ei, polar_lift, exp_polar, I, pi
+    >>> from sympy.abc import x
+
+    >>> Ei(-1)
+    Ei(-1)
+
+    This yields a real value:
+
+    >>> Ei(-1).n(chop=True)
+    -0.219383934395520
+
+    On the other hand the analytic continuation is not real:
+
+    >>> Ei(polar_lift(-1)).n(chop=True)
+    -0.21938393439552 + 3.14159265358979*I
+
+    The exponential integral has a logarithmic branch point at the origin:
+
+    >>> Ei(x*exp_polar(2*I*pi))
+    Ei(x) + 2*I*pi
+
+    Differentiation is supported:
+
+    >>> Ei(x).diff(x)
+    exp(x)/x
+
+    The exponential integral is related to many other special functions.
+    For example:
+
+    >>> from sympy import expint, Shi
+    >>> Ei(x).rewrite(expint)
+    -expint(1, x*exp_polar(I*pi)) - I*pi
+    >>> Ei(x).rewrite(Shi)
+    Chi(x) + Shi(x)
+
+    See Also
+    ========
+
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    uppergamma: Upper incomplete gamma function.
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/6.6
+    .. [2] https://en.wikipedia.org/wiki/Exponential_integral
+    .. [3] Abramowitz & Stegun, section 5: https://web.archive.org/web/20201128173312/http://people.math.sfu.ca/~cbm/aands/page_228.htm
+
+    """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z.is_zero:
+            return S.NegativeInfinity
+        elif z is S.Infinity:
+            return S.Infinity
+        elif z is S.NegativeInfinity:
+            return S.Zero
+
+        if z.is_zero:
+            return S.NegativeInfinity
+
+        nz, n = z.extract_branch_factor()
+        if n:
+            return Ei(nz) + 2*I*pi*n
+
+    def fdiff(self, argindex=1):
+        arg = unpolarify(self.args[0])
+        if argindex == 1:
+            return exp(arg)/arg
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        if (self.args[0]/polar_lift(-1)).is_positive:
+            return super()._eval_evalf(prec) + (I*pi)._eval_evalf(prec)
+        return super()._eval_evalf(prec)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        # XXX this does not currently work usefully because uppergamma
+        #     immediately turns into expint
+        return -uppergamma(0, polar_lift(-1)*z) - I*pi
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return -expint(1, polar_lift(-1)*z) - I*pi
+
+    def _eval_rewrite_as_li(self, z, **kwargs):
+        if isinstance(z, log):
+            return li(z.args[0])
+        # TODO:
+        # Actually it only holds that:
+        #  Ei(z) = li(exp(z))
+        # for -pi < imag(z) <= pi
+        return li(exp(z))
+
+    def _eval_rewrite_as_Si(self, z, **kwargs):
+        if z.is_negative:
+            return Shi(z) + Chi(z) - I*pi
+        else:
+            return Shi(z) + Chi(z)
+    _eval_rewrite_as_Ci = _eval_rewrite_as_Si
+    _eval_rewrite_as_Chi = _eval_rewrite_as_Si
+    _eval_rewrite_as_Shi = _eval_rewrite_as_Si
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return exp(z) * _eis(z)
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(S.Exp1**t/t, (t, S.NegativeInfinity, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy import re
+        x0 = self.args[0].limit(x, 0)
+        arg = self.args[0].as_leading_term(x, cdir=cdir)
+        cdir = arg.dir(x, cdir)
+        if x0.is_zero:
+            c, e = arg.as_coeff_exponent(x)
+            logx = log(x) if logx is None else logx
+            return log(c) + e*logx + EulerGamma - (
+                I*pi if re(cdir).is_negative else S.Zero)
+        return super()._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_Si(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point in (S.Infinity, S.NegativeInfinity):
+            z = self.args[0]
+            s = [factorial(k) / (z)**k for k in range(n)] + \
+                    [Order(1/z**n, x)]
+            return (exp(z)/z) * Add(*s)
+
+        return super(Ei, self)._eval_aseries(n, args0, x, logx)
+
+
+class expint(DefinedFunction):
+    r"""
+    Generalized exponential integral.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math:: \operatorname{E}_\nu(z) = z^{\nu - 1} \Gamma(1 - \nu, z),
+
+    where $\Gamma(1 - \nu, z)$ is the upper incomplete gamma function
+    (``uppergamma``).
+
+    Hence for $z$ with positive real part we have
+
+    .. math:: \operatorname{E}_\nu(z)
+              =   \int_1^\infty \frac{e^{-zt}}{t^\nu} \mathrm{d}t,
+
+    which explains the name.
+
+    The representation as an incomplete gamma function provides an analytic
+    continuation for $\operatorname{E}_\nu(z)$. If $\nu$ is a
+    non-positive integer, the exponential integral is thus an unbranched
+    function of $z$, otherwise there is a branch point at the origin.
+    Refer to the incomplete gamma function documentation for details of the
+    branching behavior.
+
+    Examples
+    ========
+
+    >>> from sympy import expint, S
+    >>> from sympy.abc import nu, z
+
+    Differentiation is supported. Differentiation with respect to $z$ further
+    explains the name: for integral orders, the exponential integral is an
+    iterated integral of the exponential function.
+
+    >>> expint(nu, z).diff(z)
+    -expint(nu - 1, z)
+
+    Differentiation with respect to $\nu$ has no classical expression:
+
+    >>> expint(nu, z).diff(nu)
+    -z**(nu - 1)*meijerg(((), (1, 1)), ((0, 0, 1 - nu), ()), z)
+
+    At non-postive integer orders, the exponential integral reduces to the
+    exponential function:
+
+    >>> expint(0, z)
+    exp(-z)/z
+    >>> expint(-1, z)
+    exp(-z)/z + exp(-z)/z**2
+
+    At half-integers it reduces to error functions:
+
+    >>> expint(S(1)/2, z)
+    sqrt(pi)*erfc(sqrt(z))/sqrt(z)
+
+    At positive integer orders it can be rewritten in terms of exponentials
+    and ``expint(1, z)``. Use ``expand_func()`` to do this:
+
+    >>> from sympy import expand_func
+    >>> expand_func(expint(5, z))
+    z**4*expint(1, z)/24 + (-z**3 + z**2 - 2*z + 6)*exp(-z)/24
+
+    The generalised exponential integral is essentially equivalent to the
+    incomplete gamma function:
+
+    >>> from sympy import uppergamma
+    >>> expint(nu, z).rewrite(uppergamma)
+    z**(nu - 1)*uppergamma(1 - nu, z)
+
+    As such it is branched at the origin:
+
+    >>> from sympy import exp_polar, pi, I
+    >>> expint(4, z*exp_polar(2*pi*I))
+    I*pi*z**3/3 + expint(4, z)
+    >>> expint(nu, z*exp_polar(2*pi*I))
+    z**(nu - 1)*(exp(2*I*pi*nu) - 1)*gamma(1 - nu) + expint(nu, z)
+
+    See Also
+    ========
+
+    Ei: Another related function called exponential integral.
+    E1: The classical case, returns expint(1, z).
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    uppergamma
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/8.19
+    .. [2] https://functions.wolfram.com/GammaBetaErf/ExpIntegralE/
+    .. [3] https://en.wikipedia.org/wiki/Exponential_integral
+
+    """
+
+
+    @classmethod
+    def eval(cls, nu, z):
+        from sympy.functions.special.gamma_functions import (gamma, uppergamma)
+        nu2 = unpolarify(nu)
+        if nu != nu2:
+            return expint(nu2, z)
+        if nu.is_Integer and nu <= 0 or (not nu.is_Integer and (2*nu).is_Integer):
+            return unpolarify(expand_mul(z**(nu - 1)*uppergamma(1 - nu, z)))
+
+        # Extract branching information. This can be deduced from what is
+        # explained in lowergamma.eval().
+        z, n = z.extract_branch_factor()
+        if n is S.Zero:
+            return
+        if nu.is_integer:
+            if not nu > 0:
+                return
+            return expint(nu, z) \
+                - 2*pi*I*n*S.NegativeOne**(nu - 1)/factorial(nu - 1)*unpolarify(z)**(nu - 1)
+        else:
+            return (exp(2*I*pi*nu*n) - 1)*z**(nu - 1)*gamma(1 - nu) + expint(nu, z)
+
+    def fdiff(self, argindex):
+        nu, z = self.args
+        if argindex == 1:
+            return -z**(nu - 1)*meijerg([], [1, 1], [0, 0, 1 - nu], [], z)
+        elif argindex == 2:
+            return -expint(nu - 1, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_uppergamma(self, nu, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return z**(nu - 1)*uppergamma(1 - nu, z)
+
+    def _eval_rewrite_as_Ei(self, nu, z, **kwargs):
+        if nu == 1:
+            return -Ei(z*exp_polar(-I*pi)) - I*pi
+        elif nu.is_Integer and nu > 1:
+            # DLMF, 8.19.7
+            x = -unpolarify(z)
+            return x**(nu - 1)/factorial(nu - 1)*E1(z).rewrite(Ei) + \
+                exp(x)/factorial(nu - 1) * \
+                Add(*[factorial(nu - k - 2)*x**k for k in range(nu - 1)])
+        else:
+            return self
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(Ei).rewrite(expint, **hints)
+
+    def _eval_rewrite_as_Si(self, nu, z, **kwargs):
+        if nu != 1:
+            return self
+        return Shi(z) - Chi(z)
+    _eval_rewrite_as_Ci = _eval_rewrite_as_Si
+    _eval_rewrite_as_Chi = _eval_rewrite_as_Si
+    _eval_rewrite_as_Shi = _eval_rewrite_as_Si
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        if not self.args[0].has(x):
+            nu = self.args[0]
+            if nu == 1:
+                f = self._eval_rewrite_as_Si(*self.args)
+                return f._eval_nseries(x, n, logx)
+            elif nu.is_Integer and nu > 1:
+                f = self._eval_rewrite_as_Ei(*self.args)
+                return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[1]
+        nu = self.args[0]
+
+        if point is S.Infinity:
+            z = self.args[1]
+            s = [S.NegativeOne**k * RisingFactorial(nu, k) / z**k for k in range(n)] + [Order(1/z**n, x)]
+            return (exp(-z)/z) * Add(*s)
+
+        return super(expint, self)._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        n, x = self.args
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        return Integral(t**-n * exp(-t*x), (t, 1, S.Infinity))
+
+
+def E1(z):
+    """
+    Classical case of the generalized exponential integral.
+
+    Explanation
+    ===========
+
+    This is equivalent to ``expint(1, z)``.
+
+    Examples
+    ========
+
+    >>> from sympy import E1
+    >>> E1(0)
+    expint(1, 0)
+
+    >>> E1(5)
+    expint(1, 5)
+
+    See Also
+    ========
+
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+
+    """
+    return expint(1, z)
+
+
+class li(DefinedFunction):
+    r"""
+    The classical logarithmic integral.
+
+    Explanation
+    ===========
+
+    For use in SymPy, this function is defined as
+
+    .. math:: \operatorname{li}(x) = \int_0^x \frac{1}{\log(t)} \mathrm{d}t \,.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, li
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> li(0)
+    0
+    >>> li(1)
+    -oo
+    >>> li(oo)
+    oo
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(li(z), z)
+    1/log(z)
+
+    Defining the ``li`` function via an integral:
+    >>> from sympy import integrate
+    >>> integrate(li(z))
+    z*li(z) - Ei(2*log(z))
+
+    >>> integrate(li(z),z)
+    z*li(z) - Ei(2*log(z))
+
+
+    The logarithmic integral can also be defined in terms of ``Ei``:
+
+    >>> from sympy import Ei
+    >>> li(z).rewrite(Ei)
+    Ei(log(z))
+    >>> diff(li(z).rewrite(Ei), z)
+    1/log(z)
+
+    We can numerically evaluate the logarithmic integral to arbitrary precision
+    on the whole complex plane (except the singular points):
+
+    >>> li(2).evalf(30)
+    1.04516378011749278484458888919
+
+    >>> li(2*I).evalf(30)
+    1.0652795784357498247001125598 + 3.08346052231061726610939702133*I
+
+    We can even compute Soldner's constant by the help of mpmath:
+
+    >>> from mpmath import findroot
+    >>> findroot(li, 2)
+    1.45136923488338
+
+    Further transformations include rewriting ``li`` in terms of
+    the trigonometric integrals ``Si``, ``Ci``, ``Shi`` and ``Chi``:
+
+    >>> from sympy import Si, Ci, Shi, Chi
+    >>> li(z).rewrite(Si)
+    -log(I*log(z)) - log(1/log(z))/2 + log(log(z))/2 + Ci(I*log(z)) + Shi(log(z))
+    >>> li(z).rewrite(Ci)
+    -log(I*log(z)) - log(1/log(z))/2 + log(log(z))/2 + Ci(I*log(z)) + Shi(log(z))
+    >>> li(z).rewrite(Shi)
+    -log(1/log(z))/2 + log(log(z))/2 + Chi(log(z)) - Shi(log(z))
+    >>> li(z).rewrite(Chi)
+    -log(1/log(z))/2 + log(log(z))/2 + Chi(log(z)) - Shi(log(z))
+
+    See Also
+    ========
+
+    Li: Offset logarithmic integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Logarithmic_integral
+    .. [2] https://mathworld.wolfram.com/LogarithmicIntegral.html
+    .. [3] https://dlmf.nist.gov/6
+    .. [4] https://mathworld.wolfram.com/SoldnersConstant.html
+
+    """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z.is_zero:
+            return S.Zero
+        elif z is S.One:
+            return S.NegativeInfinity
+        elif z is S.Infinity:
+            return S.Infinity
+        if z.is_zero:
+            return S.Zero
+
+    def fdiff(self, argindex=1):
+        arg = self.args[0]
+        if argindex == 1:
+            return S.One / log(arg)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_conjugate(self):
+        z = self.args[0]
+        # Exclude values on the branch cut (-oo, 0)
+        if not z.is_extended_negative:
+            return self.func(z.conjugate())
+
+    def _eval_rewrite_as_Li(self, z, **kwargs):
+        return Li(z) + li(2)
+
+    def _eval_rewrite_as_Ei(self, z, **kwargs):
+        return Ei(log(z))
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return (-uppergamma(0, -log(z)) +
+                S.Half*(log(log(z)) - log(S.One/log(z))) - log(-log(z)))
+
+    def _eval_rewrite_as_Si(self, z, **kwargs):
+        return (Ci(I*log(z)) - I*Si(I*log(z)) -
+                S.Half*(log(S.One/log(z)) - log(log(z))) - log(I*log(z)))
+
+    _eval_rewrite_as_Ci = _eval_rewrite_as_Si
+
+    def _eval_rewrite_as_Shi(self, z, **kwargs):
+        return (Chi(log(z)) - Shi(log(z)) - S.Half*(log(S.One/log(z)) - log(log(z))))
+
+    _eval_rewrite_as_Chi = _eval_rewrite_as_Shi
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return (log(z)*hyper((1, 1), (2, 2), log(z)) +
+                S.Half*(log(log(z)) - log(S.One/log(z))) + EulerGamma)
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return (-log(-log(z)) - S.Half*(log(S.One/log(z)) - log(log(z)))
+                - meijerg(((), (1,)), ((0, 0), ()), -log(z)))
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return z * _eis(log(z))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        z = self.args[0]
+        s = [(log(z))**k / (factorial(k) * k) for k in range(1, n)]
+        return EulerGamma + log(log(z)) + Add(*s)
+
+    def _eval_is_zero(self):
+        z = self.args[0]
+        if z.is_zero:
+            return True
+
+class Li(DefinedFunction):
+    r"""
+    The offset logarithmic integral.
+
+    Explanation
+    ===========
+
+    For use in SymPy, this function is defined as
+
+    .. math:: \operatorname{Li}(x) = \operatorname{li}(x) - \operatorname{li}(2)
+
+    Examples
+    ========
+
+    >>> from sympy import Li
+    >>> from sympy.abc import z
+
+    The following special value is known:
+
+    >>> Li(2)
+    0
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(Li(z), z)
+    1/log(z)
+
+    The shifted logarithmic integral can be written in terms of $li(z)$:
+
+    >>> from sympy import li
+    >>> Li(z).rewrite(li)
+    li(z) - li(2)
+
+    We can numerically evaluate the logarithmic integral to arbitrary precision
+    on the whole complex plane (except the singular points):
+
+    >>> Li(2).evalf(30)
+    0
+
+    >>> Li(4).evalf(30)
+    1.92242131492155809316615998938
+
+    See Also
+    ========
+
+    li: Logarithmic integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Logarithmic_integral
+    .. [2] https://mathworld.wolfram.com/LogarithmicIntegral.html
+    .. [3] https://dlmf.nist.gov/6
+
+    """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.Infinity:
+            return S.Infinity
+        elif z == S(2):
+            return S.Zero
+
+    def fdiff(self, argindex=1):
+        arg = self.args[0]
+        if argindex == 1:
+            return S.One / log(arg)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        return self.rewrite(li).evalf(prec)
+
+    def _eval_rewrite_as_li(self, z, **kwargs):
+        return li(z) - li(2)
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return self.rewrite(li).rewrite("tractable", deep=True)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        f = self._eval_rewrite_as_li(*self.args)
+        return f._eval_nseries(x, n, logx)
+
+###############################################################################
+#################### TRIGONOMETRIC INTEGRALS ##################################
+###############################################################################
+
+class TrigonometricIntegral(DefinedFunction):
+    """ Base class for trigonometric integrals. """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.Zero:
+            return cls._atzero
+        elif z is S.Infinity:
+            return cls._atinf()
+        elif z is S.NegativeInfinity:
+            return cls._atneginf()
+
+        if z.is_zero:
+            return cls._atzero
+
+        nz = z.extract_multiplicatively(polar_lift(I))
+        if nz is None and cls._trigfunc(0) == 0:
+            nz = z.extract_multiplicatively(I)
+        if nz is not None:
+            return cls._Ifactor(nz, 1)
+        nz = z.extract_multiplicatively(polar_lift(-I))
+        if nz is not None:
+            return cls._Ifactor(nz, -1)
+
+        nz = z.extract_multiplicatively(polar_lift(-1))
+        if nz is None and cls._trigfunc(0) == 0:
+            nz = z.extract_multiplicatively(-1)
+        if nz is not None:
+            return cls._minusfactor(nz)
+
+        nz, n = z.extract_branch_factor()
+        if n == 0 and nz == z:
+            return
+        return 2*pi*I*n*cls._trigfunc(0) + cls(nz)
+
+    def fdiff(self, argindex=1):
+        arg = unpolarify(self.args[0])
+        if argindex == 1:
+            return self._trigfunc(arg)/arg
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Ei(self, z, **kwargs):
+        return self._eval_rewrite_as_expint(z).rewrite(Ei)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return self._eval_rewrite_as_expint(z).rewrite(uppergamma)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE this is fairly inefficient
+        if self.args[0].subs(x, 0) != 0:
+            return super()._eval_nseries(x, n, logx)
+        baseseries = self._trigfunc(x)._eval_nseries(x, n, logx)
+        if self._trigfunc(0) != 0:
+            baseseries -= 1
+        baseseries = baseseries.replace(Pow, lambda t, n: t**n/n, simultaneous=False)
+        if self._trigfunc(0) != 0:
+            baseseries += EulerGamma + log(x)
+        return baseseries.subs(x, self.args[0])._eval_nseries(x, n, logx)
+
+
+class Si(TrigonometricIntegral):
+    r"""
+    Sine integral.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{Si}(z) = \int_0^z \frac{\sin{t}}{t} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import Si
+    >>> from sympy.abc import z
+
+    The sine integral is an antiderivative of $sin(z)/z$:
+
+    >>> Si(z).diff(z)
+    sin(z)/z
+
+    It is unbranched:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Si(z*exp_polar(2*I*pi))
+    Si(z)
+
+    Sine integral behaves much like ordinary sine under multiplication by ``I``:
+
+    >>> Si(I*z)
+    I*Shi(z)
+    >>> Si(-z)
+    -Si(z)
+
+    It can also be expressed in terms of exponential integrals, but beware
+    that the latter is branched:
+
+    >>> from sympy import expint
+    >>> Si(z).rewrite(expint)
+    -I*(-expint(1, z*exp_polar(-I*pi/2))/2 +
+         expint(1, z*exp_polar(I*pi/2))/2) + pi/2
+
+    It can be rewritten in the form of sinc function (by definition):
+
+    >>> from sympy import sinc
+    >>> Si(z).rewrite(sinc)
+    Integral(sinc(_t), (_t, 0, z))
+
+    See Also
+    ========
+
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    sinc: unnormalized sinc function
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = sin
+    _atzero = S.Zero
+
+    @classmethod
+    def _atinf(cls):
+        return pi*S.Half
+
+    @classmethod
+    def _atneginf(cls):
+        return -pi*S.Half
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return -Si(z)
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return I*Shi(z)*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        # XXX should we polarify z?
+        return pi/2 + (E1(polar_lift(I)*z) - E1(polar_lift(-I)*z))/2/I
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(sinc(t), (t, 0, z))
+
+    _eval_rewrite_as_sinc =  _eval_rewrite_as_Integral
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        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 re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif not arg0.is_infinite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo
+        if point is S.Infinity:
+            z = self.args[0]
+            p = [S.NegativeOne**k * factorial(2*k) / z**(2*k + 1)
+                    for k in range(n//2 + 1)] + [Order(1/z**n, x)]
+            q = [S.NegativeOne**k * factorial(2*k + 1) / z**(2*(k + 1))
+                    for k in range(n//2)] + [Order(1/z**n, x)]
+            return pi/2 - cos(z)*Add(*p) - sin(z)*Add(*q)
+
+        # All other points are not handled
+        return super(Si, self)._eval_aseries(n, args0, x, logx)
+
+    def _eval_is_zero(self):
+        z = self.args[0]
+        if z.is_zero:
+            return True
+
+
+class Ci(TrigonometricIntegral):
+    r"""
+    Cosine integral.
+
+    Explanation
+    ===========
+
+    This function is defined for positive $x$ by
+
+    .. math:: \operatorname{Ci}(x) = \gamma + \log{x}
+                         + \int_0^x \frac{\cos{t} - 1}{t} \mathrm{d}t
+           = -\int_x^\infty \frac{\cos{t}}{t} \mathrm{d}t,
+
+    where $\gamma$ is the Euler-Mascheroni constant.
+
+    We have
+
+    .. math:: \operatorname{Ci}(z) =
+        -\frac{\operatorname{E}_1\left(e^{i\pi/2} z\right)
+               + \operatorname{E}_1\left(e^{-i \pi/2} z\right)}{2}
+
+    which holds for all polar $z$ and thus provides an analytic
+    continuation to the Riemann surface of the logarithm.
+
+    The formula also holds as stated
+    for $z \in \mathbb{C}$ with $\Re(z) > 0$.
+    By lifting to the principal branch, we obtain an analytic function on the
+    cut complex plane.
+
+    Examples
+    ========
+
+    >>> from sympy import Ci
+    >>> from sympy.abc import z
+
+    The cosine integral is a primitive of $\cos(z)/z$:
+
+    >>> Ci(z).diff(z)
+    cos(z)/z
+
+    It has a logarithmic branch point at the origin:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Ci(z*exp_polar(2*I*pi))
+    Ci(z) + 2*I*pi
+
+    The cosine integral behaves somewhat like ordinary $\cos$ under
+    multiplication by $i$:
+
+    >>> from sympy import polar_lift
+    >>> Ci(polar_lift(I)*z)
+    Chi(z) + I*pi/2
+    >>> Ci(polar_lift(-1)*z)
+    Ci(z) + I*pi
+
+    It can also be expressed in terms of exponential integrals:
+
+    >>> from sympy import expint
+    >>> Ci(z).rewrite(expint)
+    -expint(1, z*exp_polar(-I*pi/2))/2 - expint(1, z*exp_polar(I*pi/2))/2
+
+    See Also
+    ========
+
+    Si: Sine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = cos
+    _atzero = S.ComplexInfinity
+
+    @classmethod
+    def _atinf(cls):
+        return S.Zero
+
+    @classmethod
+    def _atneginf(cls):
+        return I*pi
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return Ci(z) + I*pi
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return Chi(z) + I*pi/2*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return -(E1(polar_lift(I)*z) + E1(polar_lift(-I)*z))/2
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return S.EulerGamma + log(z) - Integral((1-cos(t))/t, (t, 0, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        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 re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            c, e = arg.as_coeff_exponent(x)
+            logx = log(x) if logx is None else logx
+            return log(c) + e*logx + EulerGamma
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point in (S.Infinity, S.NegativeInfinity):
+            z = self.args[0]
+            p = [S.NegativeOne**k * factorial(2*k) / z**(2*k + 1)
+                    for k in range(n//2 + 1)] + [Order(1/z**n, x)]
+            q = [S.NegativeOne**k * factorial(2*k + 1) / z**(2*(k + 1))
+                    for k in range(n//2)] + [Order(1/z**n, x)]
+            result = sin(z)*(Add(*p)) - cos(z)*(Add(*q))
+
+            if point is S.NegativeInfinity:
+                result += I*pi
+            return result
+
+        return super(Ci, self)._eval_aseries(n, args0, x, logx)
+
+class Shi(TrigonometricIntegral):
+    r"""
+    Sinh integral.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{Shi}(z) = \int_0^z \frac{\sinh{t}}{t} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import Shi
+    >>> from sympy.abc import z
+
+    The Sinh integral is a primitive of $\sinh(z)/z$:
+
+    >>> Shi(z).diff(z)
+    sinh(z)/z
+
+    It is unbranched:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Shi(z*exp_polar(2*I*pi))
+    Shi(z)
+
+    The $\sinh$ integral behaves much like ordinary $\sinh$ under
+    multiplication by $i$:
+
+    >>> Shi(I*z)
+    I*Si(z)
+    >>> Shi(-z)
+    -Shi(z)
+
+    It can also be expressed in terms of exponential integrals, but beware
+    that the latter is branched:
+
+    >>> from sympy import expint
+    >>> Shi(z).rewrite(expint)
+    expint(1, z)/2 - expint(1, z*exp_polar(I*pi))/2 - I*pi/2
+
+    See Also
+    ========
+
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Chi: Hyperbolic cosine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = sinh
+    _atzero = S.Zero
+
+    @classmethod
+    def _atinf(cls):
+        return S.Infinity
+
+    @classmethod
+    def _atneginf(cls):
+        return S.NegativeInfinity
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return -Shi(z)
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return I*Si(z)*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        # XXX should we polarify z?
+        return (E1(z) - E1(exp_polar(I*pi)*z))/2 - I*pi/2
+
+    def _eval_is_zero(self):
+        z = self.args[0]
+        if z.is_zero:
+            return True
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif not arg0.is_infinite:
+            return self.func(arg0)
+        else:
+            return self
+
+
+class Chi(TrigonometricIntegral):
+    r"""
+    Cosh integral.
+
+    Explanation
+    ===========
+
+    This function is defined for positive $x$ by
+
+    .. math:: \operatorname{Chi}(x) = \gamma + \log{x}
+                         + \int_0^x \frac{\cosh{t} - 1}{t} \mathrm{d}t,
+
+    where $\gamma$ is the Euler-Mascheroni constant.
+
+    We have
+
+    .. math:: \operatorname{Chi}(z) = \operatorname{Ci}\left(e^{i \pi/2}z\right)
+                         - i\frac{\pi}{2},
+
+    which holds for all polar $z$ and thus provides an analytic
+    continuation to the Riemann surface of the logarithm.
+    By lifting to the principal branch we obtain an analytic function on the
+    cut complex plane.
+
+    Examples
+    ========
+
+    >>> from sympy import Chi
+    >>> from sympy.abc import z
+
+    The $\cosh$ integral is a primitive of $\cosh(z)/z$:
+
+    >>> Chi(z).diff(z)
+    cosh(z)/z
+
+    It has a logarithmic branch point at the origin:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Chi(z*exp_polar(2*I*pi))
+    Chi(z) + 2*I*pi
+
+    The $\cosh$ integral behaves somewhat like ordinary $\cosh$ under
+    multiplication by $i$:
+
+    >>> from sympy import polar_lift
+    >>> Chi(polar_lift(I)*z)
+    Ci(z) + I*pi/2
+    >>> Chi(polar_lift(-1)*z)
+    Chi(z) + I*pi
+
+    It can also be expressed in terms of exponential integrals:
+
+    >>> from sympy import expint
+    >>> Chi(z).rewrite(expint)
+    -expint(1, z)/2 - expint(1, z*exp_polar(I*pi))/2 - I*pi/2
+
+    See Also
+    ========
+
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = cosh
+    _atzero = S.ComplexInfinity
+
+    @classmethod
+    def _atinf(cls):
+        return S.Infinity
+
+    @classmethod
+    def _atneginf(cls):
+        return S.Infinity
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return Chi(z) + I*pi
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return Ci(z) + I*pi/2*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return -I*pi/2 - (E1(z) + E1(exp_polar(I*pi)*z))/2
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        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 re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            c, e = arg.as_coeff_exponent(x)
+            logx = log(x) if logx is None else logx
+            return log(c) + e*logx + EulerGamma
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+
+###############################################################################
+#################### FRESNEL INTEGRALS ########################################
+###############################################################################
+
+class FresnelIntegral(DefinedFunction):
+    """ Base class for the Fresnel integrals."""
+
+    unbranched = True
+
+    @classmethod
+    def eval(cls, z):
+        # Values at positive infinities signs
+        # if any were extracted automatically
+        if z is S.Infinity:
+            return S.Half
+
+        # Value at zero
+        if z.is_zero:
+            return S.Zero
+
+        # Try to pull out factors of -1 and I
+        prefact = S.One
+        newarg = z
+        changed = False
+
+        nz = newarg.extract_multiplicatively(-1)
+        if nz is not None:
+            prefact = -prefact
+            newarg = nz
+            changed = True
+
+        nz = newarg.extract_multiplicatively(I)
+        if nz is not None:
+            prefact = cls._sign*I*prefact
+            newarg = nz
+            changed = True
+
+        if changed:
+            return prefact*cls(newarg)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self._trigfunc(S.Half*pi*self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    _eval_is_finite = _eval_is_extended_real
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    as_real_imag = real_to_real_as_real_imag
+
+
+class fresnels(FresnelIntegral):
+    r"""
+    Fresnel integral S.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{S}(z) = \int_0^z \sin{\frac{\pi}{2} t^2} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, fresnels
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> fresnels(0)
+    0
+    >>> fresnels(oo)
+    1/2
+    >>> fresnels(-oo)
+    -1/2
+    >>> fresnels(I*oo)
+    -I/2
+    >>> fresnels(-I*oo)
+    I/2
+
+    In general one can pull out factors of -1 and $i$ from the argument:
+
+    >>> fresnels(-z)
+    -fresnels(z)
+    >>> fresnels(I*z)
+    -I*fresnels(z)
+
+    The Fresnel S integral obeys the mirror symmetry
+    $\overline{S(z)} = S(\bar{z})$:
+
+    >>> from sympy import conjugate
+    >>> conjugate(fresnels(z))
+    fresnels(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(fresnels(z), z)
+    sin(pi*z**2/2)
+
+    Defining the Fresnel functions via an integral:
+
+    >>> from sympy import integrate, pi, sin, expand_func
+    >>> integrate(sin(pi*z**2/2), z)
+    3*fresnels(z)*gamma(3/4)/(4*gamma(7/4))
+    >>> expand_func(integrate(sin(pi*z**2/2), z))
+    fresnels(z)
+
+    We can numerically evaluate the Fresnel integral to arbitrary precision
+    on the whole complex plane:
+
+    >>> fresnels(2).evalf(30)
+    0.343415678363698242195300815958
+
+    >>> fresnels(-2*I).evalf(30)
+    0.343415678363698242195300815958*I
+
+    See Also
+    ========
+
+    fresnelc: Fresnel cosine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fresnel_integral
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/FresnelIntegrals.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/FresnelS
+    .. [5] The converging factors for the fresnel integrals
+            by John W. Wrench Jr. and Vicki Alley
+
+    """
+    _trigfunc = sin
+    _sign = -S.One
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return (-pi**2*x**4*(4*n - 1)/(8*n*(2*n + 1)*(4*n + 3))) * p
+            else:
+                return x**3 * (-x**4)**n * (S(2)**(-2*n - 1)*pi**(2*n + 1)) / ((4*n + 3)*factorial(2*n + 1))
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return (S.One + I)/4 * (erf((S.One + I)/2*sqrt(pi)*z) - I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return pi*z**3/6 * hyper([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)], -pi**2*z**4/16)
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return (pi*z**Rational(9, 4) / (sqrt(2)*(z**2)**Rational(3, 4)*(-z)**Rational(3, 4))
+                * meijerg([], [1], [Rational(3, 4)], [Rational(1, 4), 0], -pi**2*z**4/16))
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(sin(pi*t**2/2), (t, 0, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return pi*arg**3/6
+        elif arg0 in [S.Infinity, S.NegativeInfinity]:
+            s = 1 if arg0 is S.Infinity else -1
+            return s*S.Half + Order(x, x)
+        else:
+            return self.func(arg0)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo and -oo
+        if point in [S.Infinity, -S.Infinity]:
+            z = self.args[0]
+
+            # expansion of S(x) = S1(x*sqrt(pi/2)), see reference[5] page 1-8
+            # as only real infinities are dealt with, sin and cos are O(1)
+            p = [S.NegativeOne**k * factorial(4*k + 1) /
+                 (2**(2*k + 2) * z**(4*k + 3) * 2**(2*k)*factorial(2*k))
+                 for k in range(0, n) if 4*k + 3 < n]
+            q = [1/(2*z)] + [S.NegativeOne**k * factorial(4*k - 1) /
+                 (2**(2*k + 1) * z**(4*k + 1) * 2**(2*k - 1)*factorial(2*k - 1))
+                 for k in range(1, n) if 4*k + 1 < n]
+
+            p = [-sqrt(2/pi)*t for t in p]
+            q = [-sqrt(2/pi)*t for t in q]
+            s = 1 if point is S.Infinity else -1
+            # The expansion at oo is 1/2 + some odd powers of z
+            # To get the expansion at -oo, replace z by -z and flip the sign
+            # The result -1/2 + the same odd powers of z as before.
+            return s*S.Half + (sin(z**2)*Add(*p) + cos(z**2)*Add(*q)
+                ).subs(x, sqrt(2/pi)*x) + Order(1/z**n, x)
+
+        # All other points are not handled
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+class fresnelc(FresnelIntegral):
+    r"""
+    Fresnel integral C.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{C}(z) = \int_0^z \cos{\frac{\pi}{2} t^2} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, fresnelc
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> fresnelc(0)
+    0
+    >>> fresnelc(oo)
+    1/2
+    >>> fresnelc(-oo)
+    -1/2
+    >>> fresnelc(I*oo)
+    I/2
+    >>> fresnelc(-I*oo)
+    -I/2
+
+    In general one can pull out factors of -1 and $i$ from the argument:
+
+    >>> fresnelc(-z)
+    -fresnelc(z)
+    >>> fresnelc(I*z)
+    I*fresnelc(z)
+
+    The Fresnel C integral obeys the mirror symmetry
+    $\overline{C(z)} = C(\bar{z})$:
+
+    >>> from sympy import conjugate
+    >>> conjugate(fresnelc(z))
+    fresnelc(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(fresnelc(z), z)
+    cos(pi*z**2/2)
+
+    Defining the Fresnel functions via an integral:
+
+    >>> from sympy import integrate, pi, cos, expand_func
+    >>> integrate(cos(pi*z**2/2), z)
+    fresnelc(z)*gamma(1/4)/(4*gamma(5/4))
+    >>> expand_func(integrate(cos(pi*z**2/2), z))
+    fresnelc(z)
+
+    We can numerically evaluate the Fresnel integral to arbitrary precision
+    on the whole complex plane:
+
+    >>> fresnelc(2).evalf(30)
+    0.488253406075340754500223503357
+
+    >>> fresnelc(-2*I).evalf(30)
+    -0.488253406075340754500223503357*I
+
+    See Also
+    ========
+
+    fresnels: Fresnel sine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fresnel_integral
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/FresnelIntegrals.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/FresnelC
+    .. [5] The converging factors for the fresnel integrals
+            by John W. Wrench Jr. and Vicki Alley
+
+    """
+    _trigfunc = cos
+    _sign = S.One
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return (-pi**2*x**4*(4*n - 3)/(8*n*(2*n - 1)*(4*n + 1))) * p
+            else:
+                return x * (-x**4)**n * (S(2)**(-2*n)*pi**(2*n)) / ((4*n + 1)*factorial(2*n))
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return (S.One - I)/4 * (erf((S.One + I)/2*sqrt(pi)*z) + I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return z * hyper([Rational(1, 4)], [S.Half, Rational(5, 4)], -pi**2*z**4/16)
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return (pi*z**Rational(3, 4) / (sqrt(2)*root(z**2, 4)*root(-z, 4))
+                * meijerg([], [1], [Rational(1, 4)], [Rational(3, 4), 0], -pi**2*z**4/16))
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(cos(pi*t**2/2), (t, 0, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif arg0 in [S.Infinity, S.NegativeInfinity]:
+            s = 1 if arg0 is S.Infinity else -1
+            return s*S.Half + Order(x, x)
+        else:
+            return self.func(arg0)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo
+        if point in [S.Infinity, -S.Infinity]:
+            z = self.args[0]
+
+            # expansion of C(x) = C1(x*sqrt(pi/2)), see reference[5] page 1-8
+            # as only real infinities are dealt with, sin and cos are O(1)
+            p = [S.NegativeOne**k * factorial(4*k + 1) /
+                 (2**(2*k + 2) * z**(4*k + 3) * 2**(2*k)*factorial(2*k))
+                 for k in range(n) if 4*k + 3 < n]
+            q = [1/(2*z)] + [S.NegativeOne**k * factorial(4*k - 1) /
+                 (2**(2*k + 1) * z**(4*k + 1) * 2**(2*k - 1)*factorial(2*k - 1))
+                 for k in range(1, n) if 4*k + 1 < n]
+
+            p = [-sqrt(2/pi)*t for t in p]
+            q = [ sqrt(2/pi)*t for t in q]
+            s = 1 if point is S.Infinity else -1
+            # The expansion at oo is 1/2 + some odd powers of z
+            # To get the expansion at -oo, replace z by -z and flip the sign
+            # The result -1/2 + the same odd powers of z as before.
+            return s*S.Half + (cos(z**2)*Add(*p) + sin(z**2)*Add(*q)
+                ).subs(x, sqrt(2/pi)*x) + Order(1/z**n, x)
+
+        # All other points are not handled
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+###############################################################################
+#################### HELPER FUNCTIONS #########################################
+###############################################################################
+
+
+class _erfs(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{erf}(z)$ function
+    tractable for the Gruntz algorithm.
+
+    """
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_zero:
+            return S.One
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo
+        if point is S.Infinity:
+            z = self.args[0]
+            l = [1/sqrt(pi) * factorial(2*k)*(-S(
+                 4))**(-k)/factorial(k) * (1/z)**(2*k + 1) for k in range(n)]
+            o = Order(1/z**(2*n + 1), x)
+            # It is very inefficient to first add the order and then do the nseries
+            return (Add(*l))._eval_nseries(x, n, logx) + o
+
+        # Expansion at I*oo
+        t = point.extract_multiplicatively(I)
+        if t is S.Infinity:
+            z = self.args[0]
+            # TODO: is the series really correct?
+            l = [1/sqrt(pi) * factorial(2*k)*(-S(
+                 4))**(-k)/factorial(k) * (1/z)**(2*k + 1) for k in range(n)]
+            o = Order(1/z**(2*n + 1), x)
+            # It is very inefficient to first add the order and then do the nseries
+            return (Add(*l))._eval_nseries(x, n, logx) + o
+
+        # All other points are not handled
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -2/sqrt(pi) + 2*z*_erfs(z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_intractable(self, z, **kwargs):
+        return (S.One - erf(z))*exp(z**2)
+
+
+class _eis(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{Ei}(z)$ and $\\mathrm{li}(z)$
+    functions tractable for the Gruntz algorithm.
+
+    """
+
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        if args0[0] not in (S.Infinity, S.NegativeInfinity):
+            return super()._eval_aseries(n, args0, x, logx)
+
+        z = self.args[0]
+        l = [factorial(k) * (1/z)**(k + 1) for k in range(n)]
+        o = Order(1/z**(n + 1), x)
+        # It is very inefficient to first add the order and then do the nseries
+        return (Add(*l))._eval_nseries(x, n, logx) + o
+
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return S.One / z - _eis(z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_intractable(self, z, **kwargs):
+        return exp(-z)*Ei(z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return super()._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/gamma_functions.py

@@ -0,0 +1,1344 @@
+from math import prod
+
+from sympy.core import Add, S, Dummy, expand_func
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, ArgumentIndexError, PoleError
+from sympy.core.logic import fuzzy_and, fuzzy_not
+from sympy.core.numbers import Rational, pi, oo, I
+from sympy.core.power import Pow
+from sympy.functions.special.zeta_functions import zeta
+from sympy.functions.special.error_functions import erf, erfc, Ei
+from sympy.functions.elementary.complexes import re, unpolarify
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, cos, cot
+from sympy.functions.combinatorial.numbers import bernoulli, harmonic
+from sympy.functions.combinatorial.factorials import factorial, rf, RisingFactorial
+from sympy.utilities.misc import as_int
+
+from mpmath import mp, workprec
+from mpmath.libmp.libmpf import prec_to_dps
+
+def intlike(n):
+    try:
+        as_int(n, strict=False)
+        return True
+    except ValueError:
+        return False
+
+###############################################################################
+############################ COMPLETE GAMMA FUNCTION ##########################
+###############################################################################
+
+class gamma(DefinedFunction):
+    r"""
+    The gamma function
+
+    .. math::
+        \Gamma(x) := \int^{\infty}_{0} t^{x-1} e^{-t} \mathrm{d}t.
+
+    Explanation
+    ===========
+
+    The ``gamma`` function implements the function which passes through the
+    values of the factorial function (i.e., $\Gamma(n) = (n - 1)!$ when n is
+    an integer). More generally, $\Gamma(z)$ is defined in the whole complex
+    plane except at the negative integers where there are simple poles.
+
+    Examples
+    ========
+
+    >>> from sympy import S, I, pi, gamma
+    >>> from sympy.abc import x
+
+    Several special values are known:
+
+    >>> gamma(1)
+    1
+    >>> gamma(4)
+    6
+    >>> gamma(S(3)/2)
+    sqrt(pi)/2
+
+    The ``gamma`` function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(gamma(x))
+    gamma(conjugate(x))
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(gamma(x), x)
+    gamma(x)*polygamma(0, x)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(gamma(x), x, 0, 3)
+    1/x - EulerGamma + x*(EulerGamma**2/2 + pi**2/12) + x**2*(-EulerGamma*pi**2/12 - zeta(3)/3 - EulerGamma**3/6) + O(x**3)
+
+    We can numerically evaluate the ``gamma`` function to arbitrary precision
+    on the whole complex plane:
+
+    >>> gamma(pi).evalf(40)
+    2.288037795340032417959588909060233922890
+    >>> gamma(1+I).evalf(20)
+    0.49801566811835604271 - 0.15494982830181068512*I
+
+    See Also
+    ========
+
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gamma_function
+    .. [2] https://dlmf.nist.gov/5
+    .. [3] https://mathworld.wolfram.com/GammaFunction.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma/
+
+    """
+
+    unbranched = True
+    _singularities = (S.ComplexInfinity,)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self.func(self.args[0])*polygamma(0, self.args[0])
+        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 oo:
+                return oo
+            elif intlike(arg):
+                if arg.is_positive:
+                    return factorial(arg - 1)
+                else:
+                    return S.ComplexInfinity
+            elif arg.is_Rational:
+                if arg.q == 2:
+                    n = abs(arg.p) // arg.q
+
+                    if arg.is_positive:
+                        k, coeff = n, S.One
+                    else:
+                        n = k = n + 1
+
+                        if n & 1 == 0:
+                            coeff = S.One
+                        else:
+                            coeff = S.NegativeOne
+
+                    coeff *= prod(range(3, 2*k, 2))
+
+                    if arg.is_positive:
+                        return coeff*sqrt(pi) / 2**n
+                    else:
+                        return 2**n*sqrt(pi) / coeff
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        if arg.is_Rational:
+            if abs(arg.p) > arg.q:
+                x = Dummy('x')
+                n = arg.p // arg.q
+                p = arg.p - n*arg.q
+                return self.func(x + n)._eval_expand_func().subs(x, Rational(p, arg.q))
+
+        if arg.is_Add:
+            coeff, tail = arg.as_coeff_add()
+            if coeff and coeff.q != 1:
+                intpart = floor(coeff)
+                tail = (coeff - intpart,) + tail
+                coeff = intpart
+            tail = arg._new_rawargs(*tail, reeval=False)
+            return self.func(tail)*RisingFactorial(tail, coeff)
+
+        return self.func(*self.args)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_real(self):
+        x = self.args[0]
+        if x.is_nonpositive and x.is_integer:
+            return False
+        if intlike(x) and x <= 0:
+            return False
+        if x.is_positive or x.is_noninteger:
+            return True
+
+    def _eval_is_positive(self):
+        x = self.args[0]
+        if x.is_positive:
+            return True
+        elif x.is_noninteger:
+            return floor(x).is_even
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return exp(loggamma(z))
+
+    def _eval_rewrite_as_factorial(self, z, **kwargs):
+        return factorial(z - 1)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if not (x0.is_Integer and x0 <= 0):
+            return super()._eval_nseries(x, n, logx)
+        t = self.args[0] - x0
+        return (self.func(t + 1)/rf(self.args[0], -x0 + 1))._eval_nseries(x, n, logx)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0)
+
+        if x0.is_integer and x0.is_nonpositive:
+            n = -x0
+            res = S.NegativeOne**n/self.func(n + 1)
+            return res/(arg + n).as_leading_term(x)
+        elif not x0.is_infinite:
+            return self.func(x0)
+        raise PoleError()
+
+
+###############################################################################
+################## LOWER and UPPER INCOMPLETE GAMMA FUNCTIONS #################
+###############################################################################
+
+class lowergamma(DefinedFunction):
+    r"""
+    The lower incomplete gamma function.
+
+    Explanation
+    ===========
+
+    It can be defined as the meromorphic continuation of
+
+    .. math::
+        \gamma(s, x) := \int_0^x t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \Gamma(s, x).
+
+    This can be shown to be the same as
+
+    .. math::
+        \gamma(s, x) = \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),
+
+    where ${}_1F_1$ is the (confluent) hypergeometric function.
+
+    Examples
+    ========
+
+    >>> from sympy import lowergamma, S
+    >>> from sympy.abc import s, x
+    >>> lowergamma(s, x)
+    lowergamma(s, x)
+    >>> lowergamma(3, x)
+    -2*(x**2/2 + x + 1)*exp(-x) + 2
+    >>> lowergamma(-S(1)/2, x)
+    -2*sqrt(pi)*erf(sqrt(x)) - 2*exp(-x)/sqrt(x)
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Incomplete_gamma_function#Lower_incomplete_gamma_function
+    .. [2] Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6,
+           Section 5, Handbook of Mathematical Functions with Formulas, Graphs,
+           and Mathematical Tables
+    .. [3] https://dlmf.nist.gov/8
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma2/
+    .. [5] https://functions.wolfram.com/GammaBetaErf/Gamma3/
+
+    """
+
+
+    def fdiff(self, argindex=2):
+        from sympy.functions.special.hyper import meijerg
+        if argindex == 2:
+            a, z = self.args
+            return exp(-unpolarify(z))*z**(a - 1)
+        elif argindex == 1:
+            a, z = self.args
+            return gamma(a)*digamma(a) - log(z)*uppergamma(a, z) \
+                - meijerg([], [1, 1], [0, 0, a], [], z)
+
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, x):
+        # For lack of a better place, we use this one to extract branching
+        # information. The following can be
+        # found in the literature (c/f references given above), albeit scattered:
+        # 1) For fixed x != 0, lowergamma(s, x) is an entire function of s
+        # 2) For fixed positive integers s, lowergamma(s, x) is an entire
+        #    function of x.
+        # 3) For fixed non-positive integers s,
+        #    lowergamma(s, exp(I*2*pi*n)*x) =
+        #              2*pi*I*n*(-1)**(-s)/factorial(-s) + lowergamma(s, x)
+        #    (this follows from lowergamma(s, x).diff(x) = x**(s-1)*exp(-x)).
+        # 4) For fixed non-integral s,
+        #    lowergamma(s, x) = x**s*gamma(s)*lowergamma_unbranched(s, x),
+        #    where lowergamma_unbranched(s, x) is an entire function (in fact
+        #    of both s and x), i.e.
+        #    lowergamma(s, exp(2*I*pi*n)*x) = exp(2*pi*I*n*a)*lowergamma(a, x)
+        if x is S.Zero:
+            return S.Zero
+        nx, n = x.extract_branch_factor()
+        if a.is_integer and a.is_positive:
+            nx = unpolarify(x)
+            if nx != x:
+                return lowergamma(a, nx)
+        elif a.is_integer and a.is_nonpositive:
+            if n != 0:
+                return 2*pi*I*n*S.NegativeOne**(-a)/factorial(-a) + lowergamma(a, nx)
+        elif n != 0:
+            return exp(2*pi*I*n*a)*lowergamma(a, nx)
+
+        # Special values.
+        if a.is_Number:
+            if a is S.One:
+                return S.One - exp(-x)
+            elif a is S.Half:
+                return sqrt(pi)*erf(sqrt(x))
+            elif a.is_Integer or (2*a).is_Integer:
+                b = a - 1
+                if b.is_positive:
+                    if a.is_integer:
+                        return factorial(b) - exp(-x) * factorial(b) * Add(*[x ** k / factorial(k) for k in range(a)])
+                    else:
+                        return gamma(a)*(lowergamma(S.Half, x)/sqrt(pi) - exp(-x)*Add(*[x**(k - S.Half)/gamma(S.Half + k) for k in range(1, a + S.Half)]))
+
+                if not a.is_Integer:
+                    return S.NegativeOne**(S.Half - a)*pi*erf(sqrt(x))/gamma(1 - a) + exp(-x)*Add(*[x**(k + a - 1)*gamma(a)/gamma(a + k) for k in range(1, Rational(3, 2) - a)])
+
+        if x.is_zero:
+            return S.Zero
+
+    def _eval_evalf(self, prec):
+        if all(x.is_number for x in self.args):
+            a = self.args[0]._to_mpmath(prec)
+            z = self.args[1]._to_mpmath(prec)
+            with workprec(prec):
+                res = mp.gammainc(a, 0, z)
+            return Expr._from_mpmath(res, prec)
+        else:
+            return self
+
+    def _eval_conjugate(self):
+        x = self.args[1]
+        if x not in (S.Zero, S.NegativeInfinity):
+            return self.func(self.args[0].conjugate(), x.conjugate())
+
+    def _eval_is_meromorphic(self, x, a):
+        # By https://en.wikipedia.org/wiki/Incomplete_gamma_function#Holomorphic_extension,
+        #    lowergamma(s, z) = z**s*gamma(s)*gammastar(s, z),
+        # where gammastar(s, z) is holomorphic for all s and z.
+        # Hence the singularities of lowergamma are z = 0  (branch
+        # point) and nonpositive integer values of s (poles of gamma(s)).
+        s, z = self.args
+        args_merom = fuzzy_and([z._eval_is_meromorphic(x, a),
+            s._eval_is_meromorphic(x, a)])
+        if not args_merom:
+            return args_merom
+        z0 = z.subs(x, a)
+        if s.is_integer:
+            return fuzzy_and([s.is_positive, z0.is_finite])
+        s0 = s.subs(x, a)
+        return fuzzy_and([s0.is_finite, z0.is_finite, fuzzy_not(z0.is_zero)])
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import O
+        s, z = self.args
+        if args0[0] is oo and not z.has(x):
+            coeff = z**s*exp(-z)
+            sum_expr = sum(z**k/rf(s, k + 1) for k in range(n - 1))
+            o = O(z**s*s**(-n))
+            return coeff*sum_expr + o
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_uppergamma(self, s, x, **kwargs):
+        return gamma(s) - uppergamma(s, x)
+
+    def _eval_rewrite_as_expint(self, s, x, **kwargs):
+        from sympy.functions.special.error_functions import expint
+        if s.is_integer and s.is_nonpositive:
+            return self
+        return self.rewrite(uppergamma).rewrite(expint)
+
+    def _eval_is_zero(self):
+        x = self.args[1]
+        if x.is_zero:
+            return True
+
+
+class uppergamma(DefinedFunction):
+    r"""
+    The upper incomplete gamma function.
+
+    Explanation
+    ===========
+
+    It can be defined as the meromorphic continuation of
+
+    .. math::
+        \Gamma(s, x) := \int_x^\infty t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \gamma(s, x).
+
+    where $\gamma(s, x)$ is the lower incomplete gamma function,
+    :class:`lowergamma`. This can be shown to be the same as
+
+    .. math::
+        \Gamma(s, x) = \Gamma(s) - \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),
+
+    where ${}_1F_1$ is the (confluent) hypergeometric function.
+
+    The upper incomplete gamma function is also essentially equivalent to the
+    generalized exponential integral:
+
+    .. math::
+        \operatorname{E}_{n}(x) = \int_{1}^{\infty}{\frac{e^{-xt}}{t^n} \, dt} = x^{n-1}\Gamma(1-n,x).
+
+    Examples
+    ========
+
+    >>> from sympy import uppergamma, S
+    >>> from sympy.abc import s, x
+    >>> uppergamma(s, x)
+    uppergamma(s, x)
+    >>> uppergamma(3, x)
+    2*(x**2/2 + x + 1)*exp(-x)
+    >>> uppergamma(-S(1)/2, x)
+    -2*sqrt(pi)*erfc(sqrt(x)) + 2*exp(-x)/sqrt(x)
+    >>> uppergamma(-2, x)
+    expint(3, x)/x**2
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Incomplete_gamma_function#Upper_incomplete_gamma_function
+    .. [2] Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6,
+           Section 5, Handbook of Mathematical Functions with Formulas, Graphs,
+           and Mathematical Tables
+    .. [3] https://dlmf.nist.gov/8
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma2/
+    .. [5] https://functions.wolfram.com/GammaBetaErf/Gamma3/
+    .. [6] https://en.wikipedia.org/wiki/Exponential_integral#Relation_with_other_functions
+
+    """
+
+
+    def fdiff(self, argindex=2):
+        from sympy.functions.special.hyper import meijerg
+        if argindex == 2:
+            a, z = self.args
+            return -exp(-unpolarify(z))*z**(a - 1)
+        elif argindex == 1:
+            a, z = self.args
+            return uppergamma(a, z)*log(z) + meijerg([], [1, 1], [0, 0, a], [], z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        if all(x.is_number for x in self.args):
+            a = self.args[0]._to_mpmath(prec)
+            z = self.args[1]._to_mpmath(prec)
+            with workprec(prec):
+                res = mp.gammainc(a, z, mp.inf)
+            return Expr._from_mpmath(res, prec)
+        return self
+
+    @classmethod
+    def eval(cls, a, z):
+        from sympy.functions.special.error_functions import expint
+        if z.is_Number:
+            if z is S.NaN:
+                return S.NaN
+            elif z is oo:
+                return S.Zero
+            elif z.is_zero:
+                if re(a).is_positive:
+                    return gamma(a)
+
+        # We extract branching information here. C/f lowergamma.
+        nx, n = z.extract_branch_factor()
+        if a.is_integer and a.is_positive:
+            nx = unpolarify(z)
+            if z != nx:
+                return uppergamma(a, nx)
+        elif a.is_integer and a.is_nonpositive:
+            if n != 0:
+                return -2*pi*I*n*S.NegativeOne**(-a)/factorial(-a) + uppergamma(a, nx)
+        elif n != 0:
+            return gamma(a)*(1 - exp(2*pi*I*n*a)) + exp(2*pi*I*n*a)*uppergamma(a, nx)
+
+        # Special values.
+        if a.is_Number:
+            if a is S.Zero and z.is_positive:
+                return -Ei(-z)
+            elif a is S.One:
+                return exp(-z)
+            elif a is S.Half:
+                return sqrt(pi)*erfc(sqrt(z))
+            elif a.is_Integer or (2*a).is_Integer:
+                b = a - 1
+                if b.is_positive:
+                    if a.is_integer:
+                        return exp(-z) * factorial(b) * Add(*[z**k / factorial(k)
+                                                              for k in range(a)])
+                    else:
+                        return (gamma(a) * erfc(sqrt(z)) +
+                                S.NegativeOne**(a - S(3)/2) * exp(-z) * sqrt(z)
+                                * Add(*[gamma(-S.Half - k) * (-z)**k / gamma(1-a)
+                                        for k in range(a - S.Half)]))
+                elif b.is_Integer:
+                    return expint(-b, z)*unpolarify(z)**(b + 1)
+
+                if not a.is_Integer:
+                    return (S.NegativeOne**(S.Half - a) * pi*erfc(sqrt(z))/gamma(1-a)
+                            - z**a * exp(-z) * Add(*[z**k * gamma(a) / gamma(a+k+1)
+                                                     for k in range(S.Half - a)]))
+
+        if a.is_zero and z.is_positive:
+            return -Ei(-z)
+
+        if z.is_zero and re(a).is_positive:
+            return gamma(a)
+
+    def _eval_conjugate(self):
+        z = self.args[1]
+        if z not in (S.Zero, S.NegativeInfinity):
+            return self.func(self.args[0].conjugate(), z.conjugate())
+
+    def _eval_is_meromorphic(self, x, a):
+        return lowergamma._eval_is_meromorphic(self, x, a)
+
+    def _eval_rewrite_as_lowergamma(self, s, x, **kwargs):
+        return gamma(s) - lowergamma(s, x)
+
+    def _eval_rewrite_as_tractable(self, s, x, **kwargs):
+        return exp(loggamma(s)) - lowergamma(s, x)
+
+    def _eval_rewrite_as_expint(self, s, x, **kwargs):
+        from sympy.functions.special.error_functions import expint
+        return expint(1 - s, x)*x**s
+
+
+###############################################################################
+###################### POLYGAMMA and LOGGAMMA FUNCTIONS #######################
+###############################################################################
+
+class polygamma(DefinedFunction):
+    r"""
+    The function ``polygamma(n, z)`` returns ``log(gamma(z)).diff(n + 1)``.
+
+    Explanation
+    ===========
+
+    It is a meromorphic function on $\mathbb{C}$ and defined as the $(n+1)$-th
+    derivative of the logarithm of the gamma function:
+
+    .. math::
+        \psi^{(n)} (z) := \frac{\mathrm{d}^{n+1}}{\mathrm{d} z^{n+1}} \log\Gamma(z).
+
+    For `n` not a nonnegative integer the generalization by Espinosa and Moll [5]_
+    is used:
+
+    .. math:: \psi(s,z) = \frac{\zeta'(s+1, z) + (\gamma + \psi(-s)) \zeta(s+1, z)}
+        {\Gamma(-s)}
+
+    Examples
+    ========
+
+    Several special values are known:
+
+    >>> from sympy import S, polygamma
+    >>> polygamma(0, 1)
+    -EulerGamma
+    >>> polygamma(0, 1/S(2))
+    -2*log(2) - EulerGamma
+    >>> polygamma(0, 1/S(3))
+    -log(3) - sqrt(3)*pi/6 - EulerGamma - log(sqrt(3))
+    >>> polygamma(0, 1/S(4))
+    -pi/2 - log(4) - log(2) - EulerGamma
+    >>> polygamma(0, 2)
+    1 - EulerGamma
+    >>> polygamma(0, 23)
+    19093197/5173168 - EulerGamma
+
+    >>> from sympy import oo, I
+    >>> polygamma(0, oo)
+    oo
+    >>> polygamma(0, -oo)
+    oo
+    >>> polygamma(0, I*oo)
+    oo
+    >>> polygamma(0, -I*oo)
+    oo
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import Symbol, diff
+    >>> x = Symbol("x")
+    >>> diff(polygamma(0, x), x)
+    polygamma(1, x)
+    >>> diff(polygamma(0, x), x, 2)
+    polygamma(2, x)
+    >>> diff(polygamma(0, x), x, 3)
+    polygamma(3, x)
+    >>> diff(polygamma(1, x), x)
+    polygamma(2, x)
+    >>> diff(polygamma(1, x), x, 2)
+    polygamma(3, x)
+    >>> diff(polygamma(2, x), x)
+    polygamma(3, x)
+    >>> diff(polygamma(2, x), x, 2)
+    polygamma(4, x)
+
+    >>> n = Symbol("n")
+    >>> diff(polygamma(n, x), x)
+    polygamma(n + 1, x)
+    >>> diff(polygamma(n, x), x, 2)
+    polygamma(n + 2, x)
+
+    We can rewrite ``polygamma`` functions in terms of harmonic numbers:
+
+    >>> from sympy import harmonic
+    >>> polygamma(0, x).rewrite(harmonic)
+    harmonic(x - 1) - EulerGamma
+    >>> polygamma(2, x).rewrite(harmonic)
+    2*harmonic(x - 1, 3) - 2*zeta(3)
+    >>> ni = Symbol("n", integer=True)
+    >>> polygamma(ni, x).rewrite(harmonic)
+    (-1)**(n + 1)*(-harmonic(x - 1, n + 1) + zeta(n + 1))*factorial(n)
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Polygamma_function
+    .. [2] https://mathworld.wolfram.com/PolygammaFunction.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma/
+    .. [4] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/
+    .. [5] O. Espinosa and V. Moll, "A generalized polygamma function",
+           *Integral Transforms and Special Functions* (2004), 101-115.
+
+    """
+
+    @classmethod
+    def eval(cls, n, z):
+        if n is S.NaN or z is S.NaN:
+            return S.NaN
+        elif z is oo:
+            return oo if n.is_zero else S.Zero
+        elif z.is_Integer and z.is_nonpositive:
+            return S.ComplexInfinity
+        elif n is S.NegativeOne:
+            return loggamma(z) - log(2*pi) / 2
+        elif n.is_zero:
+            if z is -oo or z.extract_multiplicatively(I) in (oo, -oo):
+                return oo
+            elif z.is_Integer:
+                return harmonic(z-1) - S.EulerGamma
+            elif z.is_Rational:
+                # TODO n == 1 also can do some rational z
+                p, q = z.as_numer_denom()
+                # only expand for small denominators to avoid creating long expressions
+                if q <= 6:
+                    return expand_func(polygamma(S.Zero, z, evaluate=False))
+        elif n.is_integer and n.is_nonnegative:
+            nz = unpolarify(z)
+            if z != nz:
+                return polygamma(n, nz)
+            if z.is_Integer:
+                return S.NegativeOne**(n+1) * factorial(n) * zeta(n+1, z)
+            elif z is S.Half:
+                return S.NegativeOne**(n+1) * factorial(n) * (2**(n+1)-1) * zeta(n+1)
+
+    def _eval_is_real(self):
+        if self.args[0].is_positive and self.args[1].is_positive:
+            return True
+
+    def _eval_is_complex(self):
+        z = self.args[1]
+        is_negative_integer = fuzzy_and([z.is_negative, z.is_integer])
+        return fuzzy_and([z.is_complex, fuzzy_not(is_negative_integer)])
+
+    def _eval_is_positive(self):
+        n, z = self.args
+        if n.is_positive:
+            if n.is_odd and z.is_real:
+                return True
+            if n.is_even and z.is_positive:
+                return False
+
+    def _eval_is_negative(self):
+        n, z = self.args
+        if n.is_positive:
+            if n.is_even and z.is_positive:
+                return True
+            if n.is_odd and z.is_real:
+                return False
+
+    def _eval_expand_func(self, **hints):
+        n, z = self.args
+
+        if n.is_Integer and n.is_nonnegative:
+            if z.is_Add:
+                coeff = z.args[0]
+                if coeff.is_Integer:
+                    e = -(n + 1)
+                    if coeff > 0:
+                        tail = Add(*[Pow(
+                            z - i, e) for i in range(1, int(coeff) + 1)])
+                    else:
+                        tail = -Add(*[Pow(
+                            z + i, e) for i in range(int(-coeff))])
+                    return polygamma(n, z - coeff) + S.NegativeOne**n*factorial(n)*tail
+
+            elif z.is_Mul:
+                coeff, z = z.as_two_terms()
+                if coeff.is_Integer and coeff.is_positive:
+                    tail = [polygamma(n, z + Rational(
+                        i, coeff)) for i in range(int(coeff))]
+                    if n == 0:
+                        return Add(*tail)/coeff + log(coeff)
+                    else:
+                        return Add(*tail)/coeff**(n + 1)
+                z *= coeff
+
+        if n == 0 and z.is_Rational:
+            p, q = z.as_numer_denom()
+
+            # Reference:
+            #   Values of the polygamma functions at rational arguments, J. Choi, 2007
+            part_1 = -S.EulerGamma - pi * cot(p * pi / q) / 2 - log(q) + Add(
+                *[cos(2 * k * pi * p / q) * log(2 * sin(k * pi / q)) for k in range(1, q)])
+
+            if z > 0:
+                n = floor(z)
+                z0 = z - n
+                return part_1 + Add(*[1 / (z0 + k) for k in range(n)])
+            elif z < 0:
+                n = floor(1 - z)
+                z0 = z + n
+                return part_1 - Add(*[1 / (z0 - 1 - k) for k in range(n)])
+
+        if n == -1:
+            return loggamma(z) - log(2*pi) / 2
+        if n.is_integer is False or n.is_nonnegative is False:
+            s = Dummy("s")
+            dzt = zeta(s, z).diff(s).subs(s, n+1)
+            return (dzt + (S.EulerGamma + digamma(-n)) * zeta(n+1, z)) / gamma(-n)
+
+        return polygamma(n, z)
+
+    def _eval_rewrite_as_zeta(self, n, z, **kwargs):
+        if n.is_integer and n.is_positive:
+            return S.NegativeOne**(n + 1)*factorial(n)*zeta(n + 1, z)
+
+    def _eval_rewrite_as_harmonic(self, n, z, **kwargs):
+        if n.is_integer:
+            if n.is_zero:
+                return harmonic(z - 1) - S.EulerGamma
+            else:
+                return S.NegativeOne**(n+1) * factorial(n) * (zeta(n+1) - harmonic(z-1, n+1))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        n, z = [a.as_leading_term(x) for a in self.args]
+        o = Order(z, x)
+        if n == 0 and o.contains(1/x):
+            logx = log(x) if logx is None else logx
+            return o.getn() * logx
+        else:
+            return self.func(n, z)
+
+    def fdiff(self, argindex=2):
+        if argindex == 2:
+            n, z = self.args[:2]
+            return polygamma(n + 1, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        if args0[1] != oo or not \
+                (self.args[0].is_Integer and self.args[0].is_nonnegative):
+            return super()._eval_aseries(n, args0, x, logx)
+        z = self.args[1]
+        N = self.args[0]
+
+        if N == 0:
+            # digamma function series
+            # Abramowitz & Stegun, p. 259, 6.3.18
+            r = log(z) - 1/(2*z)
+            o = None
+            if n < 2:
+                o = Order(1/z, x)
+            else:
+                m = ceiling((n + 1)//2)
+                l = [bernoulli(2*k) / (2*k*z**(2*k)) for k in range(1, m)]
+                r -= Add(*l)
+                o = Order(1/z**n, x)
+            return r._eval_nseries(x, n, logx) + o
+        else:
+            # proper polygamma function
+            # Abramowitz & Stegun, p. 260, 6.4.10
+            # We return terms to order higher than O(x**n) on purpose
+            # -- otherwise we would not be able to return any terms for
+            #    quite a long time!
+            fac = gamma(N)
+            e0 = fac + N*fac/(2*z)
+            m = ceiling((n + 1)//2)
+            for k in range(1, m):
+                fac = fac*(2*k + N - 1)*(2*k + N - 2) / ((2*k)*(2*k - 1))
+                e0 += bernoulli(2*k)*fac/z**(2*k)
+            o = Order(1/z**(2*m), x)
+            if n == 0:
+                o = Order(1/z, x)
+            elif n == 1:
+                o = Order(1/z**2, x)
+            r = e0._eval_nseries(z, n, logx) + o
+            return (-1 * (-1/z)**N * r)._eval_nseries(x, n, logx)
+
+    def _eval_evalf(self, prec):
+        if not all(i.is_number for i in self.args):
+            return
+        s = self.args[0]._to_mpmath(prec+12)
+        z = self.args[1]._to_mpmath(prec+12)
+        if mp.isint(z) and z <= 0:
+            return S.ComplexInfinity
+        with workprec(prec+12):
+            if mp.isint(s) and s >= 0:
+                res = mp.polygamma(s, z)
+            else:
+                zt = mp.zeta(s+1, z)
+                dzt = mp.zeta(s+1, z, 1)
+                res = (dzt + (mp.euler + mp.digamma(-s)) * zt) * mp.rgamma(-s)
+        return Expr._from_mpmath(res, prec)
+
+
+class loggamma(DefinedFunction):
+    r"""
+    The ``loggamma`` function implements the logarithm of the
+    gamma function (i.e., $\log\Gamma(x)$).
+
+    Examples
+    ========
+
+    Several special values are known. For numerical integral
+    arguments we have:
+
+    >>> from sympy import loggamma
+    >>> loggamma(-2)
+    oo
+    >>> loggamma(0)
+    oo
+    >>> loggamma(1)
+    0
+    >>> loggamma(2)
+    0
+    >>> loggamma(3)
+    log(2)
+
+    And for symbolic values:
+
+    >>> from sympy import Symbol
+    >>> n = Symbol("n", integer=True, positive=True)
+    >>> loggamma(n)
+    log(gamma(n))
+    >>> loggamma(-n)
+    oo
+
+    For half-integral values:
+
+    >>> from sympy import S
+    >>> loggamma(S(5)/2)
+    log(3*sqrt(pi)/4)
+    >>> loggamma(n/2)
+    log(2**(1 - n)*sqrt(pi)*gamma(n)/gamma(n/2 + 1/2))
+
+    And general rational arguments:
+
+    >>> from sympy import expand_func
+    >>> L = loggamma(S(16)/3)
+    >>> expand_func(L).doit()
+    -5*log(3) + loggamma(1/3) + log(4) + log(7) + log(10) + log(13)
+    >>> L = loggamma(S(19)/4)
+    >>> expand_func(L).doit()
+    -4*log(4) + loggamma(3/4) + log(3) + log(7) + log(11) + log(15)
+    >>> L = loggamma(S(23)/7)
+    >>> expand_func(L).doit()
+    -3*log(7) + log(2) + loggamma(2/7) + log(9) + log(16)
+
+    The ``loggamma`` function has the following limits towards infinity:
+
+    >>> from sympy import oo
+    >>> loggamma(oo)
+    oo
+    >>> loggamma(-oo)
+    zoo
+
+    The ``loggamma`` function obeys the mirror symmetry
+    if $x \in \mathbb{C} \setminus \{-\infty, 0\}$:
+
+    >>> from sympy.abc import x
+    >>> from sympy import conjugate
+    >>> conjugate(loggamma(x))
+    loggamma(conjugate(x))
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(loggamma(x), x)
+    polygamma(0, x)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(loggamma(x), x, 0, 4).cancel()
+    -log(x) - EulerGamma*x + pi**2*x**2/12 - x**3*zeta(3)/3 + O(x**4)
+
+    We can numerically evaluate the ``loggamma`` function
+    to arbitrary precision on the whole complex plane:
+
+    >>> from sympy import I
+    >>> loggamma(5).evalf(30)
+    3.17805383034794561964694160130
+    >>> loggamma(I).evalf(20)
+    -0.65092319930185633889 - 1.8724366472624298171*I
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gamma_function
+    .. [2] https://dlmf.nist.gov/5
+    .. [3] https://mathworld.wolfram.com/LogGammaFunction.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/LogGamma/
+
+    """
+    @classmethod
+    def eval(cls, z):
+        if z.is_integer:
+            if z.is_nonpositive:
+                return oo
+            elif z.is_positive:
+                return log(gamma(z))
+        elif z.is_rational:
+            p, q = z.as_numer_denom()
+            # Half-integral values:
+            if p.is_positive and q == 2:
+                return log(sqrt(pi) * 2**(1 - p) * gamma(p) / gamma((p + 1)*S.Half))
+
+        if z is oo:
+            return oo
+        elif abs(z) is oo:
+            return S.ComplexInfinity
+        if z is S.NaN:
+            return S.NaN
+
+    def _eval_expand_func(self, **hints):
+        from sympy.concrete.summations import Sum
+        z = self.args[0]
+
+        if z.is_Rational:
+            p, q = z.as_numer_denom()
+            # General rational arguments (u + p/q)
+            # Split z as n + p/q with p < q
+            n = p // q
+            p = p - n*q
+            if p.is_positive and q.is_positive and p < q:
+                k = Dummy("k")
+                if n.is_positive:
+                    return loggamma(p / q) - n*log(q) + Sum(log((k - 1)*q + p), (k, 1, n))
+                elif n.is_negative:
+                    return loggamma(p / q) - n*log(q) + pi*I*n - Sum(log(k*q - p), (k, 1, -n))
+                elif n.is_zero:
+                    return loggamma(p / q)
+
+        return self
+
+    def _eval_nseries(self, x, n, logx=None, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        if args0[0] != oo:
+            return super()._eval_aseries(n, args0, x, logx)
+        z = self.args[0]
+        r = log(z)*(z - S.Half) - z + log(2*pi)/2
+        l = [bernoulli(2*k) / (2*k*(2*k - 1)*z**(2*k - 1)) for k in range(1, n)]
+        o = None
+        if n == 0:
+            o = Order(1, x)
+        else:
+            o = Order(1/z**n, x)
+        # It is very inefficient to first add the order and then do the nseries
+        return (r + Add(*l))._eval_nseries(x, n, logx) + o
+
+    def _eval_rewrite_as_intractable(self, z, **kwargs):
+        return log(gamma(z))
+
+    def _eval_is_real(self):
+        z = self.args[0]
+        if z.is_positive:
+            return True
+        elif z.is_nonpositive:
+            return False
+
+    def _eval_conjugate(self):
+        z = self.args[0]
+        if z not in (S.Zero, S.NegativeInfinity):
+            return self.func(z.conjugate())
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return polygamma(0, self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+class digamma(DefinedFunction):
+    r"""
+    The ``digamma`` function is the first derivative of the ``loggamma``
+    function
+
+    .. math::
+        \psi(x) := \frac{\mathrm{d}}{\mathrm{d} z} \log\Gamma(z)
+                = \frac{\Gamma'(z)}{\Gamma(z) }.
+
+    In this case, ``digamma(z) = polygamma(0, z)``.
+
+    Examples
+    ========
+
+    >>> from sympy import digamma
+    >>> digamma(0)
+    zoo
+    >>> from sympy import Symbol
+    >>> z = Symbol('z')
+    >>> digamma(z)
+    polygamma(0, z)
+
+    To retain ``digamma`` as it is:
+
+    >>> digamma(0, evaluate=False)
+    digamma(0)
+    >>> digamma(z, evaluate=False)
+    digamma(z)
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Digamma_function
+    .. [2] https://mathworld.wolfram.com/DigammaFunction.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/
+
+    """
+    def _eval_evalf(self, prec):
+        z = self.args[0]
+        nprec = prec_to_dps(prec)
+        return polygamma(0, z).evalf(n=nprec)
+
+    def fdiff(self, argindex=1):
+        z = self.args[0]
+        return polygamma(0, z).fdiff()
+
+    def _eval_is_real(self):
+        z = self.args[0]
+        return polygamma(0, z).is_real
+
+    def _eval_is_positive(self):
+        z = self.args[0]
+        return polygamma(0, z).is_positive
+
+    def _eval_is_negative(self):
+        z = self.args[0]
+        return polygamma(0, z).is_negative
+
+    def _eval_aseries(self, n, args0, x, logx):
+        as_polygamma = self.rewrite(polygamma)
+        args0 = [S.Zero,] + args0
+        return as_polygamma._eval_aseries(n, args0, x, logx)
+
+    @classmethod
+    def eval(cls, z):
+        return polygamma(0, z)
+
+    def _eval_expand_func(self, **hints):
+        z = self.args[0]
+        return polygamma(0, z).expand(func=True)
+
+    def _eval_rewrite_as_harmonic(self, z, **kwargs):
+        return harmonic(z - 1) - S.EulerGamma
+
+    def _eval_rewrite_as_polygamma(self, z, **kwargs):
+        return polygamma(0, z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        z = self.args[0]
+        return polygamma(0, z).as_leading_term(x)
+
+
+
+class trigamma(DefinedFunction):
+    r"""
+    The ``trigamma`` function is the second derivative of the ``loggamma``
+    function
+
+    .. math::
+        \psi^{(1)}(z) := \frac{\mathrm{d}^{2}}{\mathrm{d} z^{2}} \log\Gamma(z).
+
+    In this case, ``trigamma(z) = polygamma(1, z)``.
+
+    Examples
+    ========
+
+    >>> from sympy import trigamma
+    >>> trigamma(0)
+    zoo
+    >>> from sympy import Symbol
+    >>> z = Symbol('z')
+    >>> trigamma(z)
+    polygamma(1, z)
+
+    To retain ``trigamma`` as it is:
+
+    >>> trigamma(0, evaluate=False)
+    trigamma(0)
+    >>> trigamma(z, evaluate=False)
+    trigamma(z)
+
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigamma_function
+    .. [2] https://mathworld.wolfram.com/TrigammaFunction.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/
+
+    """
+    def _eval_evalf(self, prec):
+        z = self.args[0]
+        nprec = prec_to_dps(prec)
+        return polygamma(1, z).evalf(n=nprec)
+
+    def fdiff(self, argindex=1):
+        z = self.args[0]
+        return polygamma(1, z).fdiff()
+
+    def _eval_is_real(self):
+        z = self.args[0]
+        return polygamma(1, z).is_real
+
+    def _eval_is_positive(self):
+        z = self.args[0]
+        return polygamma(1, z).is_positive
+
+    def _eval_is_negative(self):
+        z = self.args[0]
+        return polygamma(1, z).is_negative
+
+    def _eval_aseries(self, n, args0, x, logx):
+        as_polygamma = self.rewrite(polygamma)
+        args0 = [S.One,] + args0
+        return as_polygamma._eval_aseries(n, args0, x, logx)
+
+    @classmethod
+    def eval(cls, z):
+        return polygamma(1, z)
+
+    def _eval_expand_func(self, **hints):
+        z = self.args[0]
+        return polygamma(1, z).expand(func=True)
+
+    def _eval_rewrite_as_zeta(self, z, **kwargs):
+        return zeta(2, z)
+
+    def _eval_rewrite_as_polygamma(self, z, **kwargs):
+        return polygamma(1, z)
+
+    def _eval_rewrite_as_harmonic(self, z, **kwargs):
+        return -harmonic(z - 1, 2) + pi**2 / 6
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        z = self.args[0]
+        return polygamma(1, z).as_leading_term(x)
+
+
+###############################################################################
+##################### COMPLETE MULTIVARIATE GAMMA FUNCTION ####################
+###############################################################################
+
+
+class multigamma(DefinedFunction):
+    r"""
+    The multivariate gamma function is a generalization of the gamma function
+
+    .. math::
+        \Gamma_p(z) = \pi^{p(p-1)/4}\prod_{k=1}^p \Gamma[z + (1 - k)/2].
+
+    In a special case, ``multigamma(x, 1) = gamma(x)``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, multigamma
+    >>> from sympy import Symbol
+    >>> x = Symbol('x')
+    >>> p = Symbol('p', positive=True, integer=True)
+
+    >>> multigamma(x, p)
+    pi**(p*(p - 1)/4)*Product(gamma(-_k/2 + x + 1/2), (_k, 1, p))
+
+    Several special values are known:
+
+    >>> multigamma(1, 1)
+    1
+    >>> multigamma(4, 1)
+    6
+    >>> multigamma(S(3)/2, 1)
+    sqrt(pi)/2
+
+    Writing ``multigamma`` in terms of the ``gamma`` function:
+
+    >>> multigamma(x, 1)
+    gamma(x)
+
+    >>> multigamma(x, 2)
+    sqrt(pi)*gamma(x)*gamma(x - 1/2)
+
+    >>> multigamma(x, 3)
+    pi**(3/2)*gamma(x)*gamma(x - 1)*gamma(x - 1/2)
+
+    Parameters
+    ==========
+
+    p : order or dimension of the multivariate gamma function
+
+    See Also
+    ========
+
+    gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma,
+    sympy.functions.special.beta_functions.beta
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multivariate_gamma_function
+
+    """
+    unbranched = True
+
+    def fdiff(self, argindex=2):
+        from sympy.concrete.summations import Sum
+        if argindex == 2:
+            x, p = self.args
+            k = Dummy("k")
+            return self.func(x, p)*Sum(polygamma(0, x + (1 - k)/2), (k, 1, p))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, p):
+        from sympy.concrete.products import Product
+        if p.is_positive is False or p.is_integer is False:
+            raise ValueError('Order parameter p must be positive integer.')
+        k = Dummy("k")
+        return (pi**(p*(p - 1)/4)*Product(gamma(x + (1 - k)/2),
+                                          (k, 1, p))).doit()
+
+    def _eval_conjugate(self):
+        x, p = self.args
+        return self.func(x.conjugate(), p)
+
+    def _eval_is_real(self):
+        x, p = self.args
+        y = 2*x
+        if y.is_integer and (y <= (p - 1)) is True:
+            return False
+        if intlike(y) and (y <= (p - 1)):
+            return False
+        if y > (p - 1) or y.is_noninteger:
+            return True

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/hyper.py

@@ -0,0 +1,1185 @@
+"""Hypergeometric and Meijer G-functions"""
+from collections import Counter
+
+from sympy.core import S, Mod
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, Derivative, ArgumentIndexError
+
+from sympy.core.containers import Tuple
+from sympy.core.mul import Mul
+from sympy.core.numbers import I, pi, oo, zoo
+from sympy.core.parameters import global_parameters
+from sympy.core.relational import Ne
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy
+
+from sympy.external.gmpy import lcm
+from sympy.functions import (sqrt, exp, log, sin, cos, asin, atan,
+        sinh, cosh, asinh, acosh, atanh, acoth)
+from sympy.functions import factorial, RisingFactorial
+from sympy.functions.elementary.complexes import Abs, re, unpolarify
+from sympy.functions.elementary.exponential import exp_polar
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.logic.boolalg import (And, Or)
+from sympy import ordered
+
+
+class TupleArg(Tuple):
+
+    # This method is only needed because hyper._eval_as_leading_term falls back
+    # (via super()) on using Function._eval_as_leading_term, which in turn
+    # calls as_leading_term on the args of the hyper. Ideally hyper should just
+    # have an _eval_as_leading_term method that handles all cases and this
+    # method should be removed because leading terms of tuples don't make
+    # sense.
+    def as_leading_term(self, *x, logx=None, cdir=0):
+        return TupleArg(*[f.as_leading_term(*x, logx=logx, cdir=cdir) for f in self.args])
+
+    def limit(self, x, xlim, dir='+'):
+        """ Compute limit x->xlim.
+        """
+        from sympy.series.limits import limit
+        return TupleArg(*[limit(f, x, xlim, dir) for f in self.args])
+
+
+# TODO should __new__ accept **options?
+# TODO should constructors should check if parameters are sensible?
+
+
+def _prep_tuple(v):
+    """
+    Turn an iterable argument *v* into a tuple and unpolarify, since both
+    hypergeometric and meijer g-functions are unbranched in their parameters.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.special.hyper import _prep_tuple
+    >>> _prep_tuple([1, 2, 3])
+    (1, 2, 3)
+    >>> _prep_tuple((4, 5))
+    (4, 5)
+    >>> _prep_tuple((7, 8, 9))
+    (7, 8, 9)
+
+    """
+    return TupleArg(*[unpolarify(x) for x in v])
+
+
+class TupleParametersBase(DefinedFunction):
+    """ Base class that takes care of differentiation, when some of
+        the arguments are actually tuples. """
+    # This is not deduced automatically since there are Tuples as arguments.
+    is_commutative = True
+
+    def _eval_derivative(self, s):
+        try:
+            res = 0
+            if self.args[0].has(s) or self.args[1].has(s):
+                for i, p in enumerate(self._diffargs):
+                    m = self._diffargs[i].diff(s)
+                    if m != 0:
+                        res += self.fdiff((1, i))*m
+            return res + self.fdiff(3)*self.args[2].diff(s)
+        except (ArgumentIndexError, NotImplementedError):
+            return Derivative(self, s)
+
+
+class hyper(TupleParametersBase):
+    r"""
+    The generalized hypergeometric function is defined by a series where
+    the ratios of successive terms are a rational function of the summation
+    index. When convergent, it is continued analytically to the largest
+    possible domain.
+
+    Explanation
+    ===========
+
+    The hypergeometric function depends on two vectors of parameters, called
+    the numerator parameters $a_p$, and the denominator parameters
+    $b_q$. It also has an argument $z$. The series definition is
+
+    .. math ::
+        {}_pF_q\left(\begin{matrix} a_1, \cdots, a_p \\ b_1, \cdots, b_q \end{matrix}
+                     \middle| z \right)
+        = \sum_{n=0}^\infty \frac{(a_1)_n \cdots (a_p)_n}{(b_1)_n \cdots (b_q)_n}
+                            \frac{z^n}{n!},
+
+    where $(a)_n = (a)(a+1)\cdots(a+n-1)$ denotes the rising factorial.
+
+    If one of the $b_q$ is a non-positive integer then the series is
+    undefined unless one of the $a_p$ is a larger (i.e., smaller in
+    magnitude) non-positive integer. If none of the $b_q$ is a
+    non-positive integer and one of the $a_p$ is a non-positive
+    integer, then the series reduces to a polynomial. To simplify the
+    following discussion, we assume that none of the $a_p$ or
+    $b_q$ is a non-positive integer. For more details, see the
+    references.
+
+    The series converges for all $z$ if $p \le q$, and thus
+    defines an entire single-valued function in this case. If $p =
+    q+1$ the series converges for $|z| < 1$, and can be continued
+    analytically into a half-plane. If $p > q+1$ the series is
+    divergent for all $z$.
+
+    Please note the hypergeometric function constructor currently does *not*
+    check if the parameters actually yield a well-defined function.
+
+    Examples
+    ========
+
+    The parameters $a_p$ and $b_q$ can be passed as arbitrary
+    iterables, for example:
+
+    >>> from sympy import hyper
+    >>> from sympy.abc import x, n, a
+    >>> h = hyper((1, 2, 3), [3, 4], x); h
+    hyper((1, 2), (4,), x)
+    >>> hyper((3, 1, 2), [3, 4], x, evaluate=False)  # don't remove duplicates
+    hyper((1, 2, 3), (3, 4), x)
+
+    There is also pretty printing (it looks better using Unicode):
+
+    >>> from sympy import pprint
+    >>> pprint(h, use_unicode=False)
+      _
+     |_  /1, 2 |  \
+     |   |     | x|
+    2  1 \  4  |  /
+
+    The parameters must always be iterables, even if they are vectors of
+    length one or zero:
+
+    >>> hyper((1, ), [], x)
+    hyper((1,), (), x)
+
+    But of course they may be variables (but if they depend on $x$ then you
+    should not expect much implemented functionality):
+
+    >>> hyper((n, a), (n**2,), x)
+    hyper((a, n), (n**2,), x)
+
+    The hypergeometric function generalizes many named special functions.
+    The function ``hyperexpand()`` tries to express a hypergeometric function
+    using named special functions. For example:
+
+    >>> from sympy import hyperexpand
+    >>> hyperexpand(hyper([], [], x))
+    exp(x)
+
+    You can also use ``expand_func()``:
+
+    >>> from sympy import expand_func
+    >>> expand_func(x*hyper([1, 1], [2], -x))
+    log(x + 1)
+
+    More examples:
+
+    >>> from sympy import S
+    >>> hyperexpand(hyper([], [S(1)/2], -x**2/4))
+    cos(x)
+    >>> hyperexpand(x*hyper([S(1)/2, S(1)/2], [S(3)/2], x**2))
+    asin(x)
+
+    We can also sometimes ``hyperexpand()`` parametric functions:
+
+    >>> from sympy.abc import a
+    >>> hyperexpand(hyper([-a], [], x))
+    (1 - x)**a
+
+    See Also
+    ========
+
+    sympy.simplify.hyperexpand
+    gamma
+    meijerg
+
+    References
+    ==========
+
+    .. [1] Luke, Y. L. (1969), The Special Functions and Their Approximations,
+           Volume 1
+    .. [2] https://en.wikipedia.org/wiki/Generalized_hypergeometric_function
+
+    """
+
+
+    def __new__(cls, ap, bq, z, **kwargs):
+        # TODO should we check convergence conditions?
+        if kwargs.pop('evaluate', global_parameters.evaluate):
+            ca = Counter(Tuple(*ap))
+            cb = Counter(Tuple(*bq))
+            common = ca & cb
+            arg = ap, bq = [], []
+            for i, c in enumerate((ca, cb)):
+                c -= common
+                for k in ordered(c):
+                    arg[i].extend([k]*c[k])
+        else:
+            ap = list(ordered(ap))
+            bq = list(ordered(bq))
+        return super().__new__(cls, _prep_tuple(ap), _prep_tuple(bq), z, **kwargs)
+
+    @classmethod
+    def eval(cls, ap, bq, z):
+        if len(ap) <= len(bq) or (len(ap) == len(bq) + 1 and (Abs(z) <= 1) == True):
+            nz = unpolarify(z)
+            if z != nz:
+                return hyper(ap, bq, nz)
+
+    def fdiff(self, argindex=3):
+        if argindex != 3:
+            raise ArgumentIndexError(self, argindex)
+        nap = Tuple(*[a + 1 for a in self.ap])
+        nbq = Tuple(*[b + 1 for b in self.bq])
+        fac = Mul(*self.ap)/Mul(*self.bq)
+        return fac*hyper(nap, nbq, self.argument)
+
+    def _eval_expand_func(self, **hints):
+        from sympy.functions.special.gamma_functions import gamma
+        from sympy.simplify.hyperexpand import hyperexpand
+        if len(self.ap) == 2 and len(self.bq) == 1 and self.argument == 1:
+            a, b = self.ap
+            c = self.bq[0]
+            return gamma(c)*gamma(c - a - b)/gamma(c - a)/gamma(c - b)
+        return hyperexpand(self)
+
+    def _eval_rewrite_as_Sum(self, ap, bq, z, **kwargs):
+        from sympy.concrete.summations import Sum
+        n = Dummy("n", integer=True)
+        rfap = [RisingFactorial(a, n) for a in ap]
+        rfbq = [RisingFactorial(b, n) for b in bq]
+        coeff = Mul(*rfap) / Mul(*rfbq)
+        return Piecewise((Sum(coeff * z**n / factorial(n), (n, 0, oo)),
+                         self.convergence_statement), (self, True))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[2]
+        x0 = arg.subs(x, 0)
+        if x0 is S.NaN:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+
+        if x0 is S.Zero:
+            return S.One
+        return super()._eval_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[2]
+        x0 = arg.limit(x, 0)
+        ap = self.args[0]
+        bq = self.args[1]
+
+        if not (arg == x and x0 == 0):
+            # It would be better to do something with arg.nseries here, rather
+            # than falling back on Function._eval_nseries. The code below
+            # though is not sufficient if arg is something like x/(x+1).
+            from sympy.simplify.hyperexpand import hyperexpand
+            return hyperexpand(super()._eval_nseries(x, n, logx))
+
+        terms = []
+
+        for i in range(n):
+            num = Mul(*[RisingFactorial(a, i) for a in ap])
+            den = Mul(*[RisingFactorial(b, i) for b in bq])
+            terms.append(((num/den) * (arg**i)) / factorial(i))
+
+        return (Add(*terms) + Order(x**n,x))
+
+    @property
+    def argument(self):
+        """ Argument of the hypergeometric function. """
+        return self.args[2]
+
+    @property
+    def ap(self):
+        """ Numerator parameters of the hypergeometric function. """
+        return Tuple(*self.args[0])
+
+    @property
+    def bq(self):
+        """ Denominator parameters of the hypergeometric function. """
+        return Tuple(*self.args[1])
+
+    @property
+    def _diffargs(self):
+        return self.ap + self.bq
+
+    @property
+    def eta(self):
+        """ A quantity related to the convergence of the series. """
+        return sum(self.ap) - sum(self.bq)
+
+    @property
+    def radius_of_convergence(self):
+        """
+        Compute the radius of convergence of the defining series.
+
+        Explanation
+        ===========
+
+        Note that even if this is not ``oo``, the function may still be
+        evaluated outside of the radius of convergence by analytic
+        continuation. But if this is zero, then the function is not actually
+        defined anywhere else.
+
+        Examples
+        ========
+
+        >>> from sympy import hyper
+        >>> from sympy.abc import z
+        >>> hyper((1, 2), [3], z).radius_of_convergence
+        1
+        >>> hyper((1, 2, 3), [4], z).radius_of_convergence
+        0
+        >>> hyper((1, 2), (3, 4), z).radius_of_convergence
+        oo
+
+        """
+        if any(a.is_integer and (a <= 0) == True for a in self.ap + self.bq):
+            aints = [a for a in self.ap if a.is_Integer and (a <= 0) == True]
+            bints = [a for a in self.bq if a.is_Integer and (a <= 0) == True]
+            if len(aints) < len(bints):
+                return S.Zero
+            popped = False
+            for b in bints:
+                cancelled = False
+                while aints:
+                    a = aints.pop()
+                    if a >= b:
+                        cancelled = True
+                        break
+                    popped = True
+                if not cancelled:
+                    return S.Zero
+            if aints or popped:
+                # There are still non-positive numerator parameters.
+                # This is a polynomial.
+                return oo
+        if len(self.ap) == len(self.bq) + 1:
+            return S.One
+        elif len(self.ap) <= len(self.bq):
+            return oo
+        else:
+            return S.Zero
+
+    @property
+    def convergence_statement(self):
+        """ Return a condition on z under which the series converges. """
+        R = self.radius_of_convergence
+        if R == 0:
+            return False
+        if R == oo:
+            return True
+        # The special functions and their approximations, page 44
+        e = self.eta
+        z = self.argument
+        c1 = And(re(e) < 0, abs(z) <= 1)
+        c2 = And(0 <= re(e), re(e) < 1, abs(z) <= 1, Ne(z, 1))
+        c3 = And(re(e) >= 1, abs(z) < 1)
+        return Or(c1, c2, c3)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.hyperexpand import hyperexpand
+        return hyperexpand(self)
+
+
+class meijerg(TupleParametersBase):
+    r"""
+    The Meijer G-function is defined by a Mellin-Barnes type integral that
+    resembles an inverse Mellin transform. It generalizes the hypergeometric
+    functions.
+
+    Explanation
+    ===========
+
+    The Meijer G-function depends on four sets of parameters. There are
+    "*numerator parameters*"
+    $a_1, \ldots, a_n$ and $a_{n+1}, \ldots, a_p$, and there are
+    "*denominator parameters*"
+    $b_1, \ldots, b_m$ and $b_{m+1}, \ldots, b_q$.
+    Confusingly, it is traditionally denoted as follows (note the position
+    of $m$, $n$, $p$, $q$, and how they relate to the lengths of the four
+    parameter vectors):
+
+    .. math ::
+        G_{p,q}^{m,n} \left(\begin{matrix}a_1, \cdots, a_n & a_{n+1}, \cdots, a_p \\
+                                        b_1, \cdots, b_m & b_{m+1}, \cdots, b_q
+                          \end{matrix} \middle| z \right).
+
+    However, in SymPy the four parameter vectors are always available
+    separately (see examples), so that there is no need to keep track of the
+    decorating sub- and super-scripts on the G symbol.
+
+    The G function is defined as the following integral:
+
+    .. math ::
+         \frac{1}{2 \pi i} \int_L \frac{\prod_{j=1}^m \Gamma(b_j - s)
+         \prod_{j=1}^n \Gamma(1 - a_j + s)}{\prod_{j=m+1}^q \Gamma(1- b_j +s)
+         \prod_{j=n+1}^p \Gamma(a_j - s)} z^s \mathrm{d}s,
+
+    where $\Gamma(z)$ is the gamma function. There are three possible
+    contours which we will not describe in detail here (see the references).
+    If the integral converges along more than one of them, the definitions
+    agree. The contours all separate the poles of $\Gamma(1-a_j+s)$
+    from the poles of $\Gamma(b_k-s)$, so in particular the G function
+    is undefined if $a_j - b_k \in \mathbb{Z}_{>0}$ for some
+    $j \le n$ and $k \le m$.
+
+    The conditions under which one of the contours yields a convergent integral
+    are complicated and we do not state them here, see the references.
+
+    Please note currently the Meijer G-function constructor does *not* check any
+    convergence conditions.
+
+    Examples
+    ========
+
+    You can pass the parameters either as four separate vectors:
+
+    >>> from sympy import meijerg, Tuple, pprint
+    >>> from sympy.abc import x, a
+    >>> pprint(meijerg((1, 2), (a, 4), (5,), [], x), use_unicode=False)
+     __1, 2 /1, 2  4, a |  \
+    /__     |           | x|
+    \_|4, 1 \ 5         |  /
+
+    Or as two nested vectors:
+
+    >>> pprint(meijerg([(1, 2), (3, 4)], ([5], Tuple()), x), use_unicode=False)
+     __1, 2 /1, 2  3, 4 |  \
+    /__     |           | x|
+    \_|4, 1 \ 5         |  /
+
+    As with the hypergeometric function, the parameters may be passed as
+    arbitrary iterables. Vectors of length zero and one also have to be
+    passed as iterables. The parameters need not be constants, but if they
+    depend on the argument then not much implemented functionality should be
+    expected.
+
+    All the subvectors of parameters are available:
+
+    >>> from sympy import pprint
+    >>> g = meijerg([1], [2], [3], [4], x)
+    >>> pprint(g, use_unicode=False)
+     __1, 1 /1  2 |  \
+    /__     |     | x|
+    \_|2, 2 \3  4 |  /
+    >>> g.an
+    (1,)
+    >>> g.ap
+    (1, 2)
+    >>> g.aother
+    (2,)
+    >>> g.bm
+    (3,)
+    >>> g.bq
+    (3, 4)
+    >>> g.bother
+    (4,)
+
+    The Meijer G-function generalizes the hypergeometric functions.
+    In some cases it can be expressed in terms of hypergeometric functions,
+    using Slater's theorem. For example:
+
+    >>> from sympy import hyperexpand
+    >>> from sympy.abc import a, b, c
+    >>> hyperexpand(meijerg([a], [], [c], [b], x), allow_hyper=True)
+    x**c*gamma(-a + c + 1)*hyper((-a + c + 1,),
+                                 (-b + c + 1,), -x)/gamma(-b + c + 1)
+
+    Thus the Meijer G-function also subsumes many named functions as special
+    cases. You can use ``expand_func()`` or ``hyperexpand()`` to (try to)
+    rewrite a Meijer G-function in terms of named special functions. For
+    example:
+
+    >>> from sympy import expand_func, S
+    >>> expand_func(meijerg([[],[]], [[0],[]], -x))
+    exp(x)
+    >>> hyperexpand(meijerg([[],[]], [[S(1)/2],[0]], (x/2)**2))
+    sin(x)/sqrt(pi)
+
+    See Also
+    ========
+
+    hyper
+    sympy.simplify.hyperexpand
+
+    References
+    ==========
+
+    .. [1] Luke, Y. L. (1969), The Special Functions and Their Approximations,
+           Volume 1
+    .. [2] https://en.wikipedia.org/wiki/Meijer_G-function
+
+    """
+
+
+    def __new__(cls, *args, **kwargs):
+        if len(args) == 5:
+            args = [(args[0], args[1]), (args[2], args[3]), args[4]]
+        if len(args) != 3:
+            raise TypeError("args must be either as, as', bs, bs', z or "
+                            "as, bs, z")
+
+        def tr(p):
+            if len(p) != 2:
+                raise TypeError("wrong argument")
+            p = [list(ordered(i)) for i in p]
+            return TupleArg(_prep_tuple(p[0]), _prep_tuple(p[1]))
+
+        arg0, arg1 = tr(args[0]), tr(args[1])
+        if Tuple(arg0, arg1).has(oo, zoo, -oo):
+            raise ValueError("G-function parameters must be finite")
+        if any((a - b).is_Integer and a - b > 0
+               for a in arg0[0] for b in arg1[0]):
+            raise ValueError("no parameter a1, ..., an may differ from "
+                         "any b1, ..., bm by a positive integer")
+
+        # TODO should we check convergence conditions?
+        return super().__new__(cls, arg0, arg1, args[2], **kwargs)
+
+    def fdiff(self, argindex=3):
+        if argindex != 3:
+            return self._diff_wrt_parameter(argindex[1])
+        if len(self.an) >= 1:
+            a = list(self.an)
+            a[0] -= 1
+            G = meijerg(a, self.aother, self.bm, self.bother, self.argument)
+            return 1/self.argument * ((self.an[0] - 1)*self + G)
+        elif len(self.bm) >= 1:
+            b = list(self.bm)
+            b[0] += 1
+            G = meijerg(self.an, self.aother, b, self.bother, self.argument)
+            return 1/self.argument * (self.bm[0]*self - G)
+        else:
+            return S.Zero
+
+    def _diff_wrt_parameter(self, idx):
+        # Differentiation wrt a parameter can only be done in very special
+        # cases. In particular, if we want to differentiate with respect to
+        # `a`, all other gamma factors have to reduce to rational functions.
+        #
+        # Let MT denote mellin transform. Suppose T(-s) is the gamma factor
+        # appearing in the definition of G. Then
+        #
+        #   MT(log(z)G(z)) = d/ds T(s) = d/da T(s) + ...
+        #
+        # Thus d/da G(z) = log(z)G(z) - ...
+        # The ... can be evaluated as a G function under the above conditions,
+        # the formula being most easily derived by using
+        #
+        # d  Gamma(s + n)    Gamma(s + n) / 1    1                1     \
+        # -- ------------ =  ------------ | - + ----  + ... + --------- |
+        # ds Gamma(s)        Gamma(s)     \ s   s + 1         s + n - 1 /
+        #
+        # which follows from the difference equation of the digamma function.
+        # (There is a similar equation for -n instead of +n).
+
+        # We first figure out how to pair the parameters.
+        an = list(self.an)
+        ap = list(self.aother)
+        bm = list(self.bm)
+        bq = list(self.bother)
+        if idx < len(an):
+            an.pop(idx)
+        else:
+            idx -= len(an)
+            if idx < len(ap):
+                ap.pop(idx)
+            else:
+                idx -= len(ap)
+                if idx < len(bm):
+                    bm.pop(idx)
+                else:
+                    bq.pop(idx - len(bm))
+        pairs1 = []
+        pairs2 = []
+        for l1, l2, pairs in [(an, bq, pairs1), (ap, bm, pairs2)]:
+            while l1:
+                x = l1.pop()
+                found = None
+                for i, y in enumerate(l2):
+                    if not Mod((x - y).simplify(), 1):
+                        found = i
+                        break
+                if found is None:
+                    raise NotImplementedError('Derivative not expressible '
+                                              'as G-function?')
+                y = l2[i]
+                l2.pop(i)
+                pairs.append((x, y))
+
+        # Now build the result.
+        res = log(self.argument)*self
+
+        for a, b in pairs1:
+            sign = 1
+            n = a - b
+            base = b
+            if n < 0:
+                sign = -1
+                n = b - a
+                base = a
+            for k in range(n):
+                res -= sign*meijerg(self.an + (base + k + 1,), self.aother,
+                                    self.bm, self.bother + (base + k + 0,),
+                                    self.argument)
+
+        for a, b in pairs2:
+            sign = 1
+            n = b - a
+            base = a
+            if n < 0:
+                sign = -1
+                n = a - b
+                base = b
+            for k in range(n):
+                res -= sign*meijerg(self.an, self.aother + (base + k + 1,),
+                                    self.bm + (base + k + 0,), self.bother,
+                                    self.argument)
+
+        return res
+
+    def get_period(self):
+        """
+        Return a number $P$ such that $G(x*exp(I*P)) == G(x)$.
+
+        Examples
+        ========
+
+        >>> from sympy import meijerg, pi, S
+        >>> from sympy.abc import z
+
+        >>> meijerg([1], [], [], [], z).get_period()
+        2*pi
+        >>> meijerg([pi], [], [], [], z).get_period()
+        oo
+        >>> meijerg([1, 2], [], [], [], z).get_period()
+        oo
+        >>> meijerg([1,1], [2], [1, S(1)/2, S(1)/3], [1], z).get_period()
+        12*pi
+
+        """
+        # This follows from slater's theorem.
+        def compute(l):
+            # first check that no two differ by an integer
+            for i, b in enumerate(l):
+                if not b.is_Rational:
+                    return oo
+                for j in range(i + 1, len(l)):
+                    if not Mod((b - l[j]).simplify(), 1):
+                        return oo
+            return lcm(*(x.q for x in l))
+        beta = compute(self.bm)
+        alpha = compute(self.an)
+        p, q = len(self.ap), len(self.bq)
+        if p == q:
+            if oo in (alpha, beta):
+                return oo
+            return 2*pi*lcm(alpha, beta)
+        elif p < q:
+            return 2*pi*beta
+        else:
+            return 2*pi*alpha
+
+    def _eval_expand_func(self, **hints):
+        from sympy.simplify.hyperexpand import hyperexpand
+        return hyperexpand(self)
+
+    def _eval_evalf(self, prec):
+        # The default code is insufficient for polar arguments.
+        # mpmath provides an optional argument "r", which evaluates
+        # G(z**(1/r)). I am not sure what its intended use is, but we hijack it
+        # here in the following way: to evaluate at a number z of |argument|
+        # less than (say) n*pi, we put r=1/n, compute z' = root(z, n)
+        # (carefully so as not to loose the branch information), and evaluate
+        # G(z'**(1/r)) = G(z'**n) = G(z).
+        import mpmath
+        znum = self.argument._eval_evalf(prec)
+        if znum.has(exp_polar):
+            znum, branch = znum.as_coeff_mul(exp_polar)
+            if len(branch) != 1:
+                return
+            branch = branch[0].args[0]/I
+        else:
+            branch = S.Zero
+        n = ceiling(abs(branch/pi)) + 1
+        znum = znum**(S.One/n)*exp(I*branch / n)
+
+        # Convert all args to mpf or mpc
+        try:
+            [z, r, ap, bq] = [arg._to_mpmath(prec)
+                    for arg in [znum, 1/n, self.args[0], self.args[1]]]
+        except ValueError:
+            return
+
+        with mpmath.workprec(prec):
+            v = mpmath.meijerg(ap, bq, z, r)
+
+        return Expr._from_mpmath(v, prec)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.simplify.hyperexpand import hyperexpand
+        return hyperexpand(self).as_leading_term(x, logx=logx, cdir=cdir)
+
+    def integrand(self, s):
+        """ Get the defining integrand D(s). """
+        from sympy.functions.special.gamma_functions import gamma
+        return self.argument**s \
+            * Mul(*(gamma(b - s) for b in self.bm)) \
+            * Mul(*(gamma(1 - a + s) for a in self.an)) \
+            / Mul(*(gamma(1 - b + s) for b in self.bother)) \
+            / Mul(*(gamma(a - s) for a in self.aother))
+
+    @property
+    def argument(self):
+        """ Argument of the Meijer G-function. """
+        return self.args[2]
+
+    @property
+    def an(self):
+        """ First set of numerator parameters. """
+        return Tuple(*self.args[0][0])
+
+    @property
+    def ap(self):
+        """ Combined numerator parameters. """
+        return Tuple(*(self.args[0][0] + self.args[0][1]))
+
+    @property
+    def aother(self):
+        """ Second set of numerator parameters. """
+        return Tuple(*self.args[0][1])
+
+    @property
+    def bm(self):
+        """ First set of denominator parameters. """
+        return Tuple(*self.args[1][0])
+
+    @property
+    def bq(self):
+        """ Combined denominator parameters. """
+        return Tuple(*(self.args[1][0] + self.args[1][1]))
+
+    @property
+    def bother(self):
+        """ Second set of denominator parameters. """
+        return Tuple(*self.args[1][1])
+
+    @property
+    def _diffargs(self):
+        return self.ap + self.bq
+
+    @property
+    def nu(self):
+        """ A quantity related to the convergence region of the integral,
+            c.f. references. """
+        return sum(self.bq) - sum(self.ap)
+
+    @property
+    def delta(self):
+        """ A quantity related to the convergence region of the integral,
+            c.f. references. """
+        return len(self.bm) + len(self.an) - S(len(self.ap) + len(self.bq))/2
+
+    @property
+    def is_number(self):
+        """ Returns true if expression has numeric data only. """
+        return not self.free_symbols
+
+
+class HyperRep(DefinedFunction):
+    """
+    A base class for "hyper representation functions".
+
+    This is used exclusively in ``hyperexpand()``, but fits more logically here.
+
+    pFq is branched at 1 if p == q+1. For use with slater-expansion, we want
+    define an "analytic continuation" to all polar numbers, which is
+    continuous on circles and on the ray t*exp_polar(I*pi). Moreover, we want
+    a "nice" expression for the various cases.
+
+    This base class contains the core logic, concrete derived classes only
+    supply the actual functions.
+
+    """
+
+
+    @classmethod
+    def eval(cls, *args):
+        newargs = tuple(map(unpolarify, args[:-1])) + args[-1:]
+        if args != newargs:
+            return cls(*newargs)
+
+    @classmethod
+    def _expr_small(cls, x):
+        """ An expression for F(x) which holds for |x| < 1. """
+        raise NotImplementedError
+
+    @classmethod
+    def _expr_small_minus(cls, x):
+        """ An expression for F(-x) which holds for |x| < 1. """
+        raise NotImplementedError
+
+    @classmethod
+    def _expr_big(cls, x, n):
+        """ An expression for F(exp_polar(2*I*pi*n)*x), |x| > 1. """
+        raise NotImplementedError
+
+    @classmethod
+    def _expr_big_minus(cls, x, n):
+        """ An expression for F(exp_polar(2*I*pi*n + pi*I)*x), |x| > 1. """
+        raise NotImplementedError
+
+    def _eval_rewrite_as_nonrep(self, *args, **kwargs):
+        x, n = self.args[-1].extract_branch_factor(allow_half=True)
+        minus = False
+        newargs = self.args[:-1] + (x,)
+        if not n.is_Integer:
+            minus = True
+            n -= S.Half
+        newerargs = newargs + (n,)
+        if minus:
+            small = self._expr_small_minus(*newargs)
+            big = self._expr_big_minus(*newerargs)
+        else:
+            small = self._expr_small(*newargs)
+            big = self._expr_big(*newerargs)
+
+        if big == small:
+            return small
+        return Piecewise((big, abs(x) > 1), (small, True))
+
+    def _eval_rewrite_as_nonrepsmall(self, *args, **kwargs):
+        x, n = self.args[-1].extract_branch_factor(allow_half=True)
+        args = self.args[:-1] + (x,)
+        if not n.is_Integer:
+            return self._expr_small_minus(*args)
+        return self._expr_small(*args)
+
+
+class HyperRep_power1(HyperRep):
+    """ Return a representative for hyper([-a], [], z) == (1 - z)**a. """
+
+    @classmethod
+    def _expr_small(cls, a, x):
+        return (1 - x)**a
+
+    @classmethod
+    def _expr_small_minus(cls, a, x):
+        return (1 + x)**a
+
+    @classmethod
+    def _expr_big(cls, a, x, n):
+        if a.is_integer:
+            return cls._expr_small(a, x)
+        return (x - 1)**a*exp((2*n - 1)*pi*I*a)
+
+    @classmethod
+    def _expr_big_minus(cls, a, x, n):
+        if a.is_integer:
+            return cls._expr_small_minus(a, x)
+        return (1 + x)**a*exp(2*n*pi*I*a)
+
+
+class HyperRep_power2(HyperRep):
+    """ Return a representative for hyper([a, a - 1/2], [2*a], z). """
+
+    @classmethod
+    def _expr_small(cls, a, x):
+        return 2**(2*a - 1)*(1 + sqrt(1 - x))**(1 - 2*a)
+
+    @classmethod
+    def _expr_small_minus(cls, a, x):
+        return 2**(2*a - 1)*(1 + sqrt(1 + x))**(1 - 2*a)
+
+    @classmethod
+    def _expr_big(cls, a, x, n):
+        sgn = -1
+        if n.is_odd:
+            sgn = 1
+            n -= 1
+        return 2**(2*a - 1)*(1 + sgn*I*sqrt(x - 1))**(1 - 2*a) \
+            *exp(-2*n*pi*I*a)
+
+    @classmethod
+    def _expr_big_minus(cls, a, x, n):
+        sgn = 1
+        if n.is_odd:
+            sgn = -1
+        return sgn*2**(2*a - 1)*(sqrt(1 + x) + sgn)**(1 - 2*a)*exp(-2*pi*I*a*n)
+
+
+class HyperRep_log1(HyperRep):
+    """ Represent -z*hyper([1, 1], [2], z) == log(1 - z). """
+    @classmethod
+    def _expr_small(cls, x):
+        return log(1 - x)
+
+    @classmethod
+    def _expr_small_minus(cls, x):
+        return log(1 + x)
+
+    @classmethod
+    def _expr_big(cls, x, n):
+        return log(x - 1) + (2*n - 1)*pi*I
+
+    @classmethod
+    def _expr_big_minus(cls, x, n):
+        return log(1 + x) + 2*n*pi*I
+
+
+class HyperRep_atanh(HyperRep):
+    """ Represent hyper([1/2, 1], [3/2], z) == atanh(sqrt(z))/sqrt(z). """
+    @classmethod
+    def _expr_small(cls, x):
+        return atanh(sqrt(x))/sqrt(x)
+
+    def _expr_small_minus(cls, x):
+        return atan(sqrt(x))/sqrt(x)
+
+    def _expr_big(cls, x, n):
+        if n.is_even:
+            return (acoth(sqrt(x)) + I*pi/2)/sqrt(x)
+        else:
+            return (acoth(sqrt(x)) - I*pi/2)/sqrt(x)
+
+    def _expr_big_minus(cls, x, n):
+        if n.is_even:
+            return atan(sqrt(x))/sqrt(x)
+        else:
+            return (atan(sqrt(x)) - pi)/sqrt(x)
+
+
+class HyperRep_asin1(HyperRep):
+    """ Represent hyper([1/2, 1/2], [3/2], z) == asin(sqrt(z))/sqrt(z). """
+    @classmethod
+    def _expr_small(cls, z):
+        return asin(sqrt(z))/sqrt(z)
+
+    @classmethod
+    def _expr_small_minus(cls, z):
+        return asinh(sqrt(z))/sqrt(z)
+
+    @classmethod
+    def _expr_big(cls, z, n):
+        return S.NegativeOne**n*((S.Half - n)*pi/sqrt(z) + I*acosh(sqrt(z))/sqrt(z))
+
+    @classmethod
+    def _expr_big_minus(cls, z, n):
+        return S.NegativeOne**n*(asinh(sqrt(z))/sqrt(z) + n*pi*I/sqrt(z))
+
+
+class HyperRep_asin2(HyperRep):
+    """ Represent hyper([1, 1], [3/2], z) == asin(sqrt(z))/sqrt(z)/sqrt(1-z). """
+    # TODO this can be nicer
+    @classmethod
+    def _expr_small(cls, z):
+        return HyperRep_asin1._expr_small(z) \
+            /HyperRep_power1._expr_small(S.Half, z)
+
+    @classmethod
+    def _expr_small_minus(cls, z):
+        return HyperRep_asin1._expr_small_minus(z) \
+            /HyperRep_power1._expr_small_minus(S.Half, z)
+
+    @classmethod
+    def _expr_big(cls, z, n):
+        return HyperRep_asin1._expr_big(z, n) \
+            /HyperRep_power1._expr_big(S.Half, z, n)
+
+    @classmethod
+    def _expr_big_minus(cls, z, n):
+        return HyperRep_asin1._expr_big_minus(z, n) \
+            /HyperRep_power1._expr_big_minus(S.Half, z, n)
+
+
+class HyperRep_sqrts1(HyperRep):
+    """ Return a representative for hyper([-a, 1/2 - a], [1/2], z). """
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return ((1 - sqrt(z))**(2*a) + (1 + sqrt(z))**(2*a))/2
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return (1 + z)**a*cos(2*a*atan(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        if n.is_even:
+            return ((sqrt(z) + 1)**(2*a)*exp(2*pi*I*n*a) +
+                    (sqrt(z) - 1)**(2*a)*exp(2*pi*I*(n - 1)*a))/2
+        else:
+            n -= 1
+            return ((sqrt(z) - 1)**(2*a)*exp(2*pi*I*a*(n + 1)) +
+                    (sqrt(z) + 1)**(2*a)*exp(2*pi*I*a*n))/2
+
+    @classmethod
+    def _expr_big_minus(cls, a, z, n):
+        if n.is_even:
+            return (1 + z)**a*exp(2*pi*I*n*a)*cos(2*a*atan(sqrt(z)))
+        else:
+            return (1 + z)**a*exp(2*pi*I*n*a)*cos(2*a*atan(sqrt(z)) - 2*pi*a)
+
+
+class HyperRep_sqrts2(HyperRep):
+    """ Return a representative for
+          sqrt(z)/2*[(1-sqrt(z))**2a - (1 + sqrt(z))**2a]
+          == -2*z/(2*a+1) d/dz hyper([-a - 1/2, -a], [1/2], z)"""
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return sqrt(z)*((1 - sqrt(z))**(2*a) - (1 + sqrt(z))**(2*a))/2
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return sqrt(z)*(1 + z)**a*sin(2*a*atan(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        if n.is_even:
+            return sqrt(z)/2*((sqrt(z) - 1)**(2*a)*exp(2*pi*I*a*(n - 1)) -
+                              (sqrt(z) + 1)**(2*a)*exp(2*pi*I*a*n))
+        else:
+            n -= 1
+            return sqrt(z)/2*((sqrt(z) - 1)**(2*a)*exp(2*pi*I*a*(n + 1)) -
+                              (sqrt(z) + 1)**(2*a)*exp(2*pi*I*a*n))
+
+    def _expr_big_minus(cls, a, z, n):
+        if n.is_even:
+            return (1 + z)**a*exp(2*pi*I*n*a)*sqrt(z)*sin(2*a*atan(sqrt(z)))
+        else:
+            return (1 + z)**a*exp(2*pi*I*n*a)*sqrt(z) \
+                *sin(2*a*atan(sqrt(z)) - 2*pi*a)
+
+
+class HyperRep_log2(HyperRep):
+    """ Represent log(1/2 + sqrt(1 - z)/2) == -z/4*hyper([3/2, 1, 1], [2, 2], z) """
+
+    @classmethod
+    def _expr_small(cls, z):
+        return log(S.Half + sqrt(1 - z)/2)
+
+    @classmethod
+    def _expr_small_minus(cls, z):
+        return log(S.Half + sqrt(1 + z)/2)
+
+    @classmethod
+    def _expr_big(cls, z, n):
+        if n.is_even:
+            return (n - S.Half)*pi*I + log(sqrt(z)/2) + I*asin(1/sqrt(z))
+        else:
+            return (n - S.Half)*pi*I + log(sqrt(z)/2) - I*asin(1/sqrt(z))
+
+    def _expr_big_minus(cls, z, n):
+        if n.is_even:
+            return pi*I*n + log(S.Half + sqrt(1 + z)/2)
+        else:
+            return pi*I*n + log(sqrt(1 + z)/2 - S.Half)
+
+
+class HyperRep_cosasin(HyperRep):
+    """ Represent hyper([a, -a], [1/2], z) == cos(2*a*asin(sqrt(z))). """
+    # Note there are many alternative expressions, e.g. as powers of a sum of
+    # square roots.
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return cos(2*a*asin(sqrt(z)))
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return cosh(2*a*asinh(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        return cosh(2*a*acosh(sqrt(z)) + a*pi*I*(2*n - 1))
+
+    @classmethod
+    def _expr_big_minus(cls, a, z, n):
+        return cosh(2*a*asinh(sqrt(z)) + 2*a*pi*I*n)
+
+
+class HyperRep_sinasin(HyperRep):
+    """ Represent 2*a*z*hyper([1 - a, 1 + a], [3/2], z)
+        == sqrt(z)/sqrt(1-z)*sin(2*a*asin(sqrt(z))) """
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return sqrt(z)/sqrt(1 - z)*sin(2*a*asin(sqrt(z)))
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return -sqrt(z)/sqrt(1 + z)*sinh(2*a*asinh(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        return -1/sqrt(1 - 1/z)*sinh(2*a*acosh(sqrt(z)) + a*pi*I*(2*n - 1))
+
+    @classmethod
+    def _expr_big_minus(cls, a, z, n):
+        return -1/sqrt(1 + 1/z)*sinh(2*a*asinh(sqrt(z)) + 2*a*pi*I*n)
+
+class appellf1(DefinedFunction):
+    r"""
+    This is the Appell hypergeometric function of two variables as:
+
+    .. math ::
+        F_1(a,b_1,b_2,c,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+        \frac{(a)_{m+n} (b_1)_m (b_2)_n}{(c)_{m+n}}
+        \frac{x^m y^n}{m! n!}.
+
+    Examples
+    ========
+
+    >>> from sympy import appellf1, symbols
+    >>> x, y, a, b1, b2, c = symbols('x y a b1 b2 c')
+    >>> appellf1(2., 1., 6., 4., 5., 6.)
+    0.0063339426292673
+    >>> appellf1(12., 12., 6., 4., 0.5, 0.12)
+    172870711.659936
+    >>> appellf1(40, 2, 6, 4, 15, 60)
+    appellf1(40, 2, 6, 4, 15, 60)
+    >>> appellf1(20., 12., 10., 3., 0.5, 0.12)
+    15605338197184.4
+    >>> appellf1(40, 2, 6, 4, x, y)
+    appellf1(40, 2, 6, 4, x, y)
+    >>> appellf1(a, b1, b2, c, x, y)
+    appellf1(a, b1, b2, c, x, y)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Appell_series
+    .. [2] https://functions.wolfram.com/HypergeometricFunctions/AppellF1/
+
+    """
+
+    @classmethod
+    def eval(cls, a, b1, b2, c, x, y):
+        if default_sort_key(b1) > default_sort_key(b2):
+            b1, b2 = b2, b1
+            x, y = y, x
+            return cls(a, b1, b2, c, x, y)
+        elif b1 == b2 and default_sort_key(x) > default_sort_key(y):
+            x, y = y, x
+            return cls(a, b1, b2, c, x, y)
+        if x == 0 and y == 0:
+            return S.One
+
+    def fdiff(self, argindex=5):
+        a, b1, b2, c, x, y = self.args
+        if argindex == 5:
+            return (a*b1/c)*appellf1(a + 1, b1 + 1, b2, c + 1, x, y)
+        elif argindex == 6:
+            return (a*b2/c)*appellf1(a + 1, b1, b2 + 1, c + 1, x, y)
+        elif argindex in (1, 2, 3, 4):
+            return Derivative(self, self.args[argindex-1])
+        else:
+            raise ArgumentIndexError(self, argindex)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/mathieu_functions.py

@@ -0,0 +1,269 @@
+""" This module contains the Mathieu functions.
+"""
+
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, cos
+
+
+class MathieuBase(DefinedFunction):
+    """
+    Abstract base class for Mathieu functions.
+
+    This class is meant to reduce code duplication.
+
+    """
+
+    unbranched = True
+
+    def _eval_conjugate(self):
+        a, q, z = self.args
+        return self.func(a.conjugate(), q.conjugate(), z.conjugate())
+
+
+class mathieus(MathieuBase):
+    r"""
+    The Mathieu Sine function $S(a,q,z)$.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Cosine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieus
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieus(a, q, z)
+    mathieus(a, q, z)
+
+    >>> mathieus(a, 0, z)
+    sin(sqrt(a)*z)
+
+    >>> diff(mathieus(a, q, z), z)
+    mathieusprime(a, q, z)
+
+    See Also
+    ========
+
+    mathieuc: Mathieu cosine function.
+    mathieusprime: Derivative of Mathieu sine function.
+    mathieucprime: Derivative of Mathieu cosine function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuS/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return mathieusprime(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return sin(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return -cls(a, q, -z)
+
+
+class mathieuc(MathieuBase):
+    r"""
+    The Mathieu Cosine function $C(a,q,z)$.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Sine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieuc
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieuc(a, q, z)
+    mathieuc(a, q, z)
+
+    >>> mathieuc(a, 0, z)
+    cos(sqrt(a)*z)
+
+    >>> diff(mathieuc(a, q, z), z)
+    mathieucprime(a, q, z)
+
+    See Also
+    ========
+
+    mathieus: Mathieu sine function
+    mathieusprime: Derivative of Mathieu sine function
+    mathieucprime: Derivative of Mathieu cosine function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuC/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return mathieucprime(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return cos(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return cls(a, q, -z)
+
+
+class mathieusprime(MathieuBase):
+    r"""
+    The derivative $S^{\prime}(a,q,z)$ of the Mathieu Sine function.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Cosine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieusprime
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieusprime(a, q, z)
+    mathieusprime(a, q, z)
+
+    >>> mathieusprime(a, 0, z)
+    sqrt(a)*cos(sqrt(a)*z)
+
+    >>> diff(mathieusprime(a, q, z), z)
+    (-a + 2*q*cos(2*z))*mathieus(a, q, z)
+
+    See Also
+    ========
+
+    mathieus: Mathieu sine function
+    mathieuc: Mathieu cosine function
+    mathieucprime: Derivative of Mathieu cosine function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuSPrime/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return (2*q*cos(2*z) - a)*mathieus(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return sqrt(a)*cos(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return cls(a, q, -z)
+
+
+class mathieucprime(MathieuBase):
+    r"""
+    The derivative $C^{\prime}(a,q,z)$ of the Mathieu Cosine function.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Sine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieucprime
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieucprime(a, q, z)
+    mathieucprime(a, q, z)
+
+    >>> mathieucprime(a, 0, z)
+    -sqrt(a)*sin(sqrt(a)*z)
+
+    >>> diff(mathieucprime(a, q, z), z)
+    (-a + 2*q*cos(2*z))*mathieuc(a, q, z)
+
+    See Also
+    ========
+
+    mathieus: Mathieu sine function
+    mathieuc: Mathieu cosine function
+    mathieusprime: Derivative of Mathieu sine function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuCPrime/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return (2*q*cos(2*z) - a)*mathieuc(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return -sqrt(a)*sin(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return -cls(a, q, -z)

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/polynomials.py

@@ -0,0 +1,1447 @@
+"""
+This module mainly implements special orthogonal polynomials.
+
+See also functions.combinatorial.numbers which contains some
+combinatorial polynomials.
+
+"""
+
+from sympy.core import Rational
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.functions.combinatorial.factorials import binomial, factorial, RisingFactorial
+from sympy.functions.elementary.complexes import re
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos, sec
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.polys.orthopolys import (chebyshevt_poly, chebyshevu_poly,
+                                    gegenbauer_poly, hermite_poly, hermite_prob_poly,
+                                    jacobi_poly, laguerre_poly, legendre_poly)
+
+_x = Dummy('x')
+
+
+class OrthogonalPolynomial(DefinedFunction):
+    """Base class for orthogonal polynomials.
+    """
+
+    @classmethod
+    def _eval_at_order(cls, n, x):
+        if n.is_integer and n >= 0:
+            return cls._ortho_poly(int(n), _x).subs(_x, x)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0], self.args[1].conjugate())
+
+#----------------------------------------------------------------------------
+# Jacobi polynomials
+#
+
+
+class jacobi(OrthogonalPolynomial):
+    r"""
+    Jacobi polynomial $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    Explanation
+    ===========
+
+    ``jacobi(n, alpha, beta, x)`` gives the $n$th Jacobi polynomial
+    in $x$, $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    The Jacobi polynomials are orthogonal on $[-1, 1]$ with respect
+    to the weight $\left(1-x\right)^\alpha \left(1+x\right)^\beta$.
+
+    Examples
+    ========
+
+    >>> from sympy import jacobi, S, conjugate, diff
+    >>> from sympy.abc import a, b, n, x
+
+    >>> jacobi(0, a, b, x)
+    1
+    >>> jacobi(1, a, b, x)
+    a/2 - b/2 + x*(a/2 + b/2 + 1)
+    >>> jacobi(2, a, b, x)
+    a**2/8 - a*b/4 - a/8 + b**2/8 - b/8 + x**2*(a**2/8 + a*b/4 + 7*a/8 + b**2/8 + 7*b/8 + 3/2) + x*(a**2/4 + 3*a/4 - b**2/4 - 3*b/4) - 1/2
+
+    >>> jacobi(n, a, b, x)
+    jacobi(n, a, b, x)
+
+    >>> jacobi(n, a, a, x)
+    RisingFactorial(a + 1, n)*gegenbauer(n,
+        a + 1/2, x)/RisingFactorial(2*a + 1, n)
+
+    >>> jacobi(n, 0, 0, x)
+    legendre(n, x)
+
+    >>> jacobi(n, S(1)/2, S(1)/2, x)
+    RisingFactorial(3/2, n)*chebyshevu(n, x)/factorial(n + 1)
+
+    >>> jacobi(n, -S(1)/2, -S(1)/2, x)
+    RisingFactorial(1/2, n)*chebyshevt(n, x)/factorial(n)
+
+    >>> jacobi(n, a, b, -x)
+    (-1)**n*jacobi(n, b, a, x)
+
+    >>> jacobi(n, a, b, 0)
+    gamma(a + n + 1)*hyper((-n, -b - n), (a + 1,), -1)/(2**n*factorial(n)*gamma(a + 1))
+    >>> jacobi(n, a, b, 1)
+    RisingFactorial(a + 1, n)/factorial(n)
+
+    >>> conjugate(jacobi(n, a, b, x))
+    jacobi(n, conjugate(a), conjugate(b), conjugate(x))
+
+    >>> diff(jacobi(n,a,b,x), x)
+    (a/2 + b/2 + n/2 + 1/2)*jacobi(n - 1, a + 1, b + 1, x)
+
+    See Also
+    ========
+
+    gegenbauer,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly,
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Jacobi_polynomials
+    .. [2] https://mathworld.wolfram.com/JacobiPolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/JacobiP/
+
+    """
+
+    @classmethod
+    def eval(cls, n, a, b, x):
+        # Simplify to other polynomials
+        # P^{a, a}_n(x)
+        if a == b:
+            if a == Rational(-1, 2):
+                return RisingFactorial(S.Half, n) / factorial(n) * chebyshevt(n, x)
+            elif a.is_zero:
+                return legendre(n, x)
+            elif a == S.Half:
+                return RisingFactorial(3*S.Half, n) / factorial(n + 1) * chebyshevu(n, x)
+            else:
+                return RisingFactorial(a + 1, n) / RisingFactorial(2*a + 1, n) * gegenbauer(n, a + S.Half, x)
+        elif b == -a:
+            # P^{a, -a}_n(x)
+            return gamma(n + a + 1) / gamma(n + 1) * (1 + x)**(a/2) / (1 - x)**(a/2) * assoc_legendre(n, -a, x)
+
+        if not n.is_Number:
+            # Symbolic result P^{a,b}_n(x)
+            # P^{a,b}_n(-x)  --->  (-1)**n * P^{b,a}_n(-x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * jacobi(n, b, a, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return (2**(-n) * gamma(a + n + 1) / (gamma(a + 1) * factorial(n)) *
+                        hyper([-b - n, -n], [a + 1], -1))
+            if x == S.One:
+                return RisingFactorial(a + 1, n) / factorial(n)
+            elif x is S.Infinity:
+                if n.is_positive:
+                    # Make sure a+b+2*n \notin Z
+                    if (a + b + 2*n).is_integer:
+                        raise ValueError("Error. a + b + 2*n should not be an integer.")
+                    return RisingFactorial(a + b + n + 1, n) * S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            return jacobi_poly(n, a, b, x)
+
+    def fdiff(self, argindex=4):
+        from sympy.concrete.summations import Sum
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt a
+            n, a, b, x = self.args
+            k = Dummy("k")
+            f1 = 1 / (a + b + n + k + 1)
+            f2 = ((a + b + 2*k + 1) * RisingFactorial(b + k + 1, n - k) /
+                  ((n - k) * RisingFactorial(a + b + k + 1, n - k)))
+            return Sum(f1 * (jacobi(n, a, b, x) + f2*jacobi(k, a, b, x)), (k, 0, n - 1))
+        elif argindex == 3:
+            # Diff wrt b
+            n, a, b, x = self.args
+            k = Dummy("k")
+            f1 = 1 / (a + b + n + k + 1)
+            f2 = (-1)**(n - k) * ((a + b + 2*k + 1) * RisingFactorial(a + k + 1, n - k) /
+                  ((n - k) * RisingFactorial(a + b + k + 1, n - k)))
+            return Sum(f1 * (jacobi(n, a, b, x) + f2*jacobi(k, a, b, x)), (k, 0, n - 1))
+        elif argindex == 4:
+            # Diff wrt x
+            n, a, b, x = self.args
+            return S.Half * (a + b + n + 1) * jacobi(n - 1, a + 1, b + 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, a, b, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        # Make sure n \in N
+        if n.is_negative or n.is_integer is False:
+            raise ValueError("Error: n should be a non-negative integer.")
+        k = Dummy("k")
+        kern = (RisingFactorial(-n, k) * RisingFactorial(a + b + n + 1, k) * RisingFactorial(a + k + 1, n - k) /
+                factorial(k) * ((1 - x)/2)**k)
+        return 1 / factorial(n) * Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, a, b, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, a, b, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, a, b, x = self.args
+        return self.func(n, a.conjugate(), b.conjugate(), x.conjugate())
+
+
+def jacobi_normalized(n, a, b, x):
+    r"""
+    Jacobi polynomial $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    Explanation
+    ===========
+
+    ``jacobi_normalized(n, alpha, beta, x)`` gives the $n$th
+    Jacobi polynomial in $x$, $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    The Jacobi polynomials are orthogonal on $[-1, 1]$ with respect
+    to the weight $\left(1-x\right)^\alpha \left(1+x\right)^\beta$.
+
+    This functions returns the polynomials normilzed:
+
+    .. math::
+
+        \int_{-1}^{1}
+          P_m^{\left(\alpha, \beta\right)}(x)
+          P_n^{\left(\alpha, \beta\right)}(x)
+          (1-x)^{\alpha} (1+x)^{\beta} \mathrm{d}x
+        = \delta_{m,n}
+
+    Examples
+    ========
+
+    >>> from sympy import jacobi_normalized
+    >>> from sympy.abc import n,a,b,x
+
+    >>> jacobi_normalized(n, a, b, x)
+    jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)/((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1)))
+
+    Parameters
+    ==========
+
+    n : integer degree of polynomial
+
+    a : alpha value
+
+    b : beta value
+
+    x : symbol
+
+    See Also
+    ========
+
+    gegenbauer,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly,
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Jacobi_polynomials
+    .. [2] https://mathworld.wolfram.com/JacobiPolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/JacobiP/
+
+    """
+    nfactor = (S(2)**(a + b + 1) * (gamma(n + a + 1) * gamma(n + b + 1))
+               / (2*n + a + b + 1) / (factorial(n) * gamma(n + a + b + 1)))
+
+    return jacobi(n, a, b, x) / sqrt(nfactor)
+
+
+#----------------------------------------------------------------------------
+# Gegenbauer polynomials
+#
+
+
+class gegenbauer(OrthogonalPolynomial):
+    r"""
+    Gegenbauer polynomial $C_n^{\left(\alpha\right)}(x)$.
+
+    Explanation
+    ===========
+
+    ``gegenbauer(n, alpha, x)`` gives the $n$th Gegenbauer polynomial
+    in $x$, $C_n^{\left(\alpha\right)}(x)$.
+
+    The Gegenbauer polynomials are orthogonal on $[-1, 1]$ with
+    respect to the weight $\left(1-x^2\right)^{\alpha-\frac{1}{2}}$.
+
+    Examples
+    ========
+
+    >>> from sympy import gegenbauer, conjugate, diff
+    >>> from sympy.abc import n,a,x
+    >>> gegenbauer(0, a, x)
+    1
+    >>> gegenbauer(1, a, x)
+    2*a*x
+    >>> gegenbauer(2, a, x)
+    -a + x**2*(2*a**2 + 2*a)
+    >>> gegenbauer(3, a, x)
+    x**3*(4*a**3/3 + 4*a**2 + 8*a/3) + x*(-2*a**2 - 2*a)
+
+    >>> gegenbauer(n, a, x)
+    gegenbauer(n, a, x)
+    >>> gegenbauer(n, a, -x)
+    (-1)**n*gegenbauer(n, a, x)
+
+    >>> gegenbauer(n, a, 0)
+    2**n*sqrt(pi)*gamma(a + n/2)/(gamma(a)*gamma(1/2 - n/2)*gamma(n + 1))
+    >>> gegenbauer(n, a, 1)
+    gamma(2*a + n)/(gamma(2*a)*gamma(n + 1))
+
+    >>> conjugate(gegenbauer(n, a, x))
+    gegenbauer(n, conjugate(a), conjugate(x))
+
+    >>> diff(gegenbauer(n, a, x), x)
+    2*a*gegenbauer(n - 1, a + 1, x)
+
+    See Also
+    ========
+
+    jacobi,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gegenbauer_polynomials
+    .. [2] https://mathworld.wolfram.com/GegenbauerPolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/GegenbauerC3/
+
+    """
+
+    @classmethod
+    def eval(cls, n, a, x):
+        # For negative n the polynomials vanish
+        # See https://functions.wolfram.com/Polynomials/GegenbauerC3/03/01/03/0012/
+        if n.is_negative:
+            return S.Zero
+
+        # Some special values for fixed a
+        if a == S.Half:
+            return legendre(n, x)
+        elif a == S.One:
+            return chebyshevu(n, x)
+        elif a == S.NegativeOne:
+            return S.Zero
+
+        if not n.is_Number:
+            # Handle this before the general sign extraction rule
+            if x == S.NegativeOne:
+                if (re(a) > S.Half) == True:
+                    return S.ComplexInfinity
+                else:
+                    return (cos(S.Pi*(a+n)) * sec(S.Pi*a) * gamma(2*a+n) /
+                                (gamma(2*a) * gamma(n+1)))
+
+            # Symbolic result C^a_n(x)
+            # C^a_n(-x)  --->  (-1)**n * C^a_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * gegenbauer(n, a, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return (2**n * sqrt(S.Pi) * gamma(a + S.Half*n) /
+                        (gamma((1 - n)/2) * gamma(n + 1) * gamma(a)) )
+            if x == S.One:
+                return gamma(2*a + n) / (gamma(2*a) * gamma(n + 1))
+            elif x is S.Infinity:
+                if n.is_positive:
+                    return RisingFactorial(a, n) * S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            return gegenbauer_poly(n, a, x)
+
+    def fdiff(self, argindex=3):
+        from sympy.concrete.summations import Sum
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt a
+            n, a, x = self.args
+            k = Dummy("k")
+            factor1 = 2 * (1 + (-1)**(n - k)) * (k + a) / ((k +
+                           n + 2*a) * (n - k))
+            factor2 = 2*(k + 1) / ((k + 2*a) * (2*k + 2*a + 1)) + \
+                2 / (k + n + 2*a)
+            kern = factor1*gegenbauer(k, a, x) + factor2*gegenbauer(n, a, x)
+            return Sum(kern, (k, 0, n - 1))
+        elif argindex == 3:
+            # Diff wrt x
+            n, a, x = self.args
+            return 2*a*gegenbauer(n - 1, a + 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, a, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = ((-1)**k * RisingFactorial(a, n - k) * (2*x)**(n - 2*k) /
+                (factorial(k) * factorial(n - 2*k)))
+        return Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, a, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, a, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, a, x = self.args
+        return self.func(n, a.conjugate(), x.conjugate())
+
+#----------------------------------------------------------------------------
+# Chebyshev polynomials of first and second kind
+#
+
+
+class chebyshevt(OrthogonalPolynomial):
+    r"""
+    Chebyshev polynomial of the first kind, $T_n(x)$.
+
+    Explanation
+    ===========
+
+    ``chebyshevt(n, x)`` gives the $n$th Chebyshev polynomial (of the first
+    kind) in $x$, $T_n(x)$.
+
+    The Chebyshev polynomials of the first kind are orthogonal on
+    $[-1, 1]$ with respect to the weight $\frac{1}{\sqrt{1-x^2}}$.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevt, diff
+    >>> from sympy.abc import n,x
+    >>> chebyshevt(0, x)
+    1
+    >>> chebyshevt(1, x)
+    x
+    >>> chebyshevt(2, x)
+    2*x**2 - 1
+
+    >>> chebyshevt(n, x)
+    chebyshevt(n, x)
+    >>> chebyshevt(n, -x)
+    (-1)**n*chebyshevt(n, x)
+    >>> chebyshevt(-n, x)
+    chebyshevt(n, x)
+
+    >>> chebyshevt(n, 0)
+    cos(pi*n/2)
+    >>> chebyshevt(n, -1)
+    (-1)**n
+
+    >>> diff(chebyshevt(n, x), x)
+    n*chebyshevu(n - 1, x)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Chebyshev_polynomial
+    .. [2] https://mathworld.wolfram.com/ChebyshevPolynomialoftheFirstKind.html
+    .. [3] https://mathworld.wolfram.com/ChebyshevPolynomialoftheSecondKind.html
+    .. [4] https://functions.wolfram.com/Polynomials/ChebyshevT/
+    .. [5] https://functions.wolfram.com/Polynomials/ChebyshevU/
+
+    """
+
+    _ortho_poly = staticmethod(chebyshevt_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result T_n(x)
+            # T_n(-x)  --->  (-1)**n * T_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * chebyshevt(n, -x)
+            # T_{-n}(x)  --->  T_n(x)
+            if n.could_extract_minus_sign():
+                return chebyshevt(-n, x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return cos(S.Half * S.Pi * n)
+            if x == S.One:
+                return S.One
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                # T_{-n}(x) == T_n(x)
+                return cls._eval_at_order(-n, x)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return n * chebyshevu(n - 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = binomial(n, 2*k) * (x**2 - 1)**k * x**(n - 2*k)
+        return Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class chebyshevu(OrthogonalPolynomial):
+    r"""
+    Chebyshev polynomial of the second kind, $U_n(x)$.
+
+    Explanation
+    ===========
+
+    ``chebyshevu(n, x)`` gives the $n$th Chebyshev polynomial of the second
+    kind in x, $U_n(x)$.
+
+    The Chebyshev polynomials of the second kind are orthogonal on
+    $[-1, 1]$ with respect to the weight $\sqrt{1-x^2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevu, diff
+    >>> from sympy.abc import n,x
+    >>> chebyshevu(0, x)
+    1
+    >>> chebyshevu(1, x)
+    2*x
+    >>> chebyshevu(2, x)
+    4*x**2 - 1
+
+    >>> chebyshevu(n, x)
+    chebyshevu(n, x)
+    >>> chebyshevu(n, -x)
+    (-1)**n*chebyshevu(n, x)
+    >>> chebyshevu(-n, x)
+    -chebyshevu(n - 2, x)
+
+    >>> chebyshevu(n, 0)
+    cos(pi*n/2)
+    >>> chebyshevu(n, 1)
+    n + 1
+
+    >>> diff(chebyshevu(n, x), x)
+    (-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Chebyshev_polynomial
+    .. [2] https://mathworld.wolfram.com/ChebyshevPolynomialoftheFirstKind.html
+    .. [3] https://mathworld.wolfram.com/ChebyshevPolynomialoftheSecondKind.html
+    .. [4] https://functions.wolfram.com/Polynomials/ChebyshevT/
+    .. [5] https://functions.wolfram.com/Polynomials/ChebyshevU/
+
+    """
+
+    _ortho_poly = staticmethod(chebyshevu_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result U_n(x)
+            # U_n(-x)  --->  (-1)**n * U_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * chebyshevu(n, -x)
+            # U_{-n}(x)  --->  -U_{n-2}(x)
+            if n.could_extract_minus_sign():
+                if n == S.NegativeOne:
+                    # n can not be -1 here
+                    return S.Zero
+                elif not (-n - 2).could_extract_minus_sign():
+                    return -chebyshevu(-n - 2, x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return cos(S.Half * S.Pi * n)
+            if x == S.One:
+                return S.One + n
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                # U_{-n}(x)  --->  -U_{n-2}(x)
+                if n == S.NegativeOne:
+                    return S.Zero
+                else:
+                    return -cls._eval_at_order(-n - 2, x)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return ((n + 1) * chebyshevt(n + 1, x) - x * chebyshevu(n, x)) / (x**2 - 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = S.NegativeOne**k * factorial(
+            n - k) * (2*x)**(n - 2*k) / (factorial(k) * factorial(n - 2*k))
+        return Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class chebyshevt_root(DefinedFunction):
+    r"""
+    ``chebyshev_root(n, k)`` returns the $k$th root (indexed from zero) of
+    the $n$th Chebyshev polynomial of the first kind; that is, if
+    $0 \le k < n$, ``chebyshevt(n, chebyshevt_root(n, k)) == 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevt, chebyshevt_root
+    >>> chebyshevt_root(3, 2)
+    -sqrt(3)/2
+    >>> chebyshevt(3, chebyshevt_root(3, 2))
+    0
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+    """
+
+    @classmethod
+    def eval(cls, n, k):
+        if not ((0 <= k) and (k < n)):
+            raise ValueError("must have 0 <= k < n, "
+                "got k = %s and n = %s" % (k, n))
+        return cos(S.Pi*(2*k + 1)/(2*n))
+
+
+class chebyshevu_root(DefinedFunction):
+    r"""
+    ``chebyshevu_root(n, k)`` returns the $k$th root (indexed from zero) of the
+    $n$th Chebyshev polynomial of the second kind; that is, if $0 \le k < n$,
+    ``chebyshevu(n, chebyshevu_root(n, k)) == 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevu, chebyshevu_root
+    >>> chebyshevu_root(3, 2)
+    -sqrt(2)/2
+    >>> chebyshevu(3, chebyshevu_root(3, 2))
+    0
+
+    See Also
+    ========
+
+    chebyshevt, chebyshevt_root, chebyshevu,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+    """
+
+
+    @classmethod
+    def eval(cls, n, k):
+        if not ((0 <= k) and (k < n)):
+            raise ValueError("must have 0 <= k < n, "
+                "got k = %s and n = %s" % (k, n))
+        return cos(S.Pi*(k + 1)/(n + 1))
+
+#----------------------------------------------------------------------------
+# Legendre polynomials and Associated Legendre polynomials
+#
+
+
+class legendre(OrthogonalPolynomial):
+    r"""
+    ``legendre(n, x)`` gives the $n$th Legendre polynomial of $x$, $P_n(x)$
+
+    Explanation
+    ===========
+
+    The Legendre polynomials are orthogonal on $[-1, 1]$ with respect to
+    the constant weight 1. They satisfy $P_n(1) = 1$ for all $n$; further,
+    $P_n$ is odd for odd $n$ and even for even $n$.
+
+    Examples
+    ========
+
+    >>> from sympy import legendre, diff
+    >>> from sympy.abc import x, n
+    >>> legendre(0, x)
+    1
+    >>> legendre(1, x)
+    x
+    >>> legendre(2, x)
+    3*x**2/2 - 1/2
+    >>> legendre(n, x)
+    legendre(n, x)
+    >>> diff(legendre(n,x), x)
+    n*(x*legendre(n, x) - legendre(n - 1, x))/(x**2 - 1)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Legendre_polynomial
+    .. [2] https://mathworld.wolfram.com/LegendrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LegendreP/
+    .. [4] https://functions.wolfram.com/Polynomials/LegendreP2/
+
+    """
+
+    _ortho_poly = staticmethod(legendre_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result L_n(x)
+            # L_n(-x)  --->  (-1)**n * L_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * legendre(n, -x)
+            # L_{-n}(x)  --->  L_{n-1}(x)
+            if n.could_extract_minus_sign() and not(-n - 1).could_extract_minus_sign():
+                return legendre(-n - S.One, x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return sqrt(S.Pi)/(gamma(S.Half - n/2)*gamma(S.One + n/2))
+            elif x == S.One:
+                return S.One
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial;
+            # L_{-n}(x)  --->  L_{n-1}(x)
+            if n.is_negative:
+                n = -n - S.One
+            return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            # Find better formula, this is unsuitable for x = +/-1
+            # https://www.autodiff.org/ad16/Oral/Buecker_Legendre.pdf says
+            # at x = 1:
+            #    n*(n + 1)/2            , m = 0
+            #    oo                     , m = 1
+            #    -(n-1)*n*(n+1)*(n+2)/4 , m = 2
+            #    0                      , m = 3, 4, ..., n
+            #
+            # at x = -1
+            #    (-1)**(n+1)*n*(n + 1)/2       , m = 0
+            #    (-1)**n*oo                    , m = 1
+            #    (-1)**n*(n-1)*n*(n+1)*(n+2)/4 , m = 2
+            #    0                             , m = 3, 4, ..., n
+            n, x = self.args
+            return n/(x**2 - 1)*(x*legendre(n, x) - legendre(n - 1, x))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = S.NegativeOne**k*binomial(n, k)**2*((1 + x)/2)**(n - k)*((1 - x)/2)**k
+        return Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class assoc_legendre(DefinedFunction):
+    r"""
+    ``assoc_legendre(n, m, x)`` gives $P_n^m(x)$, where $n$ and $m$ are
+    the degree and order or an expression which is related to the nth
+    order Legendre polynomial, $P_n(x)$ in the following manner:
+
+    .. math::
+        P_n^m(x) = (-1)^m (1 - x^2)^{\frac{m}{2}}
+                   \frac{\mathrm{d}^m P_n(x)}{\mathrm{d} x^m}
+
+    Explanation
+    ===========
+
+    Associated Legendre polynomials are orthogonal on $[-1, 1]$ with:
+
+    - weight $= 1$            for the same $m$ and different $n$.
+    - weight $= \frac{1}{1-x^2}$   for the same $n$ and different $m$.
+
+    Examples
+    ========
+
+    >>> from sympy import assoc_legendre
+    >>> from sympy.abc import x, m, n
+    >>> assoc_legendre(0,0, x)
+    1
+    >>> assoc_legendre(1,0, x)
+    x
+    >>> assoc_legendre(1,1, x)
+    -sqrt(1 - x**2)
+    >>> assoc_legendre(n,m,x)
+    assoc_legendre(n, m, x)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Associated_Legendre_polynomials
+    .. [2] https://mathworld.wolfram.com/LegendrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LegendreP/
+    .. [4] https://functions.wolfram.com/Polynomials/LegendreP2/
+
+    """
+
+    @classmethod
+    def _eval_at_order(cls, n, m):
+        P = legendre_poly(n, _x, polys=True).diff((_x, m))
+        return S.NegativeOne**m * (1 - _x**2)**Rational(m, 2) * P.as_expr()
+
+    @classmethod
+    def eval(cls, n, m, x):
+        if m.could_extract_minus_sign():
+            # P^{-m}_n  --->  F * P^m_n
+            return S.NegativeOne**(-m) * (factorial(m + n)/factorial(n - m)) * assoc_legendre(n, -m, x)
+        if m == 0:
+            # P^0_n  --->  L_n
+            return legendre(n, x)
+        if x == 0:
+            return 2**m*sqrt(S.Pi) / (gamma((1 - m - n)/2)*gamma(1 - (m - n)/2))
+        if n.is_Number and m.is_Number and n.is_integer and m.is_integer:
+            if n.is_negative:
+                raise ValueError("%s : 1st index must be nonnegative integer (got %r)" % (cls, n))
+            if abs(m) > n:
+                raise ValueError("%s : abs('2nd index') must be <= '1st index' (got %r, %r)" % (cls, n, m))
+            return cls._eval_at_order(int(n), abs(int(m))).subs(_x, x)
+
+    def fdiff(self, argindex=3):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt m
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 3:
+            # Diff wrt x
+            # Find better formula, this is unsuitable for x = 1
+            n, m, x = self.args
+            return 1/(x**2 - 1)*(x*n*assoc_legendre(n, m, x) - (m + n)*assoc_legendre(n - 1, m, x))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, m, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = factorial(2*n - 2*k)/(2**n*factorial(n - k)*factorial(
+            k)*factorial(n - 2*k - m))*S.NegativeOne**k*x**(n - m - 2*k)
+        return (1 - x**2)**(m/2) * Sum(kern, (k, 0, floor((n - m)*S.Half)))
+
+    def _eval_rewrite_as_polynomial(self, n, m, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, m, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, m, x = self.args
+        return self.func(n, m.conjugate(), x.conjugate())
+
+#----------------------------------------------------------------------------
+# Hermite polynomials
+#
+
+
+class hermite(OrthogonalPolynomial):
+    r"""
+    ``hermite(n, x)`` gives the $n$th Hermite polynomial in $x$, $H_n(x)$.
+
+    Explanation
+    ===========
+
+    The Hermite polynomials are orthogonal on $(-\infty, \infty)$
+    with respect to the weight $\exp\left(-x^2\right)$.
+
+    Examples
+    ========
+
+    >>> from sympy import hermite, diff
+    >>> from sympy.abc import x, n
+    >>> hermite(0, x)
+    1
+    >>> hermite(1, x)
+    2*x
+    >>> hermite(2, x)
+    4*x**2 - 2
+    >>> hermite(n, x)
+    hermite(n, x)
+    >>> diff(hermite(n,x), x)
+    2*n*hermite(n - 1, x)
+    >>> hermite(n, -x)
+    (-1)**n*hermite(n, x)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hermite_polynomial
+    .. [2] https://mathworld.wolfram.com/HermitePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/HermiteH/
+
+    """
+
+    _ortho_poly = staticmethod(hermite_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result H_n(x)
+            # H_n(-x)  --->  (-1)**n * H_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * hermite(n, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return 2**n * sqrt(S.Pi) / gamma((S.One - n)/2)
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                raise ValueError(
+                    "The index n must be nonnegative integer (got %r)" % n)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return 2*n*hermite(n - 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = S.NegativeOne**k / (factorial(k)*factorial(n - 2*k)) * (2*x)**(n - 2*k)
+        return factorial(n)*Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+    def _eval_rewrite_as_hermite_prob(self, n, x, **kwargs):
+        return sqrt(2)**n * hermite_prob(n, x*sqrt(2))
+
+
+class hermite_prob(OrthogonalPolynomial):
+    r"""
+    ``hermite_prob(n, x)`` gives the $n$th probabilist's Hermite polynomial
+    in $x$, $He_n(x)$.
+
+    Explanation
+    ===========
+
+    The probabilist's Hermite polynomials are orthogonal on $(-\infty, \infty)$
+    with respect to the weight $\exp\left(-\frac{x^2}{2}\right)$. They are monic
+    polynomials, related to the plain Hermite polynomials (:py:class:`~.hermite`) by
+
+    .. math :: He_n(x) = 2^{-n/2} H_n(x/\sqrt{2})
+
+    Examples
+    ========
+
+    >>> from sympy import hermite_prob, diff, I
+    >>> from sympy.abc import x, n
+    >>> hermite_prob(1, x)
+    x
+    >>> hermite_prob(5, x)
+    x**5 - 10*x**3 + 15*x
+    >>> diff(hermite_prob(n,x), x)
+    n*hermite_prob(n - 1, x)
+    >>> hermite_prob(n, -x)
+    (-1)**n*hermite_prob(n, x)
+
+    The sum of absolute values of coefficients of $He_n(x)$ is the number of
+    matchings in the complete graph $K_n$ or telephone number, A000085 in the OEIS:
+
+    >>> [hermite_prob(n,I) / I**n for n in range(11)]
+    [1, 1, 2, 4, 10, 26, 76, 232, 764, 2620, 9496]
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hermite_polynomial
+    .. [2] https://mathworld.wolfram.com/HermitePolynomial.html
+    """
+
+    _ortho_poly = staticmethod(hermite_prob_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * hermite_prob(n, -x)
+            if x.is_zero:
+                return sqrt(S.Pi) / gamma((S.One-n) / 2)
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            if n.is_negative:
+                ValueError("n must be a nonnegative integer, not %r" % n)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 2:
+            n, x = self.args
+            return n*hermite_prob(n-1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = (-S.Half)**k * x**(n-2*k) / (factorial(k) * factorial(n-2*k))
+        return factorial(n)*Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+    def _eval_rewrite_as_hermite(self, n, x, **kwargs):
+        return sqrt(2)**(-n) * hermite(n, x/sqrt(2))
+
+
+#----------------------------------------------------------------------------
+# Laguerre polynomials
+#
+
+
+class laguerre(OrthogonalPolynomial):
+    r"""
+    Returns the $n$th Laguerre polynomial in $x$, $L_n(x)$.
+
+    Examples
+    ========
+
+    >>> from sympy import laguerre, diff
+    >>> from sympy.abc import x, n
+    >>> laguerre(0, x)
+    1
+    >>> laguerre(1, x)
+    1 - x
+    >>> laguerre(2, x)
+    x**2/2 - 2*x + 1
+    >>> laguerre(3, x)
+    -x**3/6 + 3*x**2/2 - 3*x + 1
+
+    >>> laguerre(n, x)
+    laguerre(n, x)
+
+    >>> diff(laguerre(n, x), x)
+    -assoc_laguerre(n - 1, 1, x)
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of Laguerre polynomial. Must be `n \ge 0`.
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Laguerre_polynomial
+    .. [2] https://mathworld.wolfram.com/LaguerrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LaguerreL/
+    .. [4] https://functions.wolfram.com/Polynomials/LaguerreL3/
+
+    """
+
+    _ortho_poly = staticmethod(laguerre_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if n.is_integer is False:
+            raise ValueError("Error: n should be an integer.")
+        if not n.is_Number:
+            # Symbolic result L_n(x)
+            # L_{n}(-x)  --->  exp(-x) * L_{-n-1}(x)
+            # L_{-n}(x)  --->  exp(x) * L_{n-1}(-x)
+            if n.could_extract_minus_sign() and not(-n - 1).could_extract_minus_sign():
+                return exp(x)*laguerre(-n - 1, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return S.One
+            elif x is S.NegativeInfinity:
+                return S.Infinity
+            elif x is S.Infinity:
+                return S.NegativeOne**n * S.Infinity
+        else:
+            if n.is_negative:
+                return exp(x)*laguerre(-n - 1, -x)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return -assoc_laguerre(n - 1, 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        # Make sure n \in N_0
+        if n.is_negative:
+            return exp(x) * self._eval_rewrite_as_Sum(-n - 1, -x, **kwargs)
+        if n.is_integer is False:
+            raise ValueError("Error: n should be an integer.")
+        k = Dummy("k")
+        kern = RisingFactorial(-n, k) / factorial(k)**2 * x**k
+        return Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class assoc_laguerre(OrthogonalPolynomial):
+    r"""
+    Returns the $n$th generalized Laguerre polynomial in $x$, $L_n(x)$.
+
+    Examples
+    ========
+
+    >>> from sympy import assoc_laguerre, diff
+    >>> from sympy.abc import x, n, a
+    >>> assoc_laguerre(0, a, x)
+    1
+    >>> assoc_laguerre(1, a, x)
+    a - x + 1
+    >>> assoc_laguerre(2, a, x)
+    a**2/2 + 3*a/2 + x**2/2 + x*(-a - 2) + 1
+    >>> assoc_laguerre(3, a, x)
+    a**3/6 + a**2 + 11*a/6 - x**3/6 + x**2*(a/2 + 3/2) +
+        x*(-a**2/2 - 5*a/2 - 3) + 1
+
+    >>> assoc_laguerre(n, a, 0)
+    binomial(a + n, a)
+
+    >>> assoc_laguerre(n, a, x)
+    assoc_laguerre(n, a, x)
+
+    >>> assoc_laguerre(n, 0, x)
+    laguerre(n, x)
+
+    >>> diff(assoc_laguerre(n, a, x), x)
+    -assoc_laguerre(n - 1, a + 1, x)
+
+    >>> diff(assoc_laguerre(n, a, x), a)
+    Sum(assoc_laguerre(_k, a, x)/(-a + n), (_k, 0, n - 1))
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of Laguerre polynomial. Must be `n \ge 0`.
+
+    alpha : Expr
+        Arbitrary expression. For ``alpha=0`` regular Laguerre
+        polynomials will be generated.
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Laguerre_polynomial#Generalized_Laguerre_polynomials
+    .. [2] https://mathworld.wolfram.com/AssociatedLaguerrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LaguerreL/
+    .. [4] https://functions.wolfram.com/Polynomials/LaguerreL3/
+
+    """
+
+    @classmethod
+    def eval(cls, n, alpha, x):
+        # L_{n}^{0}(x)  --->  L_{n}(x)
+        if alpha.is_zero:
+            return laguerre(n, x)
+
+        if not n.is_Number:
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return binomial(n + alpha, alpha)
+            elif x is S.Infinity and n > 0:
+                return S.NegativeOne**n * S.Infinity
+            elif x is S.NegativeInfinity and n > 0:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                raise ValueError(
+                    "The index n must be nonnegative integer (got %r)" % n)
+            else:
+                return laguerre_poly(n, x, alpha)
+
+    def fdiff(self, argindex=3):
+        from sympy.concrete.summations import Sum
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt alpha
+            n, alpha, x = self.args
+            k = Dummy("k")
+            return Sum(assoc_laguerre(k, alpha, x) / (n - alpha), (k, 0, n - 1))
+        elif argindex == 3:
+            # Diff wrt x
+            n, alpha, x = self.args
+            return -assoc_laguerre(n - 1, alpha + 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, alpha, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        # Make sure n \in N_0
+        if n.is_negative or n.is_integer is False:
+            raise ValueError("Error: n should be a non-negative integer.")
+        k = Dummy("k")
+        kern = RisingFactorial(
+            -n, k) / (gamma(k + alpha + 1) * factorial(k)) * x**k
+        return gamma(n + alpha + 1) / factorial(n) * Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, alpha, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, alpha, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, alpha, x = self.args
+        return self.func(n, alpha.conjugate(), x.conjugate())

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/singularity_functions.py

@@ -0,0 +1,235 @@
+from sympy.core import S, oo, diff
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.logic import fuzzy_not
+from sympy.core.relational import Eq
+from sympy.functions.elementary.complexes import im
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import Heaviside
+
+###############################################################################
+############################# SINGULARITY FUNCTION ############################
+###############################################################################
+
+
+class SingularityFunction(DefinedFunction):
+    r"""
+    Singularity functions are a class of discontinuous functions.
+
+    Explanation
+    ===========
+
+    Singularity functions take a variable, an offset, and an exponent as
+    arguments. These functions are represented using Macaulay brackets as:
+
+    SingularityFunction(x, a, n) := <x - a>^n
+
+    The singularity function will automatically evaluate to
+    ``Derivative(DiracDelta(x - a), x, -n - 1)`` if ``n < 0``
+    and ``(x - a)**n*Heaviside(x - a, 1)`` if ``n >= 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import SingularityFunction, diff, Piecewise, DiracDelta, Heaviside, Symbol
+    >>> from sympy.abc import x, a, n
+    >>> SingularityFunction(x, a, n)
+    SingularityFunction(x, a, n)
+    >>> y = Symbol('y', positive=True)
+    >>> n = Symbol('n', nonnegative=True)
+    >>> SingularityFunction(y, -10, n)
+    (y + 10)**n
+    >>> y = Symbol('y', negative=True)
+    >>> SingularityFunction(y, 10, n)
+    0
+    >>> SingularityFunction(x, 4, -1).subs(x, 4)
+    oo
+    >>> SingularityFunction(x, 10, -2).subs(x, 10)
+    oo
+    >>> SingularityFunction(4, 1, 5)
+    243
+    >>> diff(SingularityFunction(x, 1, 5) + SingularityFunction(x, 1, 4), x)
+    4*SingularityFunction(x, 1, 3) + 5*SingularityFunction(x, 1, 4)
+    >>> diff(SingularityFunction(x, 4, 0), x, 2)
+    SingularityFunction(x, 4, -2)
+    >>> SingularityFunction(x, 4, 5).rewrite(Piecewise)
+    Piecewise(((x - 4)**5, x >= 4), (0, True))
+    >>> expr = SingularityFunction(x, a, n)
+    >>> y = Symbol('y', positive=True)
+    >>> n = Symbol('n', nonnegative=True)
+    >>> expr.subs({x: y, a: -10, n: n})
+    (y + 10)**n
+
+    The methods ``rewrite(DiracDelta)``, ``rewrite(Heaviside)``, and
+    ``rewrite('HeavisideDiracDelta')`` returns the same output. One can use any
+    of these methods according to their choice.
+
+    >>> expr = SingularityFunction(x, 4, 5) + SingularityFunction(x, -3, -1) - SingularityFunction(x, 0, -2)
+    >>> expr.rewrite(Heaviside)
+    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
+    >>> expr.rewrite(DiracDelta)
+    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
+    >>> expr.rewrite('HeavisideDiracDelta')
+    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
+
+    See Also
+    ========
+
+    DiracDelta, Heaviside
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Singularity_function
+
+    """
+
+    is_real = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of a DiracDelta Function.
+
+        Explanation
+        ===========
+
+        The difference between ``diff()`` and ``fdiff()`` is: ``diff()`` is the
+        user-level function and ``fdiff()`` is an object method. ``fdiff()`` is
+        a convenience method available in the ``Function`` class. It returns
+        the derivative of the function without considering the chain rule.
+        ``diff(function, x)`` calls ``Function._eval_derivative`` which in turn
+        calls ``fdiff()`` internally to compute the derivative of the function.
+
+        """
+
+        if argindex == 1:
+            x, a, n = self.args
+            if n in (S.Zero, S.NegativeOne, S(-2), S(-3)):
+                return self.func(x, a, n-1)
+            elif n.is_positive:
+                return n*self.func(x, a, n-1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, variable, offset, exponent):
+        """
+        Returns a simplified form or a value of Singularity Function depending
+        on the argument passed by the object.
+
+        Explanation
+        ===========
+
+        The ``eval()`` method is automatically called when the
+        ``SingularityFunction`` class is about to be instantiated and it
+        returns either some simplified instance or the unevaluated instance
+        depending on the argument passed. In other words, ``eval()`` method is
+        not needed to be called explicitly, it is being called and evaluated
+        once the object is called.
+
+        Examples
+        ========
+
+        >>> from sympy import SingularityFunction, Symbol, nan
+        >>> from sympy.abc import x, a, n
+        >>> SingularityFunction(x, a, n)
+        SingularityFunction(x, a, n)
+        >>> SingularityFunction(5, 3, 2)
+        4
+        >>> SingularityFunction(x, a, nan)
+        nan
+        >>> SingularityFunction(x, 3, 0).subs(x, 3)
+        1
+        >>> SingularityFunction(4, 1, 5)
+        243
+        >>> x = Symbol('x', positive = True)
+        >>> a = Symbol('a', negative = True)
+        >>> n = Symbol('n', nonnegative = True)
+        >>> SingularityFunction(x, a, n)
+        (-a + x)**n
+        >>> x = Symbol('x', negative = True)
+        >>> a = Symbol('a', positive = True)
+        >>> SingularityFunction(x, a, n)
+        0
+
+        """
+
+        x = variable
+        a = offset
+        n = exponent
+        shift = (x - a)
+
+        if fuzzy_not(im(shift).is_zero):
+            raise ValueError("Singularity Functions are defined only for Real Numbers.")
+        if fuzzy_not(im(n).is_zero):
+            raise ValueError("Singularity Functions are not defined for imaginary exponents.")
+        if shift is S.NaN or n is S.NaN:
+            return S.NaN
+        if (n + 4).is_negative:
+            raise ValueError("Singularity Functions are not defined for exponents less than -4.")
+        if shift.is_extended_negative:
+            return S.Zero
+        if n.is_nonnegative:
+            if shift.is_zero:  # use literal 0 in case of Symbol('z', zero=True)
+                return S.Zero**n
+            if shift.is_extended_nonnegative:
+                return shift**n
+        if n in (S.NegativeOne, -2, -3, -4):
+            if shift.is_negative or shift.is_extended_positive:
+                return S.Zero
+            if shift.is_zero:
+                return oo
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        '''
+        Converts a Singularity Function expression into its Piecewise form.
+
+        '''
+        x, a, n = self.args
+
+        if n in (S.NegativeOne, S(-2), S(-3), S(-4)):
+            return Piecewise((oo, Eq(x - a, 0)), (0, True))
+        elif n.is_nonnegative:
+            return Piecewise(((x - a)**n, x - a >= 0), (0, True))
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        '''
+        Rewrites a Singularity Function expression using Heavisides and DiracDeltas.
+
+        '''
+        x, a, n = self.args
+
+        if n == -4:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 4)
+        if n == -3:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 3)
+        if n == -2:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 2)
+        if n == -1:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 1)
+        if n.is_nonnegative:
+            return (x - a)**n*Heaviside(x - a, 1)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        z, a, n = self.args
+        shift = (z - a).subs(x, 0)
+        if n < 0:
+            return S.Zero
+        elif n.is_zero and shift.is_zero:
+            return S.Zero if cdir == -1 else S.One
+        elif shift.is_positive:
+            return shift**n
+        return S.Zero
+
+    def _eval_nseries(self, x, n, logx=None, cdir=0):
+        z, a, n = self.args
+        shift = (z - a).subs(x, 0)
+        if n < 0:
+            return S.Zero
+        elif n.is_zero and shift.is_zero:
+            return S.Zero if cdir == -1 else S.One
+        elif shift.is_positive:
+            return ((z - a)**n)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return S.Zero
+
+    _eval_rewrite_as_DiracDelta = _eval_rewrite_as_Heaviside
+    _eval_rewrite_as_HeavisideDiracDelta = _eval_rewrite_as_Heaviside

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/spherical_harmonics.py

@@ -0,0 +1,334 @@
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.numbers import I, pi
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.functions import assoc_legendre
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import Abs, conjugate
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, cos, cot
+
+_x = Dummy("x")
+
+class Ynm(DefinedFunction):
+    r"""
+    Spherical harmonics defined as
+
+    .. math::
+        Y_n^m(\theta, \varphi) := \sqrt{\frac{(2n+1)(n-m)!}{4\pi(n+m)!}}
+                                  \exp(i m \varphi)
+                                  \mathrm{P}_n^m\left(\cos(\theta)\right)
+
+    Explanation
+    ===========
+
+    ``Ynm()`` gives the spherical harmonic function of order $n$ and $m$
+    in $\theta$ and $\varphi$, $Y_n^m(\theta, \varphi)$. The four
+    parameters are as follows: $n \geq 0$ an integer and $m$ an integer
+    such that $-n \leq m \leq n$ holds. The two angles are real-valued
+    with $\theta \in [0, \pi]$ and $\varphi \in [0, 2\pi]$.
+
+    Examples
+    ========
+
+    >>> from sympy import Ynm, Symbol, simplify
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> Ynm(n, m, theta, phi)
+    Ynm(n, m, theta, phi)
+
+    Several symmetries are known, for the order:
+
+    >>> Ynm(n, -m, theta, phi)
+    (-1)**m*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    As well as for the angles:
+
+    >>> Ynm(n, m, -theta, phi)
+    Ynm(n, m, theta, phi)
+
+    >>> Ynm(n, m, theta, -phi)
+    exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    For specific integers $n$ and $m$ we can evaluate the harmonics
+    to more useful expressions:
+
+    >>> simplify(Ynm(0, 0, theta, phi).expand(func=True))
+    1/(2*sqrt(pi))
+
+    >>> simplify(Ynm(1, -1, theta, phi).expand(func=True))
+    sqrt(6)*exp(-I*phi)*sin(theta)/(4*sqrt(pi))
+
+    >>> simplify(Ynm(1, 0, theta, phi).expand(func=True))
+    sqrt(3)*cos(theta)/(2*sqrt(pi))
+
+    >>> simplify(Ynm(1, 1, theta, phi).expand(func=True))
+    -sqrt(6)*exp(I*phi)*sin(theta)/(4*sqrt(pi))
+
+    >>> simplify(Ynm(2, -2, theta, phi).expand(func=True))
+    sqrt(30)*exp(-2*I*phi)*sin(theta)**2/(8*sqrt(pi))
+
+    >>> simplify(Ynm(2, -1, theta, phi).expand(func=True))
+    sqrt(30)*exp(-I*phi)*sin(2*theta)/(8*sqrt(pi))
+
+    >>> simplify(Ynm(2, 0, theta, phi).expand(func=True))
+    sqrt(5)*(3*cos(theta)**2 - 1)/(4*sqrt(pi))
+
+    >>> simplify(Ynm(2, 1, theta, phi).expand(func=True))
+    -sqrt(30)*exp(I*phi)*sin(2*theta)/(8*sqrt(pi))
+
+    >>> simplify(Ynm(2, 2, theta, phi).expand(func=True))
+    sqrt(30)*exp(2*I*phi)*sin(theta)**2/(8*sqrt(pi))
+
+    We can differentiate the functions with respect
+    to both angles:
+
+    >>> from sympy import Ynm, Symbol, diff
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> diff(Ynm(n, m, theta, phi), theta)
+    m*cot(theta)*Ynm(n, m, theta, phi) + sqrt((-m + n)*(m + n + 1))*exp(-I*phi)*Ynm(n, m + 1, theta, phi)
+
+    >>> diff(Ynm(n, m, theta, phi), phi)
+    I*m*Ynm(n, m, theta, phi)
+
+    Further we can compute the complex conjugation:
+
+    >>> from sympy import Ynm, Symbol, conjugate
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> conjugate(Ynm(n, m, theta, phi))
+    (-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    To get back the well known expressions in spherical
+    coordinates, we use full expansion:
+
+    >>> from sympy import Ynm, Symbol, expand_func
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> expand_func(Ynm(n, m, theta, phi))
+    sqrt((2*n + 1)*factorial(-m + n)/factorial(m + n))*exp(I*m*phi)*assoc_legendre(n, m, cos(theta))/(2*sqrt(pi))
+
+    See Also
+    ========
+
+    Ynm_c, Znm
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Spherical_harmonics
+    .. [2] https://mathworld.wolfram.com/SphericalHarmonic.html
+    .. [3] https://functions.wolfram.com/Polynomials/SphericalHarmonicY/
+    .. [4] https://dlmf.nist.gov/14.30
+
+    """
+
+    @classmethod
+    def eval(cls, n, m, theta, phi):
+        # Handle negative index m and arguments theta, phi
+        if m.could_extract_minus_sign():
+            m = -m
+            return S.NegativeOne**m * exp(-2*I*m*phi) * Ynm(n, m, theta, phi)
+        if theta.could_extract_minus_sign():
+            theta = -theta
+            return Ynm(n, m, theta, phi)
+        if phi.could_extract_minus_sign():
+            phi = -phi
+            return exp(-2*I*m*phi) * Ynm(n, m, theta, phi)
+
+        # TODO Add more simplififcation here
+
+    def _eval_expand_func(self, **hints):
+        n, m, theta, phi = self.args
+        rv = (sqrt((2*n + 1)/(4*pi) * factorial(n - m)/factorial(n + m)) *
+                exp(I*m*phi) * assoc_legendre(n, m, cos(theta)))
+        # We can do this because of the range of theta
+        return rv.subs(sqrt(-cos(theta)**2 + 1), sin(theta))
+
+    def fdiff(self, argindex=4):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt m
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 3:
+            # Diff wrt theta
+            n, m, theta, phi = self.args
+            return (m * cot(theta) * Ynm(n, m, theta, phi) +
+                    sqrt((n - m)*(n + m + 1)) * exp(-I*phi) * Ynm(n, m + 1, theta, phi))
+        elif argindex == 4:
+            # Diff wrt phi
+            n, m, theta, phi = self.args
+            return I * m * Ynm(n, m, theta, phi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_polynomial(self, n, m, theta, phi, **kwargs):
+        # TODO: Make sure n \in N
+        # TODO: Assert |m| <= n ortherwise we should return 0
+        return self.expand(func=True)
+
+    def _eval_rewrite_as_sin(self, n, m, theta, phi, **kwargs):
+        return self.rewrite(cos)
+
+    def _eval_rewrite_as_cos(self, n, m, theta, phi, **kwargs):
+        # This method can be expensive due to extensive use of simplification!
+        from sympy.simplify import simplify, trigsimp
+        # TODO: Make sure n \in N
+        # TODO: Assert |m| <= n ortherwise we should return 0
+        term = simplify(self.expand(func=True))
+        # We can do this because of the range of theta
+        term = term.xreplace({Abs(sin(theta)):sin(theta)})
+        return simplify(trigsimp(term))
+
+    def _eval_conjugate(self):
+        # TODO: Make sure theta \in R and phi \in R
+        n, m, theta, phi = self.args
+        return S.NegativeOne**m * self.func(n, -m, theta, phi)
+
+    def as_real_imag(self, deep=True, **hints):
+        # TODO: Handle deep and hints
+        n, m, theta, phi = self.args
+        re = (sqrt((2*n + 1)/(4*pi) * factorial(n - m)/factorial(n + m)) *
+              cos(m*phi) * assoc_legendre(n, m, cos(theta)))
+        im = (sqrt((2*n + 1)/(4*pi) * factorial(n - m)/factorial(n + m)) *
+              sin(m*phi) * assoc_legendre(n, m, cos(theta)))
+        return (re, im)
+
+    def _eval_evalf(self, prec):
+        # Note: works without this function by just calling
+        #       mpmath for Legendre polynomials. But using
+        #       the dedicated function directly is cleaner.
+        from mpmath import mp, workprec
+        n = self.args[0]._to_mpmath(prec)
+        m = self.args[1]._to_mpmath(prec)
+        theta = self.args[2]._to_mpmath(prec)
+        phi = self.args[3]._to_mpmath(prec)
+        with workprec(prec):
+            res = mp.spherharm(n, m, theta, phi)
+        return Expr._from_mpmath(res, prec)
+
+
+def Ynm_c(n, m, theta, phi):
+    r"""
+    Conjugate spherical harmonics defined as
+
+    .. math::
+        \overline{Y_n^m(\theta, \varphi)} := (-1)^m Y_n^{-m}(\theta, \varphi).
+
+    Examples
+    ========
+
+    >>> from sympy import Ynm_c, Symbol, simplify
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+    >>> Ynm_c(n, m, theta, phi)
+    (-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+    >>> Ynm_c(n, m, -theta, phi)
+    (-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    For specific integers $n$ and $m$ we can evaluate the harmonics
+    to more useful expressions:
+
+    >>> simplify(Ynm_c(0, 0, theta, phi).expand(func=True))
+    1/(2*sqrt(pi))
+    >>> simplify(Ynm_c(1, -1, theta, phi).expand(func=True))
+    sqrt(6)*exp(I*(-phi + 2*conjugate(phi)))*sin(theta)/(4*sqrt(pi))
+
+    See Also
+    ========
+
+    Ynm, Znm
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Spherical_harmonics
+    .. [2] https://mathworld.wolfram.com/SphericalHarmonic.html
+    .. [3] https://functions.wolfram.com/Polynomials/SphericalHarmonicY/
+
+    """
+    return conjugate(Ynm(n, m, theta, phi))
+
+
+class Znm(DefinedFunction):
+    r"""
+    Real spherical harmonics defined as
+
+    .. math::
+
+        Z_n^m(\theta, \varphi) :=
+        \begin{cases}
+          \frac{Y_n^m(\theta, \varphi) + \overline{Y_n^m(\theta, \varphi)}}{\sqrt{2}} &\quad m > 0 \\
+          Y_n^m(\theta, \varphi) &\quad m = 0 \\
+          \frac{Y_n^m(\theta, \varphi) - \overline{Y_n^m(\theta, \varphi)}}{i \sqrt{2}} &\quad m < 0 \\
+        \end{cases}
+
+    which gives in simplified form
+
+    .. math::
+
+        Z_n^m(\theta, \varphi) =
+        \begin{cases}
+          \frac{Y_n^m(\theta, \varphi) + (-1)^m Y_n^{-m}(\theta, \varphi)}{\sqrt{2}} &\quad m > 0 \\
+          Y_n^m(\theta, \varphi) &\quad m = 0 \\
+          \frac{Y_n^m(\theta, \varphi) - (-1)^m Y_n^{-m}(\theta, \varphi)}{i \sqrt{2}} &\quad m < 0 \\
+        \end{cases}
+
+    Examples
+    ========
+
+    >>> from sympy import Znm, Symbol, simplify
+    >>> from sympy.abc import n, m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+    >>> Znm(n, m, theta, phi)
+    Znm(n, m, theta, phi)
+
+    For specific integers n and m we can evaluate the harmonics
+    to more useful expressions:
+
+    >>> simplify(Znm(0, 0, theta, phi).expand(func=True))
+    1/(2*sqrt(pi))
+    >>> simplify(Znm(1, 1, theta, phi).expand(func=True))
+    -sqrt(3)*sin(theta)*cos(phi)/(2*sqrt(pi))
+    >>> simplify(Znm(2, 1, theta, phi).expand(func=True))
+    -sqrt(15)*sin(2*theta)*cos(phi)/(4*sqrt(pi))
+
+    See Also
+    ========
+
+    Ynm, Ynm_c
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Spherical_harmonics
+    .. [2] https://mathworld.wolfram.com/SphericalHarmonic.html
+    .. [3] https://functions.wolfram.com/Polynomials/SphericalHarmonicY/
+
+    """
+
+    @classmethod
+    def eval(cls, n, m, theta, phi):
+        if m.is_positive:
+            zz = (Ynm(n, m, theta, phi) + Ynm_c(n, m, theta, phi)) / sqrt(2)
+            return zz
+        elif m.is_zero:
+            return Ynm(n, m, theta, phi)
+        elif m.is_negative:
+            zz = (Ynm(n, m, theta, phi) - Ynm_c(n, m, theta, phi)) / (sqrt(2)*I)
+            return zz

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/tensor_functions.py

@@ -0,0 +1,474 @@
+from math import prod
+
+from sympy.core import S, Integer
+from sympy.core.function import DefinedFunction
+from sympy.core.logic import fuzzy_not
+from sympy.core.relational import Ne
+from sympy.core.sorting import default_sort_key
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.utilities.iterables import has_dups
+
+###############################################################################
+###################### Kronecker Delta, Levi-Civita etc. ######################
+###############################################################################
+
+
+def Eijk(*args, **kwargs):
+    """
+    Represent the Levi-Civita symbol.
+
+    This is a compatibility wrapper to ``LeviCivita()``.
+
+    See Also
+    ========
+
+    LeviCivita
+
+    """
+    return LeviCivita(*args, **kwargs)
+
+
+def eval_levicivita(*args):
+    """Evaluate Levi-Civita symbol."""
+    n = len(args)
+    return prod(
+        prod(args[j] - args[i] for j in range(i + 1, n))
+        / factorial(i) for i in range(n))
+    # converting factorial(i) to int is slightly faster
+
+
+class LeviCivita(DefinedFunction):
+    """
+    Represent the Levi-Civita symbol.
+
+    Explanation
+    ===========
+
+    For even permutations of indices it returns 1, for odd permutations -1, and
+    for everything else (a repeated index) it returns 0.
+
+    Thus it represents an alternating pseudotensor.
+
+    Examples
+    ========
+
+    >>> from sympy import LeviCivita
+    >>> from sympy.abc import i, j, k
+    >>> LeviCivita(1, 2, 3)
+    1
+    >>> LeviCivita(1, 3, 2)
+    -1
+    >>> LeviCivita(1, 2, 2)
+    0
+    >>> LeviCivita(i, j, k)
+    LeviCivita(i, j, k)
+    >>> LeviCivita(i, j, i)
+    0
+
+    See Also
+    ========
+
+    Eijk
+
+    """
+
+    is_integer = True
+
+    @classmethod
+    def eval(cls, *args):
+        if all(isinstance(a, (SYMPY_INTS, Integer)) for a in args):
+            return eval_levicivita(*args)
+        if has_dups(args):
+            return S.Zero
+
+    def doit(self, **hints):
+        return eval_levicivita(*self.args)
+
+
+class KroneckerDelta(DefinedFunction):
+    """
+    The discrete, or Kronecker, delta function.
+
+    Explanation
+    ===========
+
+    A function that takes in two integers $i$ and $j$. It returns $0$ if $i$
+    and $j$ are not equal, or it returns $1$ if $i$ and $j$ are equal.
+
+    Examples
+    ========
+
+    An example with integer indices:
+
+        >>> from sympy import KroneckerDelta
+        >>> KroneckerDelta(1, 2)
+        0
+        >>> KroneckerDelta(3, 3)
+        1
+
+    Symbolic indices:
+
+        >>> from sympy.abc import i, j, k
+        >>> KroneckerDelta(i, j)
+        KroneckerDelta(i, j)
+        >>> KroneckerDelta(i, i)
+        1
+        >>> KroneckerDelta(i, i + 1)
+        0
+        >>> KroneckerDelta(i, i + 1 + k)
+        KroneckerDelta(i, i + k + 1)
+
+    Parameters
+    ==========
+
+    i : Number, Symbol
+        The first index of the delta function.
+    j : Number, Symbol
+        The second index of the delta function.
+
+    See Also
+    ========
+
+    eval
+    DiracDelta
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Kronecker_delta
+
+    """
+
+    is_integer = True
+
+    @classmethod
+    def eval(cls, i, j, delta_range=None):
+        """
+        Evaluates the discrete delta function.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta
+        >>> from sympy.abc import i, j, k
+
+        >>> KroneckerDelta(i, j)
+        KroneckerDelta(i, j)
+        >>> KroneckerDelta(i, i)
+        1
+        >>> KroneckerDelta(i, i + 1)
+        0
+        >>> KroneckerDelta(i, i + 1 + k)
+        KroneckerDelta(i, i + k + 1)
+
+        # indirect doctest
+
+        """
+
+        if delta_range is not None:
+            dinf, dsup = delta_range
+            if (dinf - i > 0) == True:
+                return S.Zero
+            if (dinf - j > 0) == True:
+                return S.Zero
+            if (dsup - i < 0) == True:
+                return S.Zero
+            if (dsup - j < 0) == True:
+                return S.Zero
+
+        diff = i - j
+        if diff.is_zero:
+            return S.One
+        elif fuzzy_not(diff.is_zero):
+            return S.Zero
+
+        if i.assumptions0.get("below_fermi") and \
+                j.assumptions0.get("above_fermi"):
+            return S.Zero
+        if j.assumptions0.get("below_fermi") and \
+                i.assumptions0.get("above_fermi"):
+            return S.Zero
+        # to make KroneckerDelta canonical
+        # following lines will check if inputs are in order
+        # if not, will return KroneckerDelta with correct order
+        if default_sort_key(j) < default_sort_key(i):
+            if delta_range:
+                return cls(j, i, delta_range)
+            else:
+                return cls(j, i)
+
+    @property
+    def delta_range(self):
+        if len(self.args) > 2:
+            return self.args[2]
+
+    def _eval_power(self, expt):
+        if expt.is_positive:
+            return self
+        if expt.is_negative and expt is not S.NegativeOne:
+            return 1/self
+
+    @property
+    def is_above_fermi(self):
+        """
+        True if Delta can be non-zero above fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, a).is_above_fermi
+        True
+        >>> KroneckerDelta(p, i).is_above_fermi
+        False
+        >>> KroneckerDelta(p, q).is_above_fermi
+        True
+
+        See Also
+        ========
+
+        is_below_fermi, is_only_below_fermi, is_only_above_fermi
+
+        """
+        if self.args[0].assumptions0.get("below_fermi"):
+            return False
+        if self.args[1].assumptions0.get("below_fermi"):
+            return False
+        return True
+
+    @property
+    def is_below_fermi(self):
+        """
+        True if Delta can be non-zero below fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, a).is_below_fermi
+        False
+        >>> KroneckerDelta(p, i).is_below_fermi
+        True
+        >>> KroneckerDelta(p, q).is_below_fermi
+        True
+
+        See Also
+        ========
+
+        is_above_fermi, is_only_above_fermi, is_only_below_fermi
+
+        """
+        if self.args[0].assumptions0.get("above_fermi"):
+            return False
+        if self.args[1].assumptions0.get("above_fermi"):
+            return False
+        return True
+
+    @property
+    def is_only_above_fermi(self):
+        """
+        True if Delta is restricted to above fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, a).is_only_above_fermi
+        True
+        >>> KroneckerDelta(p, q).is_only_above_fermi
+        False
+        >>> KroneckerDelta(p, i).is_only_above_fermi
+        False
+
+        See Also
+        ========
+
+        is_above_fermi, is_below_fermi, is_only_below_fermi
+
+        """
+        return ( self.args[0].assumptions0.get("above_fermi")
+                or
+                self.args[1].assumptions0.get("above_fermi")
+                ) or False
+
+    @property
+    def is_only_below_fermi(self):
+        """
+        True if Delta is restricted to below fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, i).is_only_below_fermi
+        True
+        >>> KroneckerDelta(p, q).is_only_below_fermi
+        False
+        >>> KroneckerDelta(p, a).is_only_below_fermi
+        False
+
+        See Also
+        ========
+
+        is_above_fermi, is_below_fermi, is_only_above_fermi
+
+        """
+        return ( self.args[0].assumptions0.get("below_fermi")
+                or
+                self.args[1].assumptions0.get("below_fermi")
+                ) or False
+
+    @property
+    def indices_contain_equal_information(self):
+        """
+        Returns True if indices are either both above or below fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, q).indices_contain_equal_information
+        True
+        >>> KroneckerDelta(p, q+1).indices_contain_equal_information
+        True
+        >>> KroneckerDelta(i, p).indices_contain_equal_information
+        False
+
+        """
+        if (self.args[0].assumptions0.get("below_fermi") and
+                self.args[1].assumptions0.get("below_fermi")):
+            return True
+        if (self.args[0].assumptions0.get("above_fermi")
+                and self.args[1].assumptions0.get("above_fermi")):
+            return True
+
+        # if both indices are general we are True, else false
+        return self.is_below_fermi and self.is_above_fermi
+
+    @property
+    def preferred_index(self):
+        """
+        Returns the index which is preferred to keep in the final expression.
+
+        Explanation
+        ===========
+
+        The preferred index is the index with more information regarding fermi
+        level. If indices contain the same information, 'a' is preferred before
+        'b'.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> j = Symbol('j', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> KroneckerDelta(p, i).preferred_index
+        i
+        >>> KroneckerDelta(p, a).preferred_index
+        a
+        >>> KroneckerDelta(i, j).preferred_index
+        i
+
+        See Also
+        ========
+
+        killable_index
+
+        """
+        if self._get_preferred_index():
+            return self.args[1]
+        else:
+            return self.args[0]
+
+    @property
+    def killable_index(self):
+        """
+        Returns the index which is preferred to substitute in the final
+        expression.
+
+        Explanation
+        ===========
+
+        The index to substitute is the index with less information regarding
+        fermi level. If indices contain the same information, 'a' is preferred
+        before 'b'.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> j = Symbol('j', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> KroneckerDelta(p, i).killable_index
+        p
+        >>> KroneckerDelta(p, a).killable_index
+        p
+        >>> KroneckerDelta(i, j).killable_index
+        j
+
+        See Also
+        ========
+
+        preferred_index
+
+        """
+        if self._get_preferred_index():
+            return self.args[0]
+        else:
+            return self.args[1]
+
+    def _get_preferred_index(self):
+        """
+        Returns the index which is preferred to keep in the final expression.
+
+        The preferred index is the index with more information regarding fermi
+        level. If indices contain the same information, index 0 is returned.
+
+        """
+        if not self.is_above_fermi:
+            if self.args[0].assumptions0.get("below_fermi"):
+                return 0
+            else:
+                return 1
+        elif not self.is_below_fermi:
+            if self.args[0].assumptions0.get("above_fermi"):
+                return 0
+            else:
+                return 1
+        else:
+            return 0
+
+    @property
+    def indices(self):
+        return self.args[0:2]
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        i, j = args
+        return Piecewise((0, Ne(i, j)), (1, True))

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/functions/special/zeta_functions.py

@@ -0,0 +1,786 @@
+""" Riemann zeta and related function. """
+
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.function import ArgumentIndexError, expand_mul, DefinedFunction
+from sympy.core.logic import fuzzy_not
+from sympy.core.numbers import pi, I, Integer
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.numbers import bernoulli, factorial, genocchi, harmonic
+from sympy.functions.elementary.complexes import re, unpolarify, Abs, polar_lift
+from sympy.functions.elementary.exponential import log, exp_polar, exp
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.polys.polytools import Poly
+
+###############################################################################
+###################### LERCH TRANSCENDENT #####################################
+###############################################################################
+
+
+class lerchphi(DefinedFunction):
+    r"""
+    Lerch transcendent (Lerch phi function).
+
+    Explanation
+    ===========
+
+    For $\operatorname{Re}(a) > 0$, $|z| < 1$ and $s \in \mathbb{C}$, the
+    Lerch transcendent is defined as
+
+    .. math :: \Phi(z, s, a) = \sum_{n=0}^\infty \frac{z^n}{(n + a)^s},
+
+    where the standard branch of the argument is used for $n + a$,
+    and by analytic continuation for other values of the parameters.
+
+    A commonly used related function is the Lerch zeta function, defined by
+
+    .. math:: L(q, s, a) = \Phi(e^{2\pi i q}, s, a).
+
+    **Analytic Continuation and Branching Behavior**
+
+    It can be shown that
+
+    .. math:: \Phi(z, s, a) = z\Phi(z, s, a+1) + a^{-s}.
+
+    This provides the analytic continuation to $\operatorname{Re}(a) \le 0$.
+
+    Assume now $\operatorname{Re}(a) > 0$. The integral representation
+
+    .. math:: \Phi_0(z, s, a) = \int_0^\infty \frac{t^{s-1} e^{-at}}{1 - ze^{-t}}
+                                \frac{\mathrm{d}t}{\Gamma(s)}
+
+    provides an analytic continuation to $\mathbb{C} - [1, \infty)$.
+    Finally, for $x \in (1, \infty)$ we find
+
+    .. math:: \lim_{\epsilon \to 0^+} \Phi_0(x + i\epsilon, s, a)
+             -\lim_{\epsilon \to 0^+} \Phi_0(x - i\epsilon, s, a)
+             = \frac{2\pi i \log^{s-1}{x}}{x^a \Gamma(s)},
+
+    using the standard branch for both $\log{x}$ and
+    $\log{\log{x}}$ (a branch of $\log{\log{x}}$ is needed to
+    evaluate $\log{x}^{s-1}$).
+    This concludes the analytic continuation. The Lerch transcendent is thus
+    branched at $z \in \{0, 1, \infty\}$ and
+    $a \in \mathbb{Z}_{\le 0}$. For fixed $z, a$ outside these
+    branch points, it is an entire function of $s$.
+
+    Examples
+    ========
+
+    The Lerch transcendent is a fairly general function, for this reason it does
+    not automatically evaluate to simpler functions. Use ``expand_func()`` to
+    achieve this.
+
+    If $z=1$, the Lerch transcendent reduces to the Hurwitz zeta function:
+
+    >>> from sympy import lerchphi, expand_func
+    >>> from sympy.abc import z, s, a
+    >>> expand_func(lerchphi(1, s, a))
+    zeta(s, a)
+
+    More generally, if $z$ is a root of unity, the Lerch transcendent
+    reduces to a sum of Hurwitz zeta functions:
+
+    >>> expand_func(lerchphi(-1, s, a))
+    zeta(s, a/2)/2**s - zeta(s, a/2 + 1/2)/2**s
+
+    If $a=1$, the Lerch transcendent reduces to the polylogarithm:
+
+    >>> expand_func(lerchphi(z, s, 1))
+    polylog(s, z)/z
+
+    More generally, if $a$ is rational, the Lerch transcendent reduces
+    to a sum of polylogarithms:
+
+    >>> from sympy import S
+    >>> expand_func(lerchphi(z, s, S(1)/2))
+    2**(s - 1)*(polylog(s, sqrt(z))/sqrt(z) -
+                polylog(s, sqrt(z)*exp_polar(I*pi))/sqrt(z))
+    >>> expand_func(lerchphi(z, s, S(3)/2))
+    -2**s/z + 2**(s - 1)*(polylog(s, sqrt(z))/sqrt(z) -
+                          polylog(s, sqrt(z)*exp_polar(I*pi))/sqrt(z))/z
+
+    The derivatives with respect to $z$ and $a$ can be computed in
+    closed form:
+
+    >>> lerchphi(z, s, a).diff(z)
+    (-a*lerchphi(z, s, a) + lerchphi(z, s - 1, a))/z
+    >>> lerchphi(z, s, a).diff(a)
+    -s*lerchphi(z, s + 1, a)
+
+    See Also
+    ========
+
+    polylog, zeta
+
+    References
+    ==========
+
+    .. [1] Bateman, H.; Erdelyi, A. (1953), Higher Transcendental Functions,
+           Vol. I, New York: McGraw-Hill. Section 1.11.
+    .. [2] https://dlmf.nist.gov/25.14
+    .. [3] https://en.wikipedia.org/wiki/Lerch_transcendent
+
+    """
+
+    def _eval_expand_func(self, **hints):
+        z, s, a = self.args
+        if z == 1:
+            return zeta(s, a)
+        if s.is_Integer and s <= 0:
+            t = Dummy('t')
+            p = Poly((t + a)**(-s), t)
+            start = 1/(1 - t)
+            res = S.Zero
+            for c in reversed(p.all_coeffs()):
+                res += c*start
+                start = t*start.diff(t)
+            return res.subs(t, z)
+
+        if a.is_Rational:
+            # See section 18 of
+            #   Kelly B. Roach.  Hypergeometric Function Representations.
+            #   In: Proceedings of the 1997 International Symposium on Symbolic and
+            #   Algebraic Computation, pages 205-211, New York, 1997. ACM.
+            # TODO should something be polarified here?
+            add = S.Zero
+            mul = S.One
+            # First reduce a to the interaval (0, 1]
+            if a > 1:
+                n = floor(a)
+                if n == a:
+                    n -= 1
+                a -= n
+                mul = z**(-n)
+                add = Add(*[-z**(k - n)/(a + k)**s for k in range(n)])
+            elif a <= 0:
+                n = floor(-a) + 1
+                a += n
+                mul = z**n
+                add = Add(*[z**(n - 1 - k)/(a - k - 1)**s for k in range(n)])
+
+            m, n = S([a.p, a.q])
+            zet = exp_polar(2*pi*I/n)
+            root = z**(1/n)
+            up_zet = unpolarify(zet)
+            addargs = []
+            for k in range(n):
+                p = polylog(s, zet**k*root)
+                if isinstance(p, polylog):
+                    p = p._eval_expand_func(**hints)
+                addargs.append(p/(up_zet**k*root)**m)
+            return add + mul*n**(s - 1)*Add(*addargs)
+
+        # TODO use minpoly instead of ad-hoc methods when issue 5888 is fixed
+        if isinstance(z, exp) and (z.args[0]/(pi*I)).is_Rational or z in [-1, I, -I]:
+            # TODO reference?
+            if z == -1:
+                p, q = S([1, 2])
+            elif z == I:
+                p, q = S([1, 4])
+            elif z == -I:
+                p, q = S([-1, 4])
+            else:
+                arg = z.args[0]/(2*pi*I)
+                p, q = S([arg.p, arg.q])
+            return Add(*[exp(2*pi*I*k*p/q)/q**s*zeta(s, (k + a)/q)
+                         for k in range(q)])
+
+        return lerchphi(z, s, a)
+
+    def fdiff(self, argindex=1):
+        z, s, a = self.args
+        if argindex == 3:
+            return -s*lerchphi(z, s + 1, a)
+        elif argindex == 1:
+            return (lerchphi(z, s - 1, a) - a*lerchphi(z, s, a))/z
+        else:
+            raise ArgumentIndexError
+
+    def _eval_rewrite_helper(self, target):
+        res = self._eval_expand_func()
+        if res.has(target):
+            return res
+        else:
+            return self
+
+    def _eval_rewrite_as_zeta(self, z, s, a, **kwargs):
+        return self._eval_rewrite_helper(zeta)
+
+    def _eval_rewrite_as_polylog(self, z, s, a, **kwargs):
+        return self._eval_rewrite_helper(polylog)
+
+###############################################################################
+###################### POLYLOGARITHM ##########################################
+###############################################################################
+
+
+class polylog(DefinedFunction):
+    r"""
+    Polylogarithm function.
+
+    Explanation
+    ===========
+
+    For $|z| < 1$ and $s \in \mathbb{C}$, the polylogarithm is
+    defined by
+
+    .. math:: \operatorname{Li}_s(z) = \sum_{n=1}^\infty \frac{z^n}{n^s},
+
+    where the standard branch of the argument is used for $n$. It admits
+    an analytic continuation which is branched at $z=1$ (notably not on the
+    sheet of initial definition), $z=0$ and $z=\infty$.
+
+    The name polylogarithm comes from the fact that for $s=1$, the
+    polylogarithm is related to the ordinary logarithm (see examples), and that
+
+    .. math:: \operatorname{Li}_{s+1}(z) =
+                    \int_0^z \frac{\operatorname{Li}_s(t)}{t} \mathrm{d}t.
+
+    The polylogarithm is a special case of the Lerch transcendent:
+
+    .. math:: \operatorname{Li}_{s}(z) = z \Phi(z, s, 1).
+
+    Examples
+    ========
+
+    For $z \in \{0, 1, -1\}$, the polylogarithm is automatically expressed
+    using other functions:
+
+    >>> from sympy import polylog
+    >>> from sympy.abc import s
+    >>> polylog(s, 0)
+    0
+    >>> polylog(s, 1)
+    zeta(s)
+    >>> polylog(s, -1)
+    -dirichlet_eta(s)
+
+    If $s$ is a negative integer, $0$ or $1$, the polylogarithm can be
+    expressed using elementary functions. This can be done using
+    ``expand_func()``:
+
+    >>> from sympy import expand_func
+    >>> from sympy.abc import z
+    >>> expand_func(polylog(1, z))
+    -log(1 - z)
+    >>> expand_func(polylog(0, z))
+    z/(1 - z)
+
+    The derivative with respect to $z$ can be computed in closed form:
+
+    >>> polylog(s, z).diff(z)
+    polylog(s - 1, z)/z
+
+    The polylogarithm can be expressed in terms of the lerch transcendent:
+
+    >>> from sympy import lerchphi
+    >>> polylog(s, z).rewrite(lerchphi)
+    z*lerchphi(z, s, 1)
+
+    See Also
+    ========
+
+    zeta, lerchphi
+
+    """
+
+    @classmethod
+    def eval(cls, s, z):
+        if z.is_number:
+            if z is S.One:
+                return zeta(s)
+            elif z is S.NegativeOne:
+                return -dirichlet_eta(s)
+            elif z is S.Zero:
+                return S.Zero
+            elif s == 2:
+                dilogtable = _dilogtable()
+                if z in dilogtable:
+                    return dilogtable[z]
+
+        if z.is_zero:
+            return S.Zero
+
+        # Make an effort to determine if z is 1 to avoid replacing into
+        # expression with singularity
+        zone = z.equals(S.One)
+
+        if zone:
+            return zeta(s)
+        elif zone is False:
+            # For s = 0 or -1 use explicit formulas to evaluate, but
+            # automatically expanding polylog(1, z) to -log(1-z) seems
+            # undesirable for summation methods based on hypergeometric
+            # functions
+            if s is S.Zero:
+                return z/(1 - z)
+            elif s is S.NegativeOne:
+                return z/(1 - z)**2
+            if s.is_zero:
+                return z/(1 - z)
+
+        # polylog is branched, but not over the unit disk
+        if z.has(exp_polar, polar_lift) and (zone or (Abs(z) <= S.One) == True):
+            return cls(s, unpolarify(z))
+
+    def fdiff(self, argindex=1):
+        s, z = self.args
+        if argindex == 2:
+            return polylog(s - 1, z)/z
+        raise ArgumentIndexError
+
+    def _eval_rewrite_as_lerchphi(self, s, z, **kwargs):
+        return z*lerchphi(z, s, 1)
+
+    def _eval_expand_func(self, **hints):
+        s, z = self.args
+        if s == 1:
+            return -log(1 - z)
+        if s.is_Integer and s <= 0:
+            u = Dummy('u')
+            start = u/(1 - u)
+            for _ in range(-s):
+                start = u*start.diff(u)
+            return expand_mul(start).subs(u, z)
+        return polylog(s, z)
+
+    def _eval_is_zero(self):
+        z = self.args[1]
+        if z.is_zero:
+            return True
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        z0 = z.subs(x, 0)
+        if z0 is S.NaN:
+            z0 = z.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+
+        if z0.is_zero:
+            # In case of powers less than 1, number of terms need to be computed
+            # separately to avoid repeated callings of _eval_nseries with wrong n
+            try:
+                _, exp = z.leadterm(x)
+            except (ValueError, NotImplementedError):
+                return self
+
+            if exp.is_positive:
+                newn = ceiling(n/exp)
+                o = Order(x**n, x)
+                r = z._eval_nseries(x, n, logx, cdir).removeO()
+                if r is S.Zero:
+                    return o
+
+                term = r
+                s = [term]
+                for k in range(2, newn):
+                    term *= r
+                    s.append(term/k**nu)
+                return Add(*s) + o
+
+        return super(polylog, self)._eval_nseries(x, n, logx, cdir)
+
+###############################################################################
+###################### HURWITZ GENERALIZED ZETA FUNCTION ######################
+###############################################################################
+
+
+class zeta(DefinedFunction):
+    r"""
+    Hurwitz zeta function (or Riemann zeta function).
+
+    Explanation
+    ===========
+
+    For $\operatorname{Re}(a) > 0$ and $\operatorname{Re}(s) > 1$, this
+    function is defined as
+
+    .. math:: \zeta(s, a) = \sum_{n=0}^\infty \frac{1}{(n + a)^s},
+
+    where the standard choice of argument for $n + a$ is used. For fixed
+    $a$ not a nonpositive integer the Hurwitz zeta function admits a
+    meromorphic continuation to all of $\mathbb{C}$; it is an unbranched
+    function with a simple pole at $s = 1$.
+
+    The Hurwitz zeta function is a special case of the Lerch transcendent:
+
+    .. math:: \zeta(s, a) = \Phi(1, s, a).
+
+    This formula defines an analytic continuation for all possible values of
+    $s$ and $a$ (also $\operatorname{Re}(a) < 0$), see the documentation of
+    :class:`lerchphi` for a description of the branching behavior.
+
+    If no value is passed for $a$ a default value of $a = 1$ is assumed,
+    yielding the Riemann zeta function.
+
+    Examples
+    ========
+
+    For $a = 1$ the Hurwitz zeta function reduces to the famous Riemann
+    zeta function:
+
+    .. math:: \zeta(s, 1) = \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s}.
+
+    >>> from sympy import zeta
+    >>> from sympy.abc import s
+    >>> zeta(s, 1)
+    zeta(s)
+    >>> zeta(s)
+    zeta(s)
+
+    The Riemann zeta function can also be expressed using the Dirichlet eta
+    function:
+
+    >>> from sympy import dirichlet_eta
+    >>> zeta(s).rewrite(dirichlet_eta)
+    dirichlet_eta(s)/(1 - 2**(1 - s))
+
+    The Riemann zeta function at nonnegative even and negative integer
+    values is related to the Bernoulli numbers and polynomials:
+
+    >>> zeta(2)
+    pi**2/6
+    >>> zeta(4)
+    pi**4/90
+    >>> zeta(0)
+    -1/2
+    >>> zeta(-1)
+    -1/12
+    >>> zeta(-4)
+    0
+
+    The specific formulae are:
+
+    .. math:: \zeta(2n) = -\frac{(2\pi i)^{2n} B_{2n}}{2(2n)!}
+    .. math:: \zeta(-n,a) = -\frac{B_{n+1}(a)}{n+1}
+
+    No closed-form expressions are known at positive odd integers, but
+    numerical evaluation is possible:
+
+    >>> zeta(3).n()
+    1.20205690315959
+
+    The derivative of $\zeta(s, a)$ with respect to $a$ can be computed:
+
+    >>> from sympy.abc import a
+    >>> zeta(s, a).diff(a)
+    -s*zeta(s + 1, a)
+
+    However the derivative with respect to $s$ has no useful closed form
+    expression:
+
+    >>> zeta(s, a).diff(s)
+    Derivative(zeta(s, a), s)
+
+    The Hurwitz zeta function can be expressed in terms of the Lerch
+    transcendent, :class:`~.lerchphi`:
+
+    >>> from sympy import lerchphi
+    >>> zeta(s, a).rewrite(lerchphi)
+    lerchphi(1, s, a)
+
+    See Also
+    ========
+
+    dirichlet_eta, lerchphi, polylog
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/25.11
+    .. [2] https://en.wikipedia.org/wiki/Hurwitz_zeta_function
+
+    """
+
+    @classmethod
+    def eval(cls, s, a=None):
+        if a is S.One:
+            return cls(s)
+        elif s is S.NaN or a is S.NaN:
+            return S.NaN
+        elif s is S.One:
+            return S.ComplexInfinity
+        elif s is S.Infinity:
+            return S.One
+        elif a is S.Infinity:
+            return S.Zero
+
+        sint = s.is_Integer
+        if a is None:
+            a = S.One
+        if sint and s.is_nonpositive:
+            return bernoulli(1-s, a) / (s-1)
+        elif a is S.One:
+            if sint and s.is_even:
+                return -(2*pi*I)**s * bernoulli(s) / (2*factorial(s))
+        elif sint and a.is_Integer and a.is_positive:
+            return cls(s) - harmonic(a-1, s)
+        elif a.is_Integer and a.is_nonpositive and \
+                (s.is_integer is False or s.is_nonpositive is False):
+            return S.NaN
+
+    def _eval_rewrite_as_bernoulli(self, s, a=1, **kwargs):
+        if a == 1 and s.is_integer and s.is_nonnegative and s.is_even:
+            return -(2*pi*I)**s * bernoulli(s) / (2*factorial(s))
+        return bernoulli(1-s, a) / (s-1)
+
+    def _eval_rewrite_as_dirichlet_eta(self, s, a=1, **kwargs):
+        if a != 1:
+            return self
+        s = self.args[0]
+        return dirichlet_eta(s)/(1 - 2**(1 - s))
+
+    def _eval_rewrite_as_lerchphi(self, s, a=1, **kwargs):
+        return lerchphi(1, s, a)
+
+    def _eval_is_finite(self):
+        return fuzzy_not((self.args[0] - 1).is_zero)
+
+    def _eval_expand_func(self, **hints):
+        s = self.args[0]
+        a = self.args[1] if len(self.args) > 1 else S.One
+        if a.is_integer:
+            if a.is_positive:
+                return zeta(s) - harmonic(a-1, s)
+            if a.is_nonpositive and (s.is_integer is False or
+                    s.is_nonpositive is False):
+                return S.NaN
+        return self
+
+    def fdiff(self, argindex=1):
+        if len(self.args) == 2:
+            s, a = self.args
+        else:
+            s, a = self.args + (1,)
+        if argindex == 2:
+            return -s*zeta(s + 1, a)
+        else:
+            raise ArgumentIndexError
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        if len(self.args) == 2:
+            s, a = self.args
+        else:
+            s, a = self.args + (S.One,)
+
+        try:
+            c, e = a.leadterm(x)
+        except NotImplementedError:
+            return self
+
+        if e.is_negative and not s.is_positive:
+            raise NotImplementedError
+
+        return super(zeta, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+
+class dirichlet_eta(DefinedFunction):
+    r"""
+    Dirichlet eta function.
+
+    Explanation
+    ===========
+
+    For $\operatorname{Re}(s) > 0$ and $0 < x \le 1$, this function is defined as
+
+    .. math:: \eta(s, a) = \sum_{n=0}^\infty \frac{(-1)^n}{(n+a)^s}.
+
+    It admits a unique analytic continuation to all of $\mathbb{C}$ for any
+    fixed $a$ not a nonpositive integer. It is an entire, unbranched function.
+
+    It can be expressed using the Hurwitz zeta function as
+
+    .. math:: \eta(s, a) = \zeta(s,a) - 2^{1-s} \zeta\left(s, \frac{a+1}{2}\right)
+
+    and using the generalized Genocchi function as
+
+    .. math:: \eta(s, a) = \frac{G(1-s, a)}{2(s-1)}.
+
+    In both cases the limiting value of $\log2 - \psi(a) + \psi\left(\frac{a+1}{2}\right)$
+    is used when $s = 1$.
+
+    Examples
+    ========
+
+    >>> from sympy import dirichlet_eta, zeta
+    >>> from sympy.abc import s
+    >>> dirichlet_eta(s).rewrite(zeta)
+    Piecewise((log(2), Eq(s, 1)), ((1 - 2**(1 - s))*zeta(s), True))
+
+    See Also
+    ========
+
+    zeta
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Dirichlet_eta_function
+    .. [2] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+
+    """
+
+    @classmethod
+    def eval(cls, s, a=None):
+        if a is S.One:
+            return cls(s)
+        if a is None:
+            if s == 1:
+                return log(2)
+            z = zeta(s)
+            if not z.has(zeta):
+                return (1 - 2**(1-s)) * z
+            return
+        elif s == 1:
+            from sympy.functions.special.gamma_functions import digamma
+            return log(2) - digamma(a) + digamma((a+1)/2)
+        z1 = zeta(s, a)
+        z2 = zeta(s, (a+1)/2)
+        if not z1.has(zeta) and not z2.has(zeta):
+            return z1 - 2**(1-s) * z2
+
+    def _eval_rewrite_as_zeta(self, s, a=1, **kwargs):
+        from sympy.functions.special.gamma_functions import digamma
+        if a == 1:
+            return Piecewise((log(2), Eq(s, 1)), ((1 - 2**(1-s)) * zeta(s), True))
+        return Piecewise((log(2) - digamma(a) + digamma((a+1)/2), Eq(s, 1)),
+                (zeta(s, a) - 2**(1-s) * zeta(s, (a+1)/2), True))
+
+    def _eval_rewrite_as_genocchi(self, s, a=S.One, **kwargs):
+        from sympy.functions.special.gamma_functions import digamma
+        return Piecewise((log(2) - digamma(a) + digamma((a+1)/2), Eq(s, 1)),
+                (genocchi(1-s, a) / (2 * (s-1)), True))
+
+    def _eval_evalf(self, prec):
+        if all(i.is_number for i in self.args):
+            return self.rewrite(zeta)._eval_evalf(prec)
+
+
+class riemann_xi(DefinedFunction):
+    r"""
+    Riemann Xi function.
+
+    Examples
+    ========
+
+    The Riemann Xi function is closely related to the Riemann zeta function.
+    The zeros of Riemann Xi function are precisely the non-trivial zeros
+    of the zeta function.
+
+    >>> from sympy import riemann_xi, zeta
+    >>> from sympy.abc import s
+    >>> riemann_xi(s).rewrite(zeta)
+    s*(s - 1)*gamma(s/2)*zeta(s)/(2*pi**(s/2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Riemann_Xi_function
+
+    """
+
+
+    @classmethod
+    def eval(cls, s):
+        from sympy.functions.special.gamma_functions import gamma
+        z = zeta(s)
+        if s in (S.Zero, S.One):
+            return S.Half
+
+        if not isinstance(z, zeta):
+            return s*(s - 1)*gamma(s/2)*z/(2*pi**(s/2))
+
+    def _eval_rewrite_as_zeta(self, s, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return s*(s - 1)*gamma(s/2)*zeta(s)/(2*pi**(s/2))
+
+
+class stieltjes(DefinedFunction):
+    r"""
+    Represents Stieltjes constants, $\gamma_{k}$ that occur in
+    Laurent Series expansion of the Riemann zeta function.
+
+    Examples
+    ========
+
+    >>> from sympy import stieltjes
+    >>> from sympy.abc import n, m
+    >>> stieltjes(n)
+    stieltjes(n)
+
+    The zero'th stieltjes constant:
+
+    >>> stieltjes(0)
+    EulerGamma
+    >>> stieltjes(0, 1)
+    EulerGamma
+
+    For generalized stieltjes constants:
+
+    >>> stieltjes(n, m)
+    stieltjes(n, m)
+
+    Constants are only defined for integers >= 0:
+
+    >>> stieltjes(-1)
+    zoo
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Stieltjes_constants
+
+    """
+
+    @classmethod
+    def eval(cls, n, a=None):
+        if a is not None:
+            a = sympify(a)
+            if a is S.NaN:
+                return S.NaN
+            if a.is_Integer and a.is_nonpositive:
+                return S.ComplexInfinity
+
+        if n.is_Number:
+            if n is S.NaN:
+                return S.NaN
+            elif n < 0:
+                return S.ComplexInfinity
+            elif not n.is_Integer:
+                return S.ComplexInfinity
+            elif n is S.Zero and a in [None, 1]:
+                return S.EulerGamma
+
+        if n.is_extended_negative:
+            return S.ComplexInfinity
+
+        if n.is_zero and a in [None, 1]:
+            return S.EulerGamma
+
+        if n.is_integer == False:
+            return S.ComplexInfinity
+
+
+@cacheit
+def _dilogtable():
+    return {
+        S.Half: pi**2/12 - log(2)**2/2,
+        Integer(2) : pi**2/4 - I*pi*log(2),
+        -(sqrt(5) - 1)/2 : -pi**2/15 + log((sqrt(5)-1)/2)**2/2,
+        -(sqrt(5) + 1)/2 : -pi**2/10 - log((sqrt(5)+1)/2)**2,
+        (3 - sqrt(5))/2 : pi**2/15 - log((sqrt(5)-1)/2)**2,
+        (sqrt(5) - 1)/2 : pi**2/10 - log((sqrt(5)-1)/2)**2,
+        I : I*S.Catalan - pi**2/48,
+        -I : -I*S.Catalan - pi**2/48,
+        1 - I : pi**2/16 - I*S.Catalan - pi*I/4*log(2),
+        1 + I : pi**2/16 + I*S.Catalan + pi*I/4*log(2),
+        (1 - I)/2 : -log(2)**2/8 + pi*I*log(2)/8 + 5*pi**2/96 - I*S.Catalan
+    }

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/plotting/backends/textbackend/__init__.py

@@ -0,0 +1,3 @@
+from sympy.plotting.backends.textbackend.text import TextBackend
+
+__all__ = ["TextBackend"]

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/plotting/backends/textbackend/text.py

@@ -0,0 +1,24 @@
+import sympy.plotting.backends.base_backend as base_backend
+from sympy.plotting.series import LineOver1DRangeSeries
+from sympy.plotting.textplot import textplot
+
+
+class TextBackend(base_backend.Plot):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def show(self):
+        if not base_backend._show:
+            return
+        if len(self._series) != 1:
+            raise ValueError(
+                'The TextBackend supports only one graph per Plot.')
+        elif not isinstance(self._series[0], LineOver1DRangeSeries):
+            raise ValueError(
+                'The TextBackend supports only expressions over a 1D range')
+        else:
+            ser = self._series[0]
+            textplot(ser.expr, ser.start, ser.end)
+
+    def close(self):
+        pass

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/plotting/intervalmath/__init__.py

@@ -0,0 +1,12 @@
+from .interval_arithmetic import interval
+from .lib_interval import (Abs, exp, log, log10, sin, cos, tan, sqrt,
+                          imin, imax, sinh, cosh, tanh, acosh, asinh, atanh,
+                          asin, acos, atan, ceil, floor, And, Or)
+
+__all__ = [
+    'interval',
+
+    'Abs', 'exp', 'log', 'log10', 'sin', 'cos', 'tan', 'sqrt', 'imin', 'imax',
+    'sinh', 'cosh', 'tanh', 'acosh', 'asinh', 'atanh', 'asin', 'acos', 'atan',
+    'ceil', 'floor', 'And', 'Or',
+]

URSA/.venv_ursa/lib/python3.12/site-packages/sympy/plotting/intervalmath/interval_arithmetic.py

@@ -0,0 +1,413 @@
+"""
+Interval Arithmetic for plotting.
+This module does not implement interval arithmetic accurately and
+hence cannot be used for purposes other than plotting. If you want
+to use interval arithmetic, use mpmath's interval arithmetic.
+
+The module implements interval arithmetic using numpy and
+python floating points. The rounding up and down is not handled
+and hence this is not an accurate implementation of interval
+arithmetic.
+
+The module uses numpy for speed which cannot be achieved with mpmath.
+"""
+
+# Q: Why use numpy? Why not simply use mpmath's interval arithmetic?
+# A: mpmath's interval arithmetic simulates a floating point unit
+# and hence is slow, while numpy evaluations are orders of magnitude
+# faster.
+
+# Q: Why create a separate class for intervals? Why not use SymPy's
+# Interval Sets?
+# A: The functionalities that will be required for plotting is quite
+# different from what Interval Sets implement.
+
+# Q: Why is rounding up and down according to IEEE754 not handled?
+# A: It is not possible to do it in both numpy and python. An external
+# library has to used, which defeats the whole purpose i.e., speed. Also
+# rounding is handled for very few functions in those libraries.
+
+# Q Will my plots be affected?
+# A It will not affect most of the plots. The interval arithmetic
+# module based suffers the same problems as that of floating point
+# arithmetic.
+
+from sympy.core.numbers import int_valued
+from sympy.core.logic import fuzzy_and
+from sympy.simplify.simplify import nsimplify
+
+from .interval_membership import intervalMembership
+
+
+class interval:
+    """ Represents an interval containing floating points as start and
+    end of the interval
+    The is_valid variable tracks whether the interval obtained as the
+    result of the function is in the domain and is continuous.
+    - True: Represents the interval result of a function is continuous and
+            in the domain of the function.
+    - False: The interval argument of the function was not in the domain of
+             the function, hence the is_valid of the result interval is False
+    - None: The function was not continuous over the interval or
+            the function's argument interval is partly in the domain of the
+            function
+
+    A comparison between an interval and a real number, or a
+    comparison between two intervals may return ``intervalMembership``
+    of two 3-valued logic values.
+    """
+
+    def __init__(self, *args, is_valid=True, **kwargs):
+        self.is_valid = is_valid
+        if len(args) == 1:
+            if isinstance(args[0], interval):
+                self.start, self.end = args[0].start, args[0].end
+            else:
+                self.start = float(args[0])
+                self.end = float(args[0])
+        elif len(args) == 2:
+            if args[0] < args[1]:
+                self.start = float(args[0])
+                self.end = float(args[1])
+            else:
+                self.start = float(args[1])
+                self.end = float(args[0])
+
+        else:
+            raise ValueError("interval takes a maximum of two float values "
+                            "as arguments")
+
+    @property
+    def mid(self):
+        return (self.start + self.end) / 2.0
+
+    @property
+    def width(self):
+        return self.end - self.start
+
+    def __repr__(self):
+        return "interval(%f, %f)" % (self.start, self.end)
+
+    def __str__(self):
+        return "[%f, %f]" % (self.start, self.end)
+
+    def __lt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end < other:
+                return intervalMembership(True, self.is_valid)
+            elif self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        elif isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end < other. start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start > other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__lt__(self)
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(True, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(False, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(True, valid)
+            elif self.__lt__(other)[0] is not None:
+                return intervalMembership(False, valid)
+            else:
+                return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ne__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start == other and self.end == other:
+                return intervalMembership(False, self.is_valid)
+            if other in self:
+                return intervalMembership(None, self.is_valid)
+            else:
+                return intervalMembership(True, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.start == other.start and self.end == other.end:
+                return intervalMembership(False, valid)
+            if not self.__lt__(other)[0] is None:
+                return intervalMembership(True, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, (int, float)):
+            if self.end <= other:
+                return intervalMembership(True, self.is_valid)
+            if self.start > other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+
+        if isinstance(other, interval):
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            if self.end <= other.start:
+                return intervalMembership(True, valid)
+            if self.start > other.end:
+                return intervalMembership(False, valid)
+            return intervalMembership(None, valid)
+        else:
+            return NotImplemented
+
+    def __ge__(self, other):
+        if isinstance(other, (int, float)):
+            if self.start >= other:
+                return intervalMembership(True, self.is_valid)
+            elif self.end < other:
+                return intervalMembership(False, self.is_valid)
+            else:
+                return intervalMembership(None, self.is_valid)
+        elif isinstance(other, interval):
+            return other.__le__(self)
+
+    def __add__(self, other):
+        if isinstance(other, (int, float)):
+            if self.is_valid:
+                return interval(self.start + other, self.end + other)
+            else:
+                start = self.start + other
+                end = self.end + other
+                return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start + other.start
+            end = self.end + other.end
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        if isinstance(other, (int, float)):
+            start = self.start - other
+            end = self.end - other
+            return interval(start, end, is_valid=self.is_valid)
+
+        elif isinstance(other, interval):
+            start = self.start - other.end
+            end = self.end - other.start
+            valid = fuzzy_and([self.is_valid, other.is_valid])
+            return interval(start, end, is_valid=valid)
+        else:
+            return NotImplemented
+
+    def __rsub__(self, other):
+        if isinstance(other, (int, float)):
+            start = other - self.end
+            end = other - self.start
+            return interval(start, end, is_valid=self.is_valid)
+        elif isinstance(other, interval):
+            return other.__sub__(self)
+        else:
+            return NotImplemented
+
+    def __neg__(self):
+        if self.is_valid:
+            return interval(-self.end, -self.start)
+        else:
+            return interval(-self.end, -self.start, is_valid=self.is_valid)
+
+    def __mul__(self, other):
+        if isinstance(other, interval):
+            if self.is_valid is False or other.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif self.is_valid is None or other.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+                inters = []
+                inters.append(self.start * other.start)
+                inters.append(self.end * other.start)
+                inters.append(self.start * other.end)
+                inters.append(self.end * other.end)
+                start = min(inters)
+                end = max(inters)
+                return interval(start, end)
+        elif isinstance(other, (int, float)):
+            return interval(self.start*other, self.end*other, is_valid=self.is_valid)
+        else:
+            return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __contains__(self, other):
+        if isinstance(other, (int, float)):
+            return self.start <= other and self.end >= other
+        else:
+            return self.start <= other.start and other.end <= self.end
+
+    def __rtruediv__(self, other):
+        if isinstance(other, (int, float)):
+            other = interval(other)
+            return other.__truediv__(self)
+        elif isinstance(other, interval):
+            return other.__truediv__(self)
+        else:
+            return NotImplemented
+
+    def __truediv__(self, other):
+        # Both None and False are handled
+        if not self.is_valid:
+            # Don't divide as the value is not valid
+            return interval(-float('inf'), float('inf'), is_valid=self.is_valid)
+        if isinstance(other, (int, float)):
+            if other == 0:
+                # Divide by zero encountered. valid nowhere
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            else:
+                return interval(self.start / other, self.end / other)
+
+        elif isinstance(other, interval):
+            if other.is_valid is False or self.is_valid is False:
+                return interval(-float('inf'), float('inf'), is_valid=False)
+            elif other.is_valid is None or self.is_valid is None:
+                return interval(-float('inf'), float('inf'), is_valid=None)
+            else:
+               # denominator contains both signs, i.e. being divided by zero
+               # return the whole real line with is_valid = None
+                if 0 in other:
+                    return interval(-float('inf'), float('inf'), is_valid=None)
+
+                # denominator negative
+                this = self
+                if other.end < 0:
+                    this = -this
+                    other = -other
+
+                # denominator positive
+                inters = []
+                inters.append(this.start / other.start)
+                inters.append(this.end / other.start)
+                inters.append(this.start / other.end)
+                inters.append(this.end / other.end)
+                start = max(inters)
+                end = min(inters)
+                return interval(start, end)
+        else:
+            return NotImplemented
+
+    def __pow__(self, other):
+        # Implements only power to an integer.
+        from .lib_interval import exp, log
+        if not self.is_valid:
+            return self
+        if isinstance(other, interval):
+            return exp(other * log(self))
+        elif isinstance(other, (float, int)):
+            if other < 0:
+                return 1 / self.__pow__(abs(other))
+            else:
+                if int_valued(other):
+                    return _pow_int(self, other)
+                else:
+                    return _pow_float(self, other)
+        else:
+            return NotImplemented
+
+    def __rpow__(self, other):
+        if isinstance(other, (float, int)):
+            if not self.is_valid:
+                #Don't do anything
+                return self
+            elif other < 0:
+                if self.width > 0:
+                    return interval(-float('inf'), float('inf'), is_valid=False)
+                else:
+                    power_rational = nsimplify(self.start)
+                    num, denom = power_rational.as_numer_denom()
+                    if denom % 2 == 0:
+                        return interval(-float('inf'), float('inf'),
+                                        is_valid=False)
+                    else:
+                        start = -abs(other)**self.start
+                        end = start
+                        return interval(start, end)
+            else:
+                return interval(other**self.start, other**self.end)
+        elif isinstance(other, interval):
+            return other.__pow__(self)
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash((self.is_valid, self.start, self.end))
+
+
+def _pow_float(inter, power):
+    """Evaluates an interval raised to a floating point."""
+    power_rational = nsimplify(power)
+    num, denom = power_rational.as_numer_denom()
+    if num % 2 == 0:
+        start = abs(inter.start)**power
+        end = abs(inter.end)**power
+        if start < 0:
+            ret = interval(0, max(start, end))
+        else:
+            ret = interval(start, end)
+        return ret
+    elif denom % 2 == 0:
+        if inter.end < 0:
+            return interval(-float('inf'), float('inf'), is_valid=False)
+        elif inter.start < 0:
+            return interval(0, inter.end**power, is_valid=None)
+        else:
+            return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0:
+            start = -abs(inter.start)**power
+        else:
+            start = inter.start**power
+
+        if inter.end < 0:
+            end = -abs(inter.end)**power
+        else:
+            end = inter.end**power
+
+        return interval(start, end, is_valid=inter.is_valid)
+
+
+def _pow_int(inter, power):
+    """Evaluates an interval raised to an integer power"""
+    power = int(power)
+    if power & 1:
+        return interval(inter.start**power, inter.end**power)
+    else:
+        if inter.start < 0 and inter.end > 0:
+            start = 0
+            end = max(inter.start**power, inter.end**power)
+            return interval(start, end)
+        else:
+            return interval(inter.start**power, inter.end**power)