Add files using upload-large-folder tool

llava_next/lib/python3.10/site-packages/regex/__init__.py

@@ -0,0 +1,3 @@
+from .regex import *
+from . import regex
+__all__ = regex.__all__

llava_next/lib/python3.10/site-packages/regex/regex.py

@@ -0,0 +1,746 @@
+#
+# Secret Labs' Regular Expression Engine
+#
+# Copyright (c) 1998-2001 by Secret Labs AB.  All rights reserved.
+#
+# This version of the SRE library can be redistributed under CNRI's
+# Python 1.6 license.  For any other use, please contact Secret Labs
+# AB (info@pythonware.com).
+#
+# Portions of this engine have been developed in cooperation with
+# CNRI.  Hewlett-Packard provided funding for 1.6 integration and
+# other compatibility work.
+#
+# 2010-01-16 mrab Python front-end re-written and extended
+
+r"""Support for regular expressions (RE).
+
+This module provides regular expression matching operations similar to those
+found in Perl. It supports both 8-bit and Unicode strings; both the pattern and
+the strings being processed can contain null bytes and characters outside the
+US ASCII range.
+
+Regular expressions can contain both special and ordinary characters. Most
+ordinary characters, like "A", "a", or "0", are the simplest regular
+expressions; they simply match themselves. You can concatenate ordinary
+characters, so last matches the string 'last'.
+
+There are a few differences between the old (legacy) behaviour and the new
+(enhanced) behaviour, which are indicated by VERSION0 or VERSION1.
+
+The special characters are:
+    "."                 Matches any character except a newline.
+    "^"                 Matches the start of the string.
+    "$"                 Matches the end of the string or just before the
+                        newline at the end of the string.
+    "*"                 Matches 0 or more (greedy) repetitions of the preceding
+                        RE. Greedy means that it will match as many repetitions
+                        as possible.
+    "+"                 Matches 1 or more (greedy) repetitions of the preceding
+                        RE.
+    "?"                 Matches 0 or 1 (greedy) of the preceding RE.
+    *?,+?,??            Non-greedy versions of the previous three special
+                        characters.
+    *+,++,?+            Possessive versions of the previous three special
+                        characters.
+    {m,n}               Matches from m to n repetitions of the preceding RE.
+    {m,n}?              Non-greedy version of the above.
+    {m,n}+              Possessive version of the above.
+    {...}               Fuzzy matching constraints.
+    "\\"                Either escapes special characters or signals a special
+                        sequence.
+    [...]               Indicates a set of characters. A "^" as the first
+                        character indicates a complementing set.
+    "|"                 A|B, creates an RE that will match either A or B.
+    (...)               Matches the RE inside the parentheses. The contents are
+                        captured and can be retrieved or matched later in the
+                        string.
+    (?flags-flags)      VERSION1: Sets/clears the flags for the remainder of
+                        the group or pattern; VERSION0: Sets the flags for the
+                        entire pattern.
+    (?:...)             Non-capturing version of regular parentheses.
+    (?>...)             Atomic non-capturing version of regular parentheses.
+    (?flags-flags:...)  Non-capturing version of regular parentheses with local
+                        flags.
+    (?P<name>...)       The substring matched by the group is accessible by
+                        name.
+    (?<name>...)        The substring matched by the group is accessible by
+                        name.
+    (?P=name)           Matches the text matched earlier by the group named
+                        name.
+    (?#...)             A comment; ignored.
+    (?=...)             Matches if ... matches next, but doesn't consume the
+                        string.
+    (?!...)             Matches if ... doesn't match next.
+    (?<=...)            Matches if preceded by ....
+    (?<!...)            Matches if not preceded by ....
+    (?(id)yes|no)       Matches yes pattern if group id matched, the (optional)
+                        no pattern otherwise.
+    (?(DEFINE)...)      If there's no group called "DEFINE", then ... will be
+                        ignored, but any group definitions will be available.
+    (?|...|...)         (?|A|B), creates an RE that will match either A or B,
+                        but reuses capture group numbers across the
+                        alternatives.
+    (*FAIL)             Forces matching to fail, which means immediate
+                        backtracking.
+    (*F)                Abbreviation for (*FAIL).
+    (*PRUNE)            Discards the current backtracking information. Its
+                        effect doesn't extend outside an atomic group or a
+                        lookaround.
+    (*SKIP)             Similar to (*PRUNE), except that it also sets where in
+                        the text the next attempt at matching the entire
+                        pattern will start. Its effect doesn't extend outside
+                        an atomic group or a lookaround.
+
+The fuzzy matching constraints are: "i" to permit insertions, "d" to permit
+deletions, "s" to permit substitutions, "e" to permit any of these. Limits are
+optional with "<=" and "<". If any type of error is provided then any type not
+provided is not permitted.
+
+A cost equation may be provided.
+
+Examples:
+    (?:fuzzy){i<=2}
+    (?:fuzzy){i<=1,s<=2,d<=1,1i+1s+1d<3}
+
+VERSION1: Set operators are supported, and a set can include nested sets. The
+set operators, in order of increasing precedence, are:
+    ||  Set union ("x||y" means "x or y").
+    ~~  (double tilde) Symmetric set difference ("x~~y" means "x or y, but not
+        both").
+    &&  Set intersection ("x&&y" means "x and y").
+    --  (double dash) Set difference ("x--y" means "x but not y").
+
+Implicit union, ie, simple juxtaposition like in [ab], has the highest
+precedence.
+
+VERSION0 and VERSION1:
+The special sequences consist of "\\" and a character from the list below. If
+the ordinary character is not on the list, then the resulting RE will match the
+second character.
+    \number         Matches the contents of the group of the same number if
+                    number is no more than 2 digits, otherwise the character
+                    with the 3-digit octal code.
+    \a              Matches the bell character.
+    \A              Matches only at the start of the string.
+    \b              Matches the empty string, but only at the start or end of a
+                    word.
+    \B              Matches the empty string, but not at the start or end of a
+                    word.
+    \d              Matches any decimal digit; equivalent to the set [0-9] when
+                    matching a bytestring or a Unicode string with the ASCII
+                    flag, or the whole range of Unicode digits when matching a
+                    Unicode string.
+    \D              Matches any non-digit character; equivalent to [^\d].
+    \f              Matches the formfeed character.
+    \g<name>        Matches the text matched by the group named name.
+    \G              Matches the empty string, but only at the position where
+                    the search started.
+    \h              Matches horizontal whitespace.
+    \K              Keeps only what follows for the entire match.
+    \L<name>        Named list. The list is provided as a keyword argument.
+    \m              Matches the empty string, but only at the start of a word.
+    \M              Matches the empty string, but only at the end of a word.
+    \n              Matches the newline character.
+    \N{name}        Matches the named character.
+    \p{name=value}  Matches the character if its property has the specified
+                    value.
+    \P{name=value}  Matches the character if its property hasn't the specified
+                    value.
+    \r              Matches the carriage-return character.
+    \s              Matches any whitespace character; equivalent to
+                    [ \t\n\r\f\v].
+    \S              Matches any non-whitespace character; equivalent to [^\s].
+    \t              Matches the tab character.
+    \uXXXX          Matches the Unicode codepoint with 4-digit hex code XXXX.
+    \UXXXXXXXX      Matches the Unicode codepoint with 8-digit hex code
+                    XXXXXXXX.
+    \v              Matches the vertical tab character.
+    \w              Matches any alphanumeric character; equivalent to
+                    [a-zA-Z0-9_] when matching a bytestring or a Unicode string
+                    with the ASCII flag, or the whole range of Unicode
+                    alphanumeric characters (letters plus digits plus
+                    underscore) when matching a Unicode string. With LOCALE, it
+                    will match the set [0-9_] plus characters defined as
+                    letters for the current locale.
+    \W              Matches the complement of \w; equivalent to [^\w].
+    \xXX            Matches the character with 2-digit hex code XX.
+    \X              Matches a grapheme.
+    \Z              Matches only at the end of the string.
+    \\              Matches a literal backslash.
+
+This module exports the following functions:
+    match      Match a regular expression pattern at the beginning of a string.
+    fullmatch  Match a regular expression pattern against all of a string.
+    search     Search a string for the presence of a pattern.
+    sub        Substitute occurrences of a pattern found in a string using a
+               template string.
+    subf       Substitute occurrences of a pattern found in a string using a
+               format string.
+    subn       Same as sub, but also return the number of substitutions made.
+    subfn      Same as subf, but also return the number of substitutions made.
+    split      Split a string by the occurrences of a pattern. VERSION1: will
+               split at zero-width match; VERSION0: won't split at zero-width
+               match.
+    splititer  Return an iterator yielding the parts of a split string.
+    findall    Find all occurrences of a pattern in a string.
+    finditer   Return an iterator yielding a match object for each match.
+    compile    Compile a pattern into a Pattern object.
+    purge      Clear the regular expression cache.
+    escape     Backslash all non-alphanumerics or special characters in a
+               string.
+
+Most of the functions support a concurrent parameter: if True, the GIL will be
+released during matching, allowing other Python threads to run concurrently. If
+the string changes during matching, the behaviour is undefined. This parameter
+is not needed when working on the builtin (immutable) string classes.
+
+Some of the functions in this module take flags as optional parameters. Most of
+these flags can also be set within an RE:
+    A   a   ASCII         Make \w, \W, \b, \B, \d, and \D match the
+                          corresponding ASCII character categories. Default
+                          when matching a bytestring.
+    B   b   BESTMATCH     Find the best fuzzy match (default is first).
+    D       DEBUG         Print the parsed pattern.
+    E   e   ENHANCEMATCH  Attempt to improve the fit after finding the first
+                          fuzzy match.
+    F   f   FULLCASE      Use full case-folding when performing
+                          case-insensitive matching in Unicode.
+    I   i   IGNORECASE    Perform case-insensitive matching.
+    L   L   LOCALE        Make \w, \W, \b, \B, \d, and \D dependent on the
+                          current locale. (One byte per character only.)
+    M   m   MULTILINE     "^" matches the beginning of lines (after a newline)
+                          as well as the string. "$" matches the end of lines
+                          (before a newline) as well as the end of the string.
+    P   p   POSIX         Perform POSIX-standard matching (leftmost longest).
+    R   r   REVERSE       Searches backwards.
+    S   s   DOTALL        "." matches any character at all, including the
+                          newline.
+    U   u   UNICODE       Make \w, \W, \b, \B, \d, and \D dependent on the
+                          Unicode locale. Default when matching a Unicode
+                          string.
+    V0  V0  VERSION0      Turn on the old legacy behaviour.
+    V1  V1  VERSION1      Turn on the new enhanced behaviour. This flag
+                          includes the FULLCASE flag.
+    W   w   WORD          Make \b and \B work with default Unicode word breaks
+                          and make ".", "^" and "$" work with Unicode line
+                          breaks.
+    X   x   VERBOSE       Ignore whitespace and comments for nicer looking REs.
+
+This module also defines an exception 'error'.
+
+"""
+
+# Public symbols.
+__all__ = ["cache_all", "compile", "DEFAULT_VERSION", "escape", "findall",
+  "finditer", "fullmatch", "match", "purge", "search", "split", "splititer",
+  "sub", "subf", "subfn", "subn", "template", "Scanner", "A", "ASCII", "B",
+  "BESTMATCH", "D", "DEBUG", "E", "ENHANCEMATCH", "S", "DOTALL", "F",
+  "FULLCASE", "I", "IGNORECASE", "L", "LOCALE", "M", "MULTILINE", "P", "POSIX",
+  "R", "REVERSE", "T", "TEMPLATE", "U", "UNICODE", "V0", "VERSION0", "V1",
+  "VERSION1", "X", "VERBOSE", "W", "WORD", "error", "Regex", "__version__",
+  "__doc__", "RegexFlag"]
+
+__version__ = "2.5.148"
+
+# --------------------------------------------------------------------
+# Public interface.
+
+def match(pattern, string, flags=0, pos=None, endpos=None, partial=False,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Try to apply the pattern at the start of the string, returning a match
+    object, or None if no match was found."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.match(string, pos, endpos, concurrent, partial, timeout)
+
+def fullmatch(pattern, string, flags=0, pos=None, endpos=None, partial=False,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Try to apply the pattern against all of the string, returning a match
+    object, or None if no match was found."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.fullmatch(string, pos, endpos, concurrent, partial, timeout)
+
+def search(pattern, string, flags=0, pos=None, endpos=None, partial=False,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Search through string looking for a match to the pattern, returning a
+    match object, or None if no match was found."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.search(string, pos, endpos, concurrent, partial, timeout)
+
+def sub(pattern, repl, string, count=0, flags=0, pos=None, endpos=None,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Return the string obtained by replacing the leftmost (or rightmost with a
+    reverse pattern) non-overlapping occurrences of the pattern in string by the
+    replacement repl. repl can be either a string or a callable; if a string,
+    backslash escapes in it are processed; if a callable, it's passed the match
+    object and must return a replacement string to be used."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.sub(repl, string, count, pos, endpos, concurrent, timeout)
+
+def subf(pattern, format, string, count=0, flags=0, pos=None, endpos=None,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Return the string obtained by replacing the leftmost (or rightmost with a
+    reverse pattern) non-overlapping occurrences of the pattern in string by the
+    replacement format. format can be either a string or a callable; if a string,
+    it's treated as a format string; if a callable, it's passed the match object
+    and must return a replacement string to be used."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.subf(format, string, count, pos, endpos, concurrent, timeout)
+
+def subn(pattern, repl, string, count=0, flags=0, pos=None, endpos=None,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Return a 2-tuple containing (new_string, number). new_string is the string
+    obtained by replacing the leftmost (or rightmost with a reverse pattern)
+    non-overlapping occurrences of the pattern in the source string by the
+    replacement repl. number is the number of substitutions that were made. repl
+    can be either a string or a callable; if a string, backslash escapes in it
+    are processed; if a callable, it's passed the match object and must return a
+    replacement string to be used."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.subn(repl, string, count, pos, endpos, concurrent, timeout)
+
+def subfn(pattern, format, string, count=0, flags=0, pos=None, endpos=None,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Return a 2-tuple containing (new_string, number). new_string is the string
+    obtained by replacing the leftmost (or rightmost with a reverse pattern)
+    non-overlapping occurrences of the pattern in the source string by the
+    replacement format. number is the number of substitutions that were made. format
+    can be either a string or a callable; if a string, it's treated as a format
+    string; if a callable, it's passed the match object and must return a
+    replacement string to be used."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.subfn(format, string, count, pos, endpos, concurrent, timeout)
+
+def split(pattern, string, maxsplit=0, flags=0, concurrent=None, timeout=None,
+  ignore_unused=False, **kwargs):
+    """Split the source string by the occurrences of the pattern, returning a
+    list containing the resulting substrings.  If capturing parentheses are used
+    in pattern, then the text of all groups in the pattern are also returned as
+    part of the resulting list.  If maxsplit is nonzero, at most maxsplit splits
+    occur, and the remainder of the string is returned as the final element of
+    the list."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.split(string, maxsplit, concurrent, timeout)
+
+def splititer(pattern, string, maxsplit=0, flags=0, concurrent=None,
+  timeout=None, ignore_unused=False, **kwargs):
+    "Return an iterator yielding the parts of a split string."
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.splititer(string, maxsplit, concurrent, timeout)
+
+def findall(pattern, string, flags=0, pos=None, endpos=None, overlapped=False,
+  concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Return a list of all matches in the string. The matches may be overlapped
+    if overlapped is True. If one or more groups are present in the pattern,
+    return a list of groups; this will be a list of tuples if the pattern has
+    more than one group. Empty matches are included in the result."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.findall(string, pos, endpos, overlapped, concurrent, timeout)
+
+def finditer(pattern, string, flags=0, pos=None, endpos=None, overlapped=False,
+  partial=False, concurrent=None, timeout=None, ignore_unused=False, **kwargs):
+    """Return an iterator over all matches in the string. The matches may be
+    overlapped if overlapped is True. For each match, the iterator returns a
+    match object. Empty matches are included in the result."""
+    pat = _compile(pattern, flags, ignore_unused, kwargs, True)
+    return pat.finditer(string, pos, endpos, overlapped, concurrent, partial,
+      timeout)
+
+def compile(pattern, flags=0, ignore_unused=False, cache_pattern=None, **kwargs):
+    "Compile a regular expression pattern, returning a pattern object."
+    if cache_pattern is None:
+        cache_pattern = _cache_all
+    return _compile(pattern, flags, ignore_unused, kwargs, cache_pattern)
+
+def purge():
+    "Clear the regular expression cache"
+    _cache.clear()
+    _locale_sensitive.clear()
+
+# Whether to cache all patterns.
+_cache_all = True
+
+def cache_all(value=True):
+    """Sets whether to cache all patterns, even those are compiled explicitly.
+    Passing None has no effect, but returns the current setting."""
+    global _cache_all
+
+    if value is None:
+        return _cache_all
+
+    _cache_all = value
+
+def template(pattern, flags=0):
+    "Compile a template pattern, returning a pattern object."
+    return _compile(pattern, flags | TEMPLATE, False, {}, False)
+
+def escape(pattern, special_only=True, literal_spaces=False):
+    """Escape a string for use as a literal in a pattern. If special_only is
+    True, escape only special characters, else escape all non-alphanumeric
+    characters. If literal_spaces is True, don't escape spaces."""
+    # Convert it to Unicode.
+    if isinstance(pattern, bytes):
+        p = pattern.decode("latin-1")
+    else:
+        p = pattern
+
+    s = []
+    if special_only:
+        for c in p:
+            if c == " " and literal_spaces:
+                s.append(c)
+            elif c in _METACHARS or c.isspace():
+                s.append("\\")
+                s.append(c)
+            else:
+                s.append(c)
+    else:
+        for c in p:
+            if c == " " and literal_spaces:
+                s.append(c)
+            elif c in _ALNUM:
+                s.append(c)
+            else:
+                s.append("\\")
+                s.append(c)
+
+    r = "".join(s)
+    # Convert it back to bytes if necessary.
+    if isinstance(pattern, bytes):
+        r = r.encode("latin-1")
+
+    return r
+
+# --------------------------------------------------------------------
+# Internals.
+
+import regex._regex_core as _regex_core
+import regex._regex as _regex
+from threading import RLock as _RLock
+from locale import getpreferredencoding as _getpreferredencoding
+from regex._regex_core import *
+from regex._regex_core import (_ALL_VERSIONS, _ALL_ENCODINGS, _FirstSetError,
+  _UnscopedFlagSet, _check_group_features, _compile_firstset,
+  _compile_replacement, _flatten_code, _fold_case, _get_required_string,
+  _parse_pattern, _shrink_cache)
+from regex._regex_core import (ALNUM as _ALNUM, Info as _Info, OP as _OP, Source
+  as _Source, Fuzzy as _Fuzzy)
+
+# Version 0 is the old behaviour, compatible with the original 're' module.
+# Version 1 is the new behaviour, which differs slightly.
+
+DEFAULT_VERSION = VERSION0
+
+_METACHARS = frozenset("()[]{}?*+|^$\\.-#&~")
+
+_regex_core.DEFAULT_VERSION = DEFAULT_VERSION
+
+# Caches for the patterns and replacements.
+_cache = {}
+_cache_lock = _RLock()
+_named_args = {}
+_replacement_cache = {}
+_locale_sensitive = {}
+
+# Maximum size of the cache.
+_MAXCACHE = 500
+_MAXREPCACHE = 500
+
+def _compile(pattern, flags, ignore_unused, kwargs, cache_it):
+    "Compiles a regular expression to a PatternObject."
+
+    global DEFAULT_VERSION
+    try:
+        from regex import DEFAULT_VERSION
+    except ImportError:
+        pass
+
+    # We won't bother to cache the pattern if we're debugging.
+    if (flags & DEBUG) != 0:
+        cache_it = False
+
+    # What locale is this pattern using?
+    locale_key = (type(pattern), pattern)
+    if _locale_sensitive.get(locale_key, True) or (flags & LOCALE) != 0:
+        # This pattern is, or might be, locale-sensitive.
+        pattern_locale = _getpreferredencoding()
+    else:
+        # This pattern is definitely not locale-sensitive.
+        pattern_locale = None
+
+    def complain_unused_args():
+        if ignore_unused:
+            return
+
+        # Complain about any unused keyword arguments, possibly resulting from a typo.
+        unused_kwargs = set(kwargs) - {k for k, v in args_needed}
+        if unused_kwargs:
+            any_one = next(iter(unused_kwargs))
+            raise ValueError('unused keyword argument {!a}'.format(any_one))
+
+    if cache_it:
+        try:
+            # Do we know what keyword arguments are needed?
+            args_key = pattern, type(pattern), flags
+            args_needed = _named_args[args_key]
+
+            # Are we being provided with its required keyword arguments?
+            args_supplied = set()
+            if args_needed:
+                for k, v in args_needed:
+                    try:
+                        args_supplied.add((k, frozenset(kwargs[k])))
+                    except KeyError:
+                        raise error("missing named list: {!r}".format(k))
+
+            complain_unused_args()
+
+            args_supplied = frozenset(args_supplied)
+
+            # Have we already seen this regular expression and named list?
+            pattern_key = (pattern, type(pattern), flags, args_supplied,
+              DEFAULT_VERSION, pattern_locale)
+            return _cache[pattern_key]
+        except KeyError:
+            # It's a new pattern, or new named list for a known pattern.
+            pass
+
+    # Guess the encoding from the class of the pattern string.
+    if isinstance(pattern, str):
+        guess_encoding = UNICODE
+    elif isinstance(pattern, bytes):
+        guess_encoding = ASCII
+    elif isinstance(pattern, Pattern):
+        if flags:
+            raise ValueError("cannot process flags argument with a compiled pattern")
+
+        return pattern
+    else:
+        raise TypeError("first argument must be a string or compiled pattern")
+
+    # Set the default version in the core code in case it has been changed.
+    _regex_core.DEFAULT_VERSION = DEFAULT_VERSION
+
+    global_flags = flags
+
+    while True:
+        caught_exception = None
+        try:
+            source = _Source(pattern)
+            info = _Info(global_flags, source.char_type, kwargs)
+            info.guess_encoding = guess_encoding
+            source.ignore_space = bool(info.flags & VERBOSE)
+            parsed = _parse_pattern(source, info)
+            break
+        except _UnscopedFlagSet:
+            # Remember the global flags for the next attempt.
+            global_flags = info.global_flags
+        except error as e:
+            caught_exception = e
+
+        if caught_exception:
+            raise error(caught_exception.msg, caught_exception.pattern,
+              caught_exception.pos)
+
+    if not source.at_end():
+        raise error("unbalanced parenthesis", pattern, source.pos)
+
+    # Check the global flags for conflicts.
+    version = (info.flags & _ALL_VERSIONS) or DEFAULT_VERSION
+    if version not in (0, VERSION0, VERSION1):
+        raise ValueError("VERSION0 and VERSION1 flags are mutually incompatible")
+
+    if (info.flags & _ALL_ENCODINGS) not in (0, ASCII, LOCALE, UNICODE):
+        raise ValueError("ASCII, LOCALE and UNICODE flags are mutually incompatible")
+
+    if isinstance(pattern, bytes) and (info.flags & UNICODE):
+        raise ValueError("cannot use UNICODE flag with a bytes pattern")
+
+    if not (info.flags & _ALL_ENCODINGS):
+        if isinstance(pattern, str):
+            info.flags |= UNICODE
+        else:
+            info.flags |= ASCII
+
+    reverse = bool(info.flags & REVERSE)
+    fuzzy = isinstance(parsed, _Fuzzy)
+
+    # Remember whether this pattern as an inline locale flag.
+    _locale_sensitive[locale_key] = info.inline_locale
+
+    # Fix the group references.
+    caught_exception = None
+    try:
+        parsed.fix_groups(pattern, reverse, False)
+    except error as e:
+        caught_exception = e
+
+    if caught_exception:
+        raise error(caught_exception.msg, caught_exception.pattern,
+          caught_exception.pos)
+
+    # Should we print the parsed pattern?
+    if flags & DEBUG:
+        parsed.dump(indent=0, reverse=reverse)
+
+    # Optimise the parsed pattern.
+    parsed = parsed.optimise(info, reverse)
+    parsed = parsed.pack_characters(info)
+
+    # Get the required string.
+    req_offset, req_chars, req_flags = _get_required_string(parsed, info.flags)
+
+    # Build the named lists.
+    named_lists = {}
+    named_list_indexes = [None] * len(info.named_lists_used)
+    args_needed = set()
+    for key, index in info.named_lists_used.items():
+        name, case_flags = key
+        values = frozenset(kwargs[name])
+        if case_flags:
+            items = frozenset(_fold_case(info, v) for v in values)
+        else:
+            items = values
+        named_lists[name] = values
+        named_list_indexes[index] = items
+        args_needed.add((name, values))
+
+    complain_unused_args()
+
+    # Check the features of the groups.
+    _check_group_features(info, parsed)
+
+    # Compile the parsed pattern. The result is a list of tuples.
+    code = parsed.compile(reverse)
+
+    # Is there a group call to the pattern as a whole?
+    key = (0, reverse, fuzzy)
+    ref = info.call_refs.get(key)
+    if ref is not None:
+        code = [(_OP.CALL_REF, ref)] + code + [(_OP.END, )]
+
+    # Add the final 'success' opcode.
+    code += [(_OP.SUCCESS, )]
+
+    # Compile the additional copies of the groups that we need.
+    for group, rev, fuz in info.additional_groups:
+        code += group.compile(rev, fuz)
+
+    # Flatten the code into a list of ints.
+    code = _flatten_code(code)
+
+    if not parsed.has_simple_start():
+        # Get the first set, if possible.
+        try:
+            fs_code = _compile_firstset(info, parsed.get_firstset(reverse))
+            fs_code = _flatten_code(fs_code)
+            code = fs_code + code
+        except _FirstSetError:
+            pass
+
+    # The named capture groups.
+    index_group = dict((v, n) for n, v in info.group_index.items())
+
+    # Create the PatternObject.
+    #
+    # Local flags like IGNORECASE affect the code generation, but aren't needed
+    # by the PatternObject itself. Conversely, global flags like LOCALE _don't_
+    # affect the code generation but _are_ needed by the PatternObject.
+    compiled_pattern = _regex.compile(pattern, info.flags | version, code,
+      info.group_index, index_group, named_lists, named_list_indexes,
+      req_offset, req_chars, req_flags, info.group_count)
+
+    # Do we need to reduce the size of the cache?
+    if len(_cache) >= _MAXCACHE:
+        with _cache_lock:
+            _shrink_cache(_cache, _named_args, _locale_sensitive, _MAXCACHE)
+
+    if cache_it:
+        if (info.flags & LOCALE) == 0:
+            pattern_locale = None
+
+        args_needed = frozenset(args_needed)
+
+        # Store this regular expression and named list.
+        pattern_key = (pattern, type(pattern), flags, args_needed,
+          DEFAULT_VERSION, pattern_locale)
+        _cache[pattern_key] = compiled_pattern
+
+        # Store what keyword arguments are needed.
+        _named_args[args_key] = args_needed
+
+    return compiled_pattern
+
+def _compile_replacement_helper(pattern, template):
+    "Compiles a replacement template."
+    # This function is called by the _regex module.
+
+    # Have we seen this before?
+    key = pattern.pattern, pattern.flags, template
+    compiled = _replacement_cache.get(key)
+    if compiled is not None:
+        return compiled
+
+    if len(_replacement_cache) >= _MAXREPCACHE:
+        _replacement_cache.clear()
+
+    is_unicode = isinstance(template, str)
+    source = _Source(template)
+    if is_unicode:
+        def make_string(char_codes):
+            return "".join(chr(c) for c in char_codes)
+    else:
+        def make_string(char_codes):
+            return bytes(char_codes)
+
+    compiled = []
+    literal = []
+    while True:
+        ch = source.get()
+        if not ch:
+            break
+        if ch == "\\":
+            # '_compile_replacement' will return either an int group reference
+            # or a string literal. It returns items (plural) in order to handle
+            # a 2-character literal (an invalid escape sequence).
+            is_group, items = _compile_replacement(source, pattern, is_unicode)
+            if is_group:
+                # It's a group, so first flush the literal.
+                if literal:
+                    compiled.append(make_string(literal))
+                    literal = []
+                compiled.extend(items)
+            else:
+                literal.extend(items)
+        else:
+            literal.append(ord(ch))
+
+    # Flush the literal.
+    if literal:
+        compiled.append(make_string(literal))
+
+    _replacement_cache[key] = compiled
+
+    return compiled
+
+# We define Pattern here after all the support objects have been defined.
+_pat = _compile('', 0, False, {}, False)
+Pattern = type(_pat)
+Match = type(_pat.match(''))
+del _pat
+
+# Make Pattern public for typing annotations.
+__all__.append("Pattern")
+__all__.append("Match")
+
+# We'll define an alias for the 'compile' function so that the repr of a
+# pattern object is eval-able.
+Regex = compile
+
+# Register myself for pickling.
+import copyreg as _copy_reg
+
+def _pickle(pattern):
+    return _regex.compile, pattern._pickled_data
+
+_copy_reg.pickle(Pattern, _pickle)

llava_next/lib/python3.10/site-packages/torch-2.1.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

llava_next/lib/python3.10/site-packages/torch-2.1.2.dist-info/METADATA

@@ -0,0 +1,520 @@
+Metadata-Version: 2.1
+Name: torch
+Version: 2.1.2
+Summary: Tensors and Dynamic neural networks in Python with strong GPU acceleration
+Home-page: https://pytorch.org/
+Author: PyTorch Team
+Author-email: packages@pytorch.org
+License: BSD-3
+Download-URL: https://github.com/pytorch/pytorch/tags
+Keywords: pytorch,machine learning
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.8.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: filelock
+Requires-Dist: typing-extensions
+Requires-Dist: sympy
+Requires-Dist: networkx
+Requires-Dist: jinja2
+Requires-Dist: fsspec
+Requires-Dist: nvidia-cuda-nvrtc-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-cuda-runtime-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-cuda-cupti-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-cudnn-cu12 (==8.9.2.26) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-cublas-cu12 (==12.1.3.1) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-cufft-cu12 (==11.0.2.54) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-curand-cu12 (==10.3.2.106) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-cusolver-cu12 (==11.4.5.107) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-cusparse-cu12 (==12.1.0.106) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-nccl-cu12 (==2.18.1) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: nvidia-nvtx-cu12 (==12.1.105) ; platform_system == "Linux" and platform_machine == "x86_64"
+Requires-Dist: triton (==2.1.0) ; platform_system == "Linux" and platform_machine == "x86_64"
+Provides-Extra: dynamo
+Requires-Dist: jinja2 ; extra == 'dynamo'
+Provides-Extra: opt-einsum
+Requires-Dist: opt-einsum (>=3.3) ; extra == 'opt-einsum'
+
+![PyTorch Logo](https://github.com/pytorch/pytorch/blob/main/docs/source/_static/img/pytorch-logo-dark.png)
+
+--------------------------------------------------------------------------------
+
+PyTorch is a Python package that provides two high-level features:
+- Tensor computation (like NumPy) with strong GPU acceleration
+- Deep neural networks built on a tape-based autograd system
+
+You can reuse your favorite Python packages such as NumPy, SciPy, and Cython to extend PyTorch when needed.
+
+Our trunk health (Continuous Integration signals) can be found at [hud.pytorch.org](https://hud.pytorch.org/ci/pytorch/pytorch/main).
+
+<!-- toc -->
+
+- [More About PyTorch](#more-about-pytorch)
+  - [A GPU-Ready Tensor Library](#a-gpu-ready-tensor-library)
+  - [Dynamic Neural Networks: Tape-Based Autograd](#dynamic-neural-networks-tape-based-autograd)
+  - [Python First](#python-first)
+  - [Imperative Experiences](#imperative-experiences)
+  - [Fast and Lean](#fast-and-lean)
+  - [Extensions Without Pain](#extensions-without-pain)
+- [Installation](#installation)
+  - [Binaries](#binaries)
+    - [NVIDIA Jetson Platforms](#nvidia-jetson-platforms)
+  - [From Source](#from-source)
+    - [Prerequisites](#prerequisites)
+    - [Install Dependencies](#install-dependencies)
+    - [Get the PyTorch Source](#get-the-pytorch-source)
+    - [Install PyTorch](#install-pytorch)
+      - [Adjust Build Options (Optional)](#adjust-build-options-optional)
+  - [Docker Image](#docker-image)
+    - [Using pre-built images](#using-pre-built-images)
+    - [Building the image yourself](#building-the-image-yourself)
+  - [Building the Documentation](#building-the-documentation)
+  - [Previous Versions](#previous-versions)
+- [Getting Started](#getting-started)
+- [Resources](#resources)
+- [Communication](#communication)
+- [Releases and Contributing](#releases-and-contributing)
+- [The Team](#the-team)
+- [License](#license)
+
+<!-- tocstop -->
+
+## More About PyTorch
+
+[Learn the basics of PyTorch](https://pytorch.org/tutorials/beginner/basics/intro.html)
+
+At a granular level, PyTorch is a library that consists of the following components:
+
+| Component | Description |
+| ---- | --- |
+| [**torch**](https://pytorch.org/docs/stable/torch.html) | A Tensor library like NumPy, with strong GPU support |
+| [**torch.autograd**](https://pytorch.org/docs/stable/autograd.html) | A tape-based automatic differentiation library that supports all differentiable Tensor operations in torch |
+| [**torch.jit**](https://pytorch.org/docs/stable/jit.html) | A compilation stack (TorchScript) to create serializable and optimizable models from PyTorch code  |
+| [**torch.nn**](https://pytorch.org/docs/stable/nn.html) | A neural networks library deeply integrated with autograd designed for maximum flexibility |
+| [**torch.multiprocessing**](https://pytorch.org/docs/stable/multiprocessing.html) | Python multiprocessing, but with magical memory sharing of torch Tensors across processes. Useful for data loading and Hogwild training |
+| [**torch.utils**](https://pytorch.org/docs/stable/data.html) | DataLoader and other utility functions for convenience |
+
+Usually, PyTorch is used either as:
+
+- A replacement for NumPy to use the power of GPUs.
+- A deep learning research platform that provides maximum flexibility and speed.
+
+Elaborating Further:
+
+### A GPU-Ready Tensor Library
+
+If you use NumPy, then you have used Tensors (a.k.a. ndarray).
+
+![Tensor illustration](./docs/source/_static/img/tensor_illustration.png)
+
+PyTorch provides Tensors that can live either on the CPU or the GPU and accelerates the
+computation by a huge amount.
+
+We provide a wide variety of tensor routines to accelerate and fit your scientific computation needs
+such as slicing, indexing, mathematical operations, linear algebra, reductions.
+And they are fast!
+
+### Dynamic Neural Networks: Tape-Based Autograd
+
+PyTorch has a unique way of building neural networks: using and replaying a tape recorder.
+
+Most frameworks such as TensorFlow, Theano, Caffe, and CNTK have a static view of the world.
+One has to build a neural network and reuse the same structure again and again.
+Changing the way the network behaves means that one has to start from scratch.
+
+With PyTorch, we use a technique called reverse-mode auto-differentiation, which allows you to
+change the way your network behaves arbitrarily with zero lag or overhead. Our inspiration comes
+from several research papers on this topic, as well as current and past work such as
+[torch-autograd](https://github.com/twitter/torch-autograd),
+[autograd](https://github.com/HIPS/autograd),
+[Chainer](https://chainer.org), etc.
+
+While this technique is not unique to PyTorch, it's one of the fastest implementations of it to date.
+You get the best of speed and flexibility for your crazy research.
+
+![Dynamic graph](https://github.com/pytorch/pytorch/blob/main/docs/source/_static/img/dynamic_graph.gif)
+
+### Python First
+
+PyTorch is not a Python binding into a monolithic C++ framework.
+It is built to be deeply integrated into Python.
+You can use it naturally like you would use [NumPy](https://www.numpy.org/) / [SciPy](https://www.scipy.org/) / [scikit-learn](https://scikit-learn.org) etc.
+You can write your new neural network layers in Python itself, using your favorite libraries
+and use packages such as [Cython](https://cython.org/) and [Numba](http://numba.pydata.org/).
+Our goal is to not reinvent the wheel where appropriate.
+
+### Imperative Experiences
+
+PyTorch is designed to be intuitive, linear in thought, and easy to use.
+When you execute a line of code, it gets executed. There isn't an asynchronous view of the world.
+When you drop into a debugger or receive error messages and stack traces, understanding them is straightforward.
+The stack trace points to exactly where your code was defined.
+We hope you never spend hours debugging your code because of bad stack traces or asynchronous and opaque execution engines.
+
+### Fast and Lean
+
+PyTorch has minimal framework overhead. We integrate acceleration libraries
+such as [Intel MKL](https://software.intel.com/mkl) and NVIDIA ([cuDNN](https://developer.nvidia.com/cudnn), [NCCL](https://developer.nvidia.com/nccl)) to maximize speed.
+At the core, its CPU and GPU Tensor and neural network backends
+are mature and have been tested for years.
+
+Hence, PyTorch is quite fast — whether you run small or large neural networks.
+
+The memory usage in PyTorch is extremely efficient compared to Torch or some of the alternatives.
+We've written custom memory allocators for the GPU to make sure that
+your deep learning models are maximally memory efficient.
+This enables you to train bigger deep learning models than before.
+
+### Extensions Without Pain
+
+Writing new neural network modules, or interfacing with PyTorch's Tensor API was designed to be straightforward
+and with minimal abstractions.
+
+You can write new neural network layers in Python using the torch API
+[or your favorite NumPy-based libraries such as SciPy](https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html).
+
+If you want to write your layers in C/C++, we provide a convenient extension API that is efficient and with minimal boilerplate.
+No wrapper code needs to be written. You can see [a tutorial here](https://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp).
+
+
+## Installation
+
+### Binaries
+Commands to install binaries via Conda or pip wheels are on our website: [https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)
+
+
+#### NVIDIA Jetson Platforms
+
+Python wheels for NVIDIA's Jetson Nano, Jetson TX1/TX2, Jetson Xavier NX/AGX, and Jetson AGX Orin are provided [here](https://forums.developer.nvidia.com/t/pytorch-for-jetson-version-1-10-now-available/72048) and the L4T container is published [here](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-pytorch)
+
+They require JetPack 4.2 and above, and [@dusty-nv](https://github.com/dusty-nv) and [@ptrblck](https://github.com/ptrblck) are maintaining them.
+
+
+### From Source
+
+#### Prerequisites
+If you are installing from source, you will need:
+- Python 3.8 or later (for Linux, Python 3.8.1+ is needed)
+- A compiler that fully supports C++17, such as clang or gcc (especially for aarch64, gcc 9.4.0 or newer is required)
+
+We highly recommend installing an [Anaconda](https://www.anaconda.com/download) environment. You will get a high-quality BLAS library (MKL) and you get controlled dependency versions regardless of your Linux distro.
+
+If you want to compile with CUDA support, [select a supported version of CUDA from our support matrix](https://pytorch.org/get-started/locally/), then install the following:
+- [NVIDIA CUDA](https://developer.nvidia.com/cuda-downloads)
+- [NVIDIA cuDNN](https://developer.nvidia.com/cudnn) v7 or above
+- [Compiler](https://gist.github.com/ax3l/9489132) compatible with CUDA
+
+Note: You could refer to the [cuDNN Support Matrix](https://docs.nvidia.com/deeplearning/cudnn/pdf/cuDNN-Support-Matrix.pdf) for cuDNN versions with the various supported CUDA, CUDA driver and NVIDIA hardware
+
+If you want to disable CUDA support, export the environment variable `USE_CUDA=0`.
+Other potentially useful environment variables may be found in `setup.py`.
+
+If you are building for NVIDIA's Jetson platforms (Jetson Nano, TX1, TX2, AGX Xavier), Instructions to install PyTorch for Jetson Nano are [available here](https://devtalk.nvidia.com/default/topic/1049071/jetson-nano/pytorch-for-jetson-nano/)
+
+If you want to compile with ROCm support, install
+- [AMD ROCm](https://rocm.docs.amd.com/en/latest/deploy/linux/quick_start.html) 4.0 and above installation
+- ROCm is currently supported only for Linux systems.
+
+If you want to disable ROCm support, export the environment variable `USE_ROCM=0`.
+Other potentially useful environment variables may be found in `setup.py`.
+
+#### Install Dependencies
+
+**Common**
+
+```bash
+conda install cmake ninja
+# Run this command from the PyTorch directory after cloning the source code using the “Get the PyTorch Source“ section below
+pip install -r requirements.txt
+```
+
+**On Linux**
+
+```bash
+conda install mkl mkl-include
+# CUDA only: Add LAPACK support for the GPU if needed
+conda install -c pytorch magma-cuda110  # or the magma-cuda* that matches your CUDA version from https://anaconda.org/pytorch/repo
+
+# (optional) If using torch.compile with inductor/triton, install the matching version of triton
+# Run from the pytorch directory after cloning
+make triton
+```
+
+**On MacOS**
+
+```bash
+# Add this package on intel x86 processor machines only
+conda install mkl mkl-include
+# Add these packages if torch.distributed is needed
+conda install pkg-config libuv
+```
+
+**On Windows**
+
+```bash
+conda install mkl mkl-include
+# Add these packages if torch.distributed is needed.
+# Distributed package support on Windows is a prototype feature and is subject to changes.
+conda install -c conda-forge libuv=1.39
+```
+
+#### Get the PyTorch Source
+```bash
+git clone --recursive https://github.com/pytorch/pytorch
+cd pytorch
+# if you are updating an existing checkout
+git submodule sync
+git submodule update --init --recursive
+```
+
+#### Install PyTorch
+**On Linux**
+
+If you would like to compile PyTorch with [new C++ ABI](https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html) enabled, then first run this command:
+```bash
+export _GLIBCXX_USE_CXX11_ABI=1
+```
+
+If you're compiling for AMD ROCm then first run this command:
+```bash
+# Only run this if you're compiling for ROCm
+python tools/amd_build/build_amd.py
+```
+
+Install PyTorch
+```bash
+export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}
+python setup.py develop
+```
+
+> _Aside:_ If you are using [Anaconda](https://www.anaconda.com/distribution/#download-section), you may experience an error caused by the linker:
+>
+> ```plaintext
+> build/temp.linux-x86_64-3.7/torch/csrc/stub.o: file not recognized: file format not recognized
+> collect2: error: ld returned 1 exit status
+> error: command 'g++' failed with exit status 1
+> ```
+>
+> This is caused by `ld` from the Conda environment shadowing the system `ld`. You should use a newer version of Python that fixes this issue. The recommended Python version is 3.8.1+.
+
+**On macOS**
+
+```bash
+python3 setup.py develop
+```
+
+**On Windows**
+
+Choose Correct Visual Studio Version.
+
+PyTorch CI uses Visual C++ BuildTools, which come with Visual Studio Enterprise,
+Professional, or Community Editions. You can also install the build tools from
+https://visualstudio.microsoft.com/visual-cpp-build-tools/. The build tools *do not*
+come with Visual Studio Code by default.
+
+If you want to build legacy python code, please refer to [Building on legacy code and CUDA](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md#building-on-legacy-code-and-cuda)
+
+**CPU-only builds**
+
+In this mode PyTorch computations will run on your CPU, not your GPU
+
+```cmd
+conda activate
+python setup.py develop
+```
+
+Note on OpenMP: The desired OpenMP implementation is Intel OpenMP (iomp). In order to link against iomp, you'll need to manually download the library and set up the building environment by tweaking `CMAKE_INCLUDE_PATH` and `LIB`. The instruction [here](https://github.com/pytorch/pytorch/blob/main/docs/source/notes/windows.rst#building-from-source) is an example for setting up both MKL and Intel OpenMP. Without these configurations for CMake, Microsoft Visual C OpenMP runtime (vcomp) will be used.
+
+**CUDA based build**
+
+In this mode PyTorch computations will leverage your GPU via CUDA for faster number crunching
+
+[NVTX](https://docs.nvidia.com/gameworks/content/gameworkslibrary/nvtx/nvidia_tools_extension_library_nvtx.htm) is needed to build Pytorch with CUDA.
+NVTX is a part of CUDA distributive, where it is called "Nsight Compute". To install it onto an already installed CUDA run CUDA installation once again and check the corresponding checkbox.
+Make sure that CUDA with Nsight Compute is installed after Visual Studio.
+
+Currently, VS 2017 / 2019, and Ninja are supported as the generator of CMake. If `ninja.exe` is detected in `PATH`, then Ninja will be used as the default generator, otherwise, it will use VS 2017 / 2019.
+<br/> If Ninja is selected as the generator, the latest MSVC will get selected as the underlying toolchain.
+
+Additional libraries such as
+[Magma](https://developer.nvidia.com/magma), [oneDNN, a.k.a. MKLDNN or DNNL](https://github.com/oneapi-src/oneDNN), and [Sccache](https://github.com/mozilla/sccache) are often needed. Please refer to the [installation-helper](https://github.com/pytorch/pytorch/tree/main/.ci/pytorch/win-test-helpers/installation-helpers) to install them.
+
+You can refer to the [build_pytorch.bat](https://github.com/pytorch/pytorch/blob/main/.ci/pytorch/win-test-helpers/build_pytorch.bat) script for some other environment variables configurations
+
+
+```cmd
+cmd
+
+:: Set the environment variables after you have downloaded and unzipped the mkl package,
+:: else CMake would throw an error as `Could NOT find OpenMP`.
+set CMAKE_INCLUDE_PATH={Your directory}\mkl\include
+set LIB={Your directory}\mkl\lib;%LIB%
+
+:: Read the content in the previous section carefully before you proceed.
+:: [Optional] If you want to override the underlying toolset used by Ninja and Visual Studio with CUDA, please run the following script block.
+:: "Visual Studio 2019 Developer Command Prompt" will be run automatically.
+:: Make sure you have CMake >= 3.12 before you do this when you use the Visual Studio generator.
+set CMAKE_GENERATOR_TOOLSET_VERSION=14.27
+set DISTUTILS_USE_SDK=1
+for /f "usebackq tokens=*" %i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -version [15^,17^) -products * -latest -property installationPath`) do call "%i\VC\Auxiliary\Build\vcvarsall.bat" x64 -vcvars_ver=%CMAKE_GENERATOR_TOOLSET_VERSION%
+
+:: [Optional] If you want to override the CUDA host compiler
+set CUDAHOSTCXX=C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.27.29110\bin\HostX64\x64\cl.exe
+
+python setup.py develop
+
+```
+
+##### Adjust Build Options (Optional)
+
+You can adjust the configuration of cmake variables optionally (without building first), by doing
+the following. For example, adjusting the pre-detected directories for CuDNN or BLAS can be done
+with such a step.
+
+On Linux
+```bash
+export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}
+python setup.py build --cmake-only
+ccmake build  # or cmake-gui build
+```
+
+On macOS
+```bash
+export CMAKE_PREFIX_PATH=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}
+MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ python setup.py build --cmake-only
+ccmake build  # or cmake-gui build
+```
+
+### Docker Image
+
+#### Using pre-built images
+
+You can also pull a pre-built docker image from Docker Hub and run with docker v19.03+
+
+```bash
+docker run --gpus all --rm -ti --ipc=host pytorch/pytorch:latest
+```
+
+Please note that PyTorch uses shared memory to share data between processes, so if torch multiprocessing is used (e.g.
+for multithreaded data loaders) the default shared memory segment size that container runs with is not enough, and you
+should increase shared memory size either with `--ipc=host` or `--shm-size` command line options to `nvidia-docker run`.
+
+#### Building the image yourself
+
+**NOTE:** Must be built with a docker version > 18.06
+
+The `Dockerfile` is supplied to build images with CUDA 11.1 support and cuDNN v8.
+You can pass `PYTHON_VERSION=x.y` make variable to specify which Python version is to be used by Miniconda, or leave it
+unset to use the default.
+
+```bash
+make -f docker.Makefile
+# images are tagged as docker.io/${your_docker_username}/pytorch
+```
+
+You can also pass the `CMAKE_VARS="..."` environment variable to specify additional CMake variables to be passed to CMake during the build.
+See [setup.py](./setup.py) for the list of available variables.
+
+```bash
+CMAKE_VARS="BUILD_CAFFE2=ON BUILD_CAFFE2_OPS=ON" make -f docker.Makefile
+```
+
+### Building the Documentation
+
+To build documentation in various formats, you will need [Sphinx](http://www.sphinx-doc.org) and the
+readthedocs theme.
+
+```bash
+cd docs/
+pip install -r requirements.txt
+```
+You can then build the documentation by running `make <format>` from the
+`docs/` folder. Run `make` to get a list of all available output formats.
+
+If you get a katex error run `npm install katex`.  If it persists, try
+`npm install -g katex`
+
+> Note: if you installed `nodejs` with a different package manager (e.g.,
+`conda`) then `npm` will probably install a version of `katex` that is not
+compatible with your version of `nodejs` and doc builds will fail.
+A combination of versions that is known to work is `node@6.13.1` and
+`katex@0.13.18`. To install the latter with `npm` you can run
+```npm install -g katex@0.13.18```
+
+### Previous Versions
+
+Installation instructions and binaries for previous PyTorch versions may be found
+on [our website](https://pytorch.org/previous-versions).
+
+
+## Getting Started
+
+Three-pointers to get you started:
+- [Tutorials: get you started with understanding and using PyTorch](https://pytorch.org/tutorials/)
+- [Examples: easy to understand PyTorch code across all domains](https://github.com/pytorch/examples)
+- [The API Reference](https://pytorch.org/docs/)
+- [Glossary](https://github.com/pytorch/pytorch/blob/main/GLOSSARY.md)
+
+## Resources
+
+* [PyTorch.org](https://pytorch.org/)
+* [PyTorch Tutorials](https://pytorch.org/tutorials/)
+* [PyTorch Examples](https://github.com/pytorch/examples)
+* [PyTorch Models](https://pytorch.org/hub/)
+* [Intro to Deep Learning with PyTorch from Udacity](https://www.udacity.com/course/deep-learning-pytorch--ud188)
+* [Intro to Machine Learning with PyTorch from Udacity](https://www.udacity.com/course/intro-to-machine-learning-nanodegree--nd229)
+* [Deep Neural Networks with PyTorch from Coursera](https://www.coursera.org/learn/deep-neural-networks-with-pytorch)
+* [PyTorch Twitter](https://twitter.com/PyTorch)
+* [PyTorch Blog](https://pytorch.org/blog/)
+* [PyTorch YouTube](https://www.youtube.com/channel/UCWXI5YeOsh03QvJ59PMaXFw)
+
+## Communication
+* Forums: Discuss implementations, research, etc. https://discuss.pytorch.org
+* GitHub Issues: Bug reports, feature requests, install issues, RFCs, thoughts, etc.
+* Slack: The [PyTorch Slack](https://pytorch.slack.com/) hosts a primary audience of moderate to experienced PyTorch users and developers for general chat, online discussions, collaboration, etc. If you are a beginner looking for help, the primary medium is [PyTorch Forums](https://discuss.pytorch.org). If you need a slack invite, please fill this form: https://goo.gl/forms/PP1AGvNHpSaJP8to1
+* Newsletter: No-noise, a one-way email newsletter with important announcements about PyTorch. You can sign-up here: https://eepurl.com/cbG0rv
+* Facebook Page: Important announcements about PyTorch. https://www.facebook.com/pytorch
+* For brand guidelines, please visit our website at [pytorch.org](https://pytorch.org/)
+
+## Releases and Contributing
+
+Typically, PyTorch has three minor releases a year. Please let us know if you encounter a bug by [filing an issue](https://github.com/pytorch/pytorch/issues).
+
+We appreciate all contributions. If you are planning to contribute back bug-fixes, please do so without any further discussion.
+
+If you plan to contribute new features, utility functions, or extensions to the core, please first open an issue and discuss the feature with us.
+Sending a PR without discussion might end up resulting in a rejected PR because we might be taking the core in a different direction than you might be aware of.
+
+To learn more about making a contribution to Pytorch, please see our [Contribution page](CONTRIBUTING.md). For more information about PyTorch releases, see [Release page](RELEASE.md).
+
+## The Team
+
+PyTorch is a community-driven project with several skillful engineers and researchers contributing to it.
+
+PyTorch is currently maintained by [Soumith Chintala](http://soumith.ch), [Gregory Chanan](https://github.com/gchanan), [Dmytro Dzhulgakov](https://github.com/dzhulgakov), [Edward Yang](https://github.com/ezyang), and [Nikita Shulga](https://github.com/malfet) with major contributions coming from hundreds of talented individuals in various forms and means.
+A non-exhaustive but growing list needs to mention: Trevor Killeen, Sasank Chilamkurthy, Sergey Zagoruyko, Adam Lerer, Francisco Massa, Alykhan Tejani, Luca Antiga, Alban Desmaison, Andreas Koepf, James Bradbury, Zeming Lin, Yuandong Tian, Guillaume Lample, Marat Dukhan, Natalia Gimelshein, Christian Sarofeen, Martin Raison, Edward Yang, Zachary Devito.
+
+Note: This project is unrelated to [hughperkins/pytorch](https://github.com/hughperkins/pytorch) with the same name. Hugh is a valuable contributor to the Torch community and has helped with many things Torch and PyTorch.
+
+## License
+
+PyTorch has a BSD-style license, as found in the [LICENSE](LICENSE) file.
+
+

llava_next/lib/python3.10/site-packages/torch-2.1.2.dist-info/NOTICE

@@ -0,0 +1,456 @@
+=======================================================================
+Software under third_party
+=======================================================================
+Software libraries under third_party are provided as github submodule
+links, and their content is not part of the Caffe2 codebase. Their
+licences can be found under the respective software repositories.
+
+=======================================================================
+Earlier BSD License
+=======================================================================
+Early development of Caffe2 in 2015 and early 2016 is licensed under the
+BSD license. The license is attached below:
+
+All contributions by Facebook:
+Copyright (c) 2016 Facebook Inc.
+
+All contributions by Google:
+Copyright (c) 2015 Google Inc.
+All rights reserved.
+
+All contributions by Yangqing Jia:
+Copyright (c) 2015 Yangqing Jia
+All rights reserved.
+
+All contributions by Kakao Brain:
+Copyright 2019-2020 Kakao Brain
+
+All other contributions:
+Copyright(c) 2015, 2016 the respective contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+=======================================================================
+Caffe's BSD License
+=======================================================================
+Some parts of the caffe2 code is derived from the original Caffe code, which is
+created by Yangqing Jia and is now a BSD-licensed open-source project. The Caffe
+license is as follows:
+
+COPYRIGHT
+
+All contributions by the University of California:
+Copyright (c) 2014, The Regents of the University of California (Regents)
+All rights reserved.
+
+All other contributions:
+Copyright (c) 2014, the respective contributors
+All rights reserved.
+
+Caffe uses a shared copyright model: each contributor holds copyright over
+their contributions to Caffe. The project versioning records all such
+contribution and copyright details. If a contributor wants to further mark
+their specific copyright on a particular contribution, they should indicate
+their copyright solely in the commit message of the change when it is
+committed.
+
+LICENSE
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+CONTRIBUTION AGREEMENT
+
+By contributing to the BVLC/caffe repository through pull-request, comment,
+or otherwise, the contributor releases their content to the
+license and copyright terms herein.
+
+=======================================================================
+Caffe2's Apache License
+=======================================================================
+
+This repo contains Caffe2 code, which was previously licensed under
+Apache License Version 2.0:
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+=======================================================================
+Cephes's 3-Clause BSD License
+=======================================================================
+
+Code derived from implementations in the Cephes Math Library should mention
+its derivation and reference the following license:
+
+   3-Clause BSD License for the Cephes Math Library
+   Copyright (c) 2018, Steven Moshier
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+   * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   * Neither the name of the nor the
+   names of its contributors may be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   DISCLAIMED. IN NO EVENT SHALL Steven Moshier BE LIABLE FOR ANY
+   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+=======================================================================
+SciPy's 3-Clause BSD License
+=======================================================================
+
+Code derived from implementations in SciPy should mention its derivation
+and reference the following license:
+
+   Copyright (c) 2001-2002 Enthought, Inc.  2003-2019, SciPy Developers.
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+
+   3. Neither the name of the copyright holder nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=======================================================================
+Boost's 1.0 Software License
+=======================================================================
+
+Code derived from implementations in Boost 1.0 should mention its
+derivation and reference the following license:
+
+   Boost Software License - Version 1.0 - August 17th, 2003
+
+   Permission is hereby granted, free of charge, to any person or organization
+   obtaining a copy of the software and accompanying documentation covered by
+   this license (the "Software") to use, reproduce, display, distribute,
+   execute, and transmit the Software, and to prepare derivative works of the
+   Software, and to permit third-parties to whom the Software is furnished to
+   do so, all subject to the following:
+
+   The copyright notices in the Software and this entire statement, including
+   the above license grant, this restriction and the following disclaimer,
+   must be included in all copies of the Software, in whole or in part, and
+   all derivative works of the Software, unless such copies or derivative
+   works are solely in the form of machine-executable object code generated by
+   a source language processor.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+   SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+   FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+=======================================================================
+PILLOW-SIMD Software License
+=======================================================================
+
+Code derived from implementations in PILLOW-SIMD should mention its derivation
+and reference the following license:
+
+    The Python Imaging Library (PIL) is
+
+        Copyright © 1997-2011 by Secret Labs AB
+        Copyright © 1995-2011 by Fredrik Lundh
+
+    Pillow is the friendly PIL fork. It is
+
+        Copyright © 2010-2022 by Alex Clark and contributors
+
+    Like PIL, Pillow is licensed under the open source HPND License:
+
+    By obtaining, using, and/or copying this software and/or its associated
+    documentation, you agree that you have read, understood, and will comply
+    with the following terms and conditions:
+
+    Permission to use, copy, modify, and distribute this software and its
+    associated documentation for any purpose and without fee is hereby granted,
+    provided that the above copyright notice appears in all copies, and that
+    both that copyright notice and this permission notice appear in supporting
+    documentation, and that the name of Secret Labs AB or the author not be
+    used in advertising or publicity pertaining to distribution of the software
+    without specific, written prior permission.
+
+    SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+    IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR ANY SPECIAL,
+    INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+    OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.

llava_next/lib/python3.10/site-packages/torch-2.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: false
+Tag: cp310-cp310-linux_x86_64
+

llava_next/lib/python3.10/site-packages/websockets-11.0.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

llava_next/lib/python3.10/site-packages/websockets-11.0.3.dist-info/RECORD

@@ -0,0 +1,88 @@
+websockets-11.0.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+websockets-11.0.3.dist-info/LICENSE,sha256=PWoMBQ2L7FL6utUC5F-yW9ArytvXDeo01Ee2oP9Obag,1514
+websockets-11.0.3.dist-info/METADATA,sha256=p679f2CwWdb-87gsrSEpFWqlue5gFCyNJbYqCucVpmg,6619
+websockets-11.0.3.dist-info/RECORD,,
+websockets-11.0.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+websockets-11.0.3.dist-info/WHEEL,sha256=24QVFBJBvF4a1ZC352AVuqHCJgY3xUfAV-_i6gkjtuc,225
+websockets-11.0.3.dist-info/top_level.txt,sha256=CMpdKklxKsvZgCgyltxUWOHibZXZ1uYIVpca9xsQ8Hk,11
+websockets/__init__.py,sha256=kezN0NeaLAYBNP8eNgIadwCf-X4qAuQjdqXVrdLm5AM,3426
+websockets/__main__.py,sha256=8Dtga-XePHQ4jqgMMuXHT8XRH_hSvs8bEZ7-v49vTKg,4744
+websockets/__pycache__/__init__.cpython-310.pyc,,
+websockets/__pycache__/__main__.cpython-310.pyc,,
+websockets/__pycache__/auth.cpython-310.pyc,,
+websockets/__pycache__/client.cpython-310.pyc,,
+websockets/__pycache__/connection.cpython-310.pyc,,
+websockets/__pycache__/datastructures.cpython-310.pyc,,
+websockets/__pycache__/exceptions.cpython-310.pyc,,
+websockets/__pycache__/frames.cpython-310.pyc,,
+websockets/__pycache__/headers.cpython-310.pyc,,
+websockets/__pycache__/http.cpython-310.pyc,,
+websockets/__pycache__/http11.cpython-310.pyc,,
+websockets/__pycache__/imports.cpython-310.pyc,,
+websockets/__pycache__/protocol.cpython-310.pyc,,
+websockets/__pycache__/server.cpython-310.pyc,,
+websockets/__pycache__/streams.cpython-310.pyc,,
+websockets/__pycache__/typing.cpython-310.pyc,,
+websockets/__pycache__/uri.cpython-310.pyc,,
+websockets/__pycache__/utils.cpython-310.pyc,,
+websockets/__pycache__/version.cpython-310.pyc,,
+websockets/auth.py,sha256=VObSo1Q61jh0XFXpeL6-1ir0OXlqA8OJjoChsB_01k8,139
+websockets/client.py,sha256=dfEJWRlGLaSfssMr3Lss-02n-IVosorFMD6Ub9JAI3E,12418
+websockets/connection.py,sha256=UivBmLaKmEOGpL1bU8uwh1PXIqMFiOUTVRi_gM7w5Rg,333
+websockets/datastructures.py,sha256=pcT7RdCI6ZfYddHWMcwPR-1A89GRpj26xgdtmZsRgiA,5738
+websockets/exceptions.py,sha256=DUzr1GdPO6FDAl9C5Wb3IhjSYSomVbvWo_NTM46zWm4,10143
+websockets/extensions/__init__.py,sha256=QkZsxaJVllVSp1uhdD5uPGibdbx_091GrVVfS5LXcpw,98
+websockets/extensions/__pycache__/__init__.cpython-310.pyc,,
+websockets/extensions/__pycache__/base.cpython-310.pyc,,
+websockets/extensions/__pycache__/permessage_deflate.cpython-310.pyc,,
+websockets/extensions/base.py,sha256=5shEU7lqmsLC7-y3OCWih1VdS_wOImmZwuAaEKl9kDU,3271
+websockets/extensions/permessage_deflate.py,sha256=bPFOAyTUDU7IIJyCGnWfr5yZF_J8dhCwJWt7jWuYM6c,24782
+websockets/frames.py,sha256=jSHawlqpEDrVcnGrKDawlINoelU9Hg5Wb0p4B_3SEl0,12537
+websockets/headers.py,sha256=RYryH2zqB_2Y02BTF2KsQFfYxAM6-Kh-A3Dv_32opAA,16120
+websockets/http.py,sha256=HR_IIij3xpoKkiLzGp4h5_NkVr2a8ZeCqGUopo6U4Rs,644
+websockets/http11.py,sha256=QcZ7u-UYbO98xQXrUz43qgaBXk-AyoQBHJBR0J9qYRE,12565
+websockets/imports.py,sha256=SXXs0glid-UHcwla5yjR72DIbGeUTrS9VFagPvPvRNY,2790
+websockets/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+websockets/legacy/__pycache__/__init__.cpython-310.pyc,,
+websockets/legacy/__pycache__/async_timeout.cpython-310.pyc,,
+websockets/legacy/__pycache__/auth.cpython-310.pyc,,
+websockets/legacy/__pycache__/client.cpython-310.pyc,,
+websockets/legacy/__pycache__/compatibility.cpython-310.pyc,,
+websockets/legacy/__pycache__/framing.cpython-310.pyc,,
+websockets/legacy/__pycache__/handshake.cpython-310.pyc,,
+websockets/legacy/__pycache__/http.cpython-310.pyc,,
+websockets/legacy/__pycache__/protocol.cpython-310.pyc,,
+websockets/legacy/__pycache__/server.cpython-310.pyc,,
+websockets/legacy/async_timeout.py,sha256=nHW_nJYnxtuprwPduZMTl789KAymwmv0ukLbzm2Z8yU,8540
+websockets/legacy/auth.py,sha256=WP68nZ1KAS0YCfNRyYG2M6LrNmT6xa430YnAjoeAP3g,6287
+websockets/legacy/client.py,sha256=cEa1xlsuUhJk9T0RKdRSWeYm8WGV2M7M8JZeqwp2tpE,26555
+websockets/legacy/compatibility.py,sha256=HRmodUeop_0hT7TG8_qIZrXmfGYDFioSmg3jCoPs0Ow,758
+websockets/legacy/framing.py,sha256=M4J6ZPRK-zNqY_UgPQ4Qppc4R64aSMftO7FR_0VpG-Q,4998
+websockets/legacy/handshake.py,sha256=RggPKl-w8oFJZQYZR0IdIOTrsz040pYp0Gu4L_D7_4U,5479
+websockets/legacy/http.py,sha256=qmrM7pa0kuuJIroMVahBAH8_ZVqkD91YhwVux_xpfeI,6938
+websockets/legacy/protocol.py,sha256=W_et77gFzuJ4IWtoROWt45v_Nx4Auq552HrQPakdGps,63339
+websockets/legacy/server.py,sha256=BjiJELoOfY7KspN9RpqquxIMVDgQZw4IFQscHdH82lM,45232
+websockets/protocol.py,sha256=sKb7pl8k5TFTBwZPB9_kBzvBaxSzR9ExHTPrgUbW6lU,23822
+websockets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+websockets/server.py,sha256=uYaKhW6y01WCSegDVAwKhFv__OAhG6_-lwbLIBXq0lw,20857
+websockets/speedups.c,sha256=ghPq-NF35VLVNkMv0uFDIruNpVISyW-qvoZgPpE65qw,5834
+websockets/speedups.cpython-310-x86_64-linux-gnu.so,sha256=tFuYvXgP4zHqpDcekn8lGpbSHaMwApSUvtfoH-TDtAs,33736
+websockets/streams.py,sha256=8nv62HYyS74t_JSWGie4SoYAz8-jMcQacaHnD0RkK90,4038
+websockets/sync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+websockets/sync/__pycache__/__init__.cpython-310.pyc,,
+websockets/sync/__pycache__/client.cpython-310.pyc,,
+websockets/sync/__pycache__/compatibility.cpython-310.pyc,,
+websockets/sync/__pycache__/connection.cpython-310.pyc,,
+websockets/sync/__pycache__/messages.cpython-310.pyc,,
+websockets/sync/__pycache__/server.cpython-310.pyc,,
+websockets/sync/__pycache__/utils.cpython-310.pyc,,
+websockets/sync/client.py,sha256=-9we3AHtE25pcT6EHGQ0oIyGzfYs18AzLpyDn4RLi94,11265
+websockets/sync/compatibility.py,sha256=1k-EUGSz-tpDdj4c65uIgbzpET5ZRWdQtRTPbZ8kFvI,555
+websockets/sync/connection.py,sha256=3Fe1BRNr4AdXs5j8UAdrSODomnfNrI460T0nTyn_2N0,29284
+websockets/sync/messages.py,sha256=pTcWhwD-uwA0l4a26_xgPHgP8pjRYk5xrX5Vhq-JuCo,9484
+websockets/sync/server.py,sha256=Wi306IkixafVw0JqeFEXUE7WWgIU_Go_FG3UQ9bz0HA,18661
+websockets/sync/utils.py,sha256=yUDxjeM4yVeXOZ_Go4ajgTUDOy-0rEWkjcR_RZDqcYY,1151
+websockets/typing.py,sha256=yx0SxSmil5JfG4fUtj-dgyR1UcW5wwmvgqtEOmcJxm4,1384
+websockets/uri.py,sha256=oymYUo7bX8LofYzXpT3UqTZfkCt2y4s680Xr-qw88qk,3215
+websockets/utils.py,sha256=QBhgbXn9ZvvLEzj-X8-zSHWVMkUqc6Wm-_HBjga5RNM,1150
+websockets/version.py,sha256=1txnm49P_pXG7EmoPowwuhzYwUJVkR1iaD-ZTyLuvrc,2723

llava_next/lib/python3.10/site-packages/websockets-11.0.3.dist-info/WHEEL

@@ -0,0 +1,8 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_5_x86_64
+Tag: cp310-cp310-manylinux1_x86_64
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

llava_next/lib/python3.10/site-packages/websockets-11.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+websockets

parrot/lib/python3.10/site-packages/sympy/integrals/__init__.py

@@ -0,0 +1,45 @@
+"""Integration functions that integrate a SymPy expression.
+
+    Examples
+    ========
+
+    >>> from sympy import integrate, sin
+    >>> from sympy.abc import x
+    >>> integrate(1/x,x)
+    log(x)
+    >>> integrate(sin(x),x)
+    -cos(x)
+"""
+from .integrals import integrate, Integral, line_integrate
+from .transforms import (mellin_transform, inverse_mellin_transform,
+                        MellinTransform, InverseMellinTransform,
+                        laplace_transform, inverse_laplace_transform,
+                        laplace_correspondence, laplace_initial_conds,
+                        LaplaceTransform, InverseLaplaceTransform,
+                        fourier_transform, inverse_fourier_transform,
+                        FourierTransform, InverseFourierTransform,
+                        sine_transform, inverse_sine_transform,
+                        SineTransform, InverseSineTransform,
+                        cosine_transform, inverse_cosine_transform,
+                        CosineTransform, InverseCosineTransform,
+                        hankel_transform, inverse_hankel_transform,
+                        HankelTransform, InverseHankelTransform)
+from .singularityfunctions import singularityintegrate
+
+__all__ = [
+    'integrate', 'Integral', 'line_integrate',
+
+    'mellin_transform', 'inverse_mellin_transform', 'MellinTransform',
+    'InverseMellinTransform', 'laplace_transform',
+    'inverse_laplace_transform', 'LaplaceTransform',
+    'laplace_correspondence', 'laplace_initial_conds',
+    'InverseLaplaceTransform', 'fourier_transform',
+    'inverse_fourier_transform', 'FourierTransform',
+    'InverseFourierTransform', 'sine_transform', 'inverse_sine_transform',
+    'SineTransform', 'InverseSineTransform', 'cosine_transform',
+    'inverse_cosine_transform', 'CosineTransform', 'InverseCosineTransform',
+    'hankel_transform', 'inverse_hankel_transform', 'HankelTransform',
+    'InverseHankelTransform',
+
+    'singularityintegrate',
+]

parrot/lib/python3.10/site-packages/sympy/integrals/integrals.py

@@ -0,0 +1,1640 @@
+from typing import Tuple as tTuple
+
+from sympy.concrete.expr_with_limits import AddWithLimits
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import diff
+from sympy.core.logic import fuzzy_bool
+from sympy.core.mul import Mul
+from sympy.core.numbers import oo, pi
+from sympy.core.relational import Ne
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, Wild)
+from sympy.core.sympify import sympify
+from sympy.functions import Piecewise, sqrt, piecewise_fold, tan, cot, atan
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.complexes import Abs, sign
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.functions.special.singularity_functions import Heaviside
+from .rationaltools import ratint
+from sympy.matrices import MatrixBase
+from sympy.polys import Poly, PolynomialError
+from sympy.series.formal import FormalPowerSeries
+from sympy.series.limits import limit
+from sympy.series.order import Order
+from sympy.tensor.functions import shape
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.misc import filldedent
+
+
+class Integral(AddWithLimits):
+    """Represents unevaluated integral."""
+
+    __slots__ = ()
+
+    args: tTuple[Expr, Tuple]
+
+    def __new__(cls, function, *symbols, **assumptions):
+        """Create an unevaluated integral.
+
+        Explanation
+        ===========
+
+        Arguments are an integrand followed by one or more limits.
+
+        If no limits are given and there is only one free symbol in the
+        expression, that symbol will be used, otherwise an error will be
+        raised.
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, y
+        >>> Integral(x)
+        Integral(x, x)
+        >>> Integral(y)
+        Integral(y, y)
+
+        When limits are provided, they are interpreted as follows (using
+        ``x`` as though it were the variable of integration):
+
+            (x,) or x - indefinite integral
+            (x, a) - "evaluate at" integral is an abstract antiderivative
+            (x, a, b) - definite integral
+
+        The ``as_dummy`` method can be used to see which symbols cannot be
+        targeted by subs: those with a prepended underscore cannot be
+        changed with ``subs``. (Also, the integration variables themselves --
+        the first element of a limit -- can never be changed by subs.)
+
+        >>> i = Integral(x, x)
+        >>> at = Integral(x, (x, x))
+        >>> i.as_dummy()
+        Integral(x, x)
+        >>> at.as_dummy()
+        Integral(_0, (_0, x))
+
+        """
+
+        #This will help other classes define their own definitions
+        #of behaviour with Integral.
+        if hasattr(function, '_eval_Integral'):
+            return function._eval_Integral(*symbols, **assumptions)
+
+        if isinstance(function, Poly):
+            sympy_deprecation_warning(
+                """
+                integrate(Poly) and Integral(Poly) are deprecated. Instead,
+                use the Poly.integrate() method, or convert the Poly to an
+                Expr first with the Poly.as_expr() method.
+                """,
+                deprecated_since_version="1.6",
+                active_deprecations_target="deprecated-integrate-poly")
+
+        obj = AddWithLimits.__new__(cls, function, *symbols, **assumptions)
+        return obj
+
+    def __getnewargs__(self):
+        return (self.function,) + tuple([tuple(xab) for xab in self.limits])
+
+    @property
+    def free_symbols(self):
+        """
+        This method returns the symbols that will exist when the
+        integral is evaluated. This is useful if one is trying to
+        determine whether an integral depends on a certain
+        symbol or not.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, y
+        >>> Integral(x, (x, y, 1)).free_symbols
+        {y}
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_limits.ExprWithLimits.function
+        sympy.concrete.expr_with_limits.ExprWithLimits.limits
+        sympy.concrete.expr_with_limits.ExprWithLimits.variables
+        """
+        return super().free_symbols
+
+    def _eval_is_zero(self):
+        # This is a very naive and quick test, not intended to do the integral to
+        # answer whether it is zero or not, e.g. Integral(sin(x), (x, 0, 2*pi))
+        # is zero but this routine should return None for that case. But, like
+        # Mul, there are trivial situations for which the integral will be
+        # zero so we check for those.
+        if self.function.is_zero:
+            return True
+        got_none = False
+        for l in self.limits:
+            if len(l) == 3:
+                z = (l[1] == l[2]) or (l[1] - l[2]).is_zero
+                if z:
+                    return True
+                elif z is None:
+                    got_none = True
+        free = self.function.free_symbols
+        for xab in self.limits:
+            if len(xab) == 1:
+                free.add(xab[0])
+                continue
+            if len(xab) == 2 and xab[0] not in free:
+                if xab[1].is_zero:
+                    return True
+                elif xab[1].is_zero is None:
+                    got_none = True
+            # take integration symbol out of free since it will be replaced
+            # with the free symbols in the limits
+            free.discard(xab[0])
+            # add in the new symbols
+            for i in xab[1:]:
+                free.update(i.free_symbols)
+        if self.function.is_zero is False and got_none is False:
+            return False
+
+    def transform(self, x, u):
+        r"""
+        Performs a change of variables from `x` to `u` using the relationship
+        given by `x` and `u` which will define the transformations `f` and `F`
+        (which are inverses of each other) as follows:
+
+        1) If `x` is a Symbol (which is a variable of integration) then `u`
+           will be interpreted as some function, f(u), with inverse F(u).
+           This, in effect, just makes the substitution of x with f(x).
+
+        2) If `u` is a Symbol then `x` will be interpreted as some function,
+           F(x), with inverse f(u). This is commonly referred to as
+           u-substitution.
+
+        Once f and F have been identified, the transformation is made as
+        follows:
+
+        .. math:: \int_a^b x \mathrm{d}x \rightarrow \int_{F(a)}^{F(b)} f(x)
+                  \frac{\mathrm{d}}{\mathrm{d}x}
+
+        where `F(x)` is the inverse of `f(x)` and the limits and integrand have
+        been corrected so as to retain the same value after integration.
+
+        Notes
+        =====
+
+        The mappings, F(x) or f(u), must lead to a unique integral. Linear
+        or rational linear expression, ``2*x``, ``1/x`` and ``sqrt(x)``, will
+        always work; quadratic expressions like ``x**2 - 1`` are acceptable
+        as long as the resulting integrand does not depend on the sign of
+        the solutions (see examples).
+
+        The integral will be returned unchanged if ``x`` is not a variable of
+        integration.
+
+        ``x`` must be (or contain) only one of of the integration variables. If
+        ``u`` has more than one free symbol then it should be sent as a tuple
+        (``u``, ``uvar``) where ``uvar`` identifies which variable is replacing
+        the integration variable.
+        XXX can it contain another integration variable?
+
+        Examples
+        ========
+
+        >>> from sympy.abc import a, x, u
+        >>> from sympy import Integral, cos, sqrt
+
+        >>> i = Integral(x*cos(x**2 - 1), (x, 0, 1))
+
+        transform can change the variable of integration
+
+        >>> i.transform(x, u)
+        Integral(u*cos(u**2 - 1), (u, 0, 1))
+
+        transform can perform u-substitution as long as a unique
+        integrand is obtained:
+
+        >>> ui = i.transform(x**2 - 1, u)
+        >>> ui
+        Integral(cos(u)/2, (u, -1, 0))
+
+        This attempt fails because x = +/-sqrt(u + 1) and the
+        sign does not cancel out of the integrand:
+
+        >>> Integral(cos(x**2 - 1), (x, 0, 1)).transform(x**2 - 1, u)
+        Traceback (most recent call last):
+        ...
+        ValueError:
+        The mapping between F(x) and f(u) did not give a unique integrand.
+
+        transform can do a substitution. Here, the previous
+        result is transformed back into the original expression
+        using "u-substitution":
+
+        >>> ui.transform(sqrt(u + 1), x) == i
+        True
+
+        We can accomplish the same with a regular substitution:
+
+        >>> ui.transform(u, x**2 - 1) == i
+        True
+
+        If the `x` does not contain a symbol of integration then
+        the integral will be returned unchanged. Integral `i` does
+        not have an integration variable `a` so no change is made:
+
+        >>> i.transform(a, x) == i
+        True
+
+        When `u` has more than one free symbol the symbol that is
+        replacing `x` must be identified by passing `u` as a tuple:
+
+        >>> Integral(x, (x, 0, 1)).transform(x, (u + a, u))
+        Integral(a + u, (u, -a, 1 - a))
+        >>> Integral(x, (x, 0, 1)).transform(x, (u + a, a))
+        Integral(a + u, (a, -u, 1 - u))
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_limits.ExprWithLimits.variables : Lists the integration variables
+        as_dummy : Replace integration variables with dummy ones
+        """
+        d = Dummy('d')
+
+        xfree = x.free_symbols.intersection(self.variables)
+        if len(xfree) > 1:
+            raise ValueError(
+                'F(x) can only contain one of: %s' % self.variables)
+        xvar = xfree.pop() if xfree else d
+
+        if xvar not in self.variables:
+            return self
+
+        u = sympify(u)
+        if isinstance(u, Expr):
+            ufree = u.free_symbols
+            if len(ufree) == 0:
+                raise ValueError(filldedent('''
+                f(u) cannot be a constant'''))
+            if len(ufree) > 1:
+                raise ValueError(filldedent('''
+                When f(u) has more than one free symbol, the one replacing x
+                must be identified: pass f(u) as (f(u), u)'''))
+            uvar = ufree.pop()
+        else:
+            u, uvar = u
+            if uvar not in u.free_symbols:
+                raise ValueError(filldedent('''
+                Expecting a tuple (expr, symbol) where symbol identified
+                a free symbol in expr, but symbol is not in expr's free
+                symbols.'''))
+            if not isinstance(uvar, Symbol):
+                # This probably never evaluates to True
+                raise ValueError(filldedent('''
+                Expecting a tuple (expr, symbol) but didn't get
+                a symbol; got %s''' % uvar))
+
+        if x.is_Symbol and u.is_Symbol:
+            return self.xreplace({x: u})
+
+        if not x.is_Symbol and not u.is_Symbol:
+            raise ValueError('either x or u must be a symbol')
+
+        if uvar == xvar:
+            return self.transform(x, (u.subs(uvar, d), d)).xreplace({d: uvar})
+
+        if uvar in self.limits:
+            raise ValueError(filldedent('''
+            u must contain the same variable as in x
+            or a variable that is not already an integration variable'''))
+
+        from sympy.solvers.solvers import solve
+        if not x.is_Symbol:
+            F = [x.subs(xvar, d)]
+            soln = solve(u - x, xvar, check=False)
+            if not soln:
+                raise ValueError('no solution for solve(F(x) - f(u), x)')
+            f = [fi.subs(uvar, d) for fi in soln]
+        else:
+            f = [u.subs(uvar, d)]
+            from sympy.simplify.simplify import posify
+            pdiff, reps = posify(u - x)
+            puvar = uvar.subs([(v, k) for k, v in reps.items()])
+            soln = [s.subs(reps) for s in solve(pdiff, puvar)]
+            if not soln:
+                raise ValueError('no solution for solve(F(x) - f(u), u)')
+            F = [fi.subs(xvar, d) for fi in soln]
+
+        newfuncs = {(self.function.subs(xvar, fi)*fi.diff(d)
+                        ).subs(d, uvar) for fi in f}
+        if len(newfuncs) > 1:
+            raise ValueError(filldedent('''
+            The mapping between F(x) and f(u) did not give
+            a unique integrand.'''))
+        newfunc = newfuncs.pop()
+
+        def _calc_limit_1(F, a, b):
+            """
+            replace d with a, using subs if possible, otherwise limit
+            where sign of b is considered
+            """
+            wok = F.subs(d, a)
+            if wok is S.NaN or wok.is_finite is False and a.is_finite:
+                return limit(sign(b)*F, d, a)
+            return wok
+
+        def _calc_limit(a, b):
+            """
+            replace d with a, using subs if possible, otherwise limit
+            where sign of b is considered
+            """
+            avals = list({_calc_limit_1(Fi, a, b) for Fi in F})
+            if len(avals) > 1:
+                raise ValueError(filldedent('''
+                The mapping between F(x) and f(u) did not
+                give a unique limit.'''))
+            return avals[0]
+
+        newlimits = []
+        for xab in self.limits:
+            sym = xab[0]
+            if sym == xvar:
+                if len(xab) == 3:
+                    a, b = xab[1:]
+                    a, b = _calc_limit(a, b), _calc_limit(b, a)
+                    if fuzzy_bool(a - b > 0):
+                        a, b = b, a
+                        newfunc = -newfunc
+                    newlimits.append((uvar, a, b))
+                elif len(xab) == 2:
+                    a = _calc_limit(xab[1], 1)
+                    newlimits.append((uvar, a))
+                else:
+                    newlimits.append(uvar)
+            else:
+                newlimits.append(xab)
+
+        return self.func(newfunc, *newlimits)
+
+    def doit(self, **hints):
+        """
+        Perform the integration using any hints given.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise, S
+        >>> from sympy.abc import x, t
+        >>> p = x**2 + Piecewise((0, x/t < 0), (1, True))
+        >>> p.integrate((t, S(4)/5, 1), (x, -1, 1))
+        1/3
+
+        See Also
+        ========
+
+        sympy.integrals.trigonometry.trigintegrate
+        sympy.integrals.heurisch.heurisch
+        sympy.integrals.rationaltools.ratint
+        as_sum : Approximate the integral using a sum
+        """
+        if not hints.get('integrals', True):
+            return self
+
+        deep = hints.get('deep', True)
+        meijerg = hints.get('meijerg', None)
+        conds = hints.get('conds', 'piecewise')
+        risch = hints.get('risch', None)
+        heurisch = hints.get('heurisch', None)
+        manual = hints.get('manual', None)
+        if len(list(filter(None, (manual, meijerg, risch, heurisch)))) > 1:
+            raise ValueError("At most one of manual, meijerg, risch, heurisch can be True")
+        elif manual:
+            meijerg = risch = heurisch = False
+        elif meijerg:
+            manual = risch = heurisch = False
+        elif risch:
+            manual = meijerg = heurisch = False
+        elif heurisch:
+            manual = meijerg = risch = False
+        eval_kwargs = {"meijerg": meijerg, "risch": risch, "manual": manual, "heurisch": heurisch,
+            "conds": conds}
+
+        if conds not in ('separate', 'piecewise', 'none'):
+            raise ValueError('conds must be one of "separate", "piecewise", '
+                             '"none", got: %s' % conds)
+
+        if risch and any(len(xab) > 1 for xab in self.limits):
+            raise ValueError('risch=True is only allowed for indefinite integrals.')
+
+        # check for the trivial zero
+        if self.is_zero:
+            return S.Zero
+
+        # hacks to handle integrals of
+        # nested summations
+        from sympy.concrete.summations import Sum
+        if isinstance(self.function, Sum):
+            if any(v in self.function.limits[0] for v in self.variables):
+                raise ValueError('Limit of the sum cannot be an integration variable.')
+            if any(l.is_infinite for l in self.function.limits[0][1:]):
+                return self
+            _i = self
+            _sum = self.function
+            return _sum.func(_i.func(_sum.function, *_i.limits).doit(), *_sum.limits).doit()
+
+        # now compute and check the function
+        function = self.function
+
+        # hack to use a consistent Heaviside(x, 1/2)
+        function = function.replace(
+            lambda x: isinstance(x, Heaviside) and x.args[1]*2 != 1,
+            lambda x: Heaviside(x.args[0]))
+
+        if deep:
+            function = function.doit(**hints)
+        if function.is_zero:
+            return S.Zero
+
+        # hacks to handle special cases
+        if isinstance(function, MatrixBase):
+            return function.applyfunc(
+                lambda f: self.func(f, *self.limits).doit(**hints))
+
+        if isinstance(function, FormalPowerSeries):
+            if len(self.limits) > 1:
+                raise NotImplementedError
+            xab = self.limits[0]
+            if len(xab) > 1:
+                return function.integrate(xab, **eval_kwargs)
+            else:
+                return function.integrate(xab[0], **eval_kwargs)
+
+        # There is no trivial answer and special handling
+        # is done so continue
+
+        # first make sure any definite limits have integration
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            if len(xab) != 3:
+                # it makes sense to just make
+                # all x real but in practice with the
+                # current state of integration...this
+                # doesn't work out well
+                # x = xab[0]
+                # if x not in reps and not x.is_real:
+                #     reps[x] = Dummy(real=True)
+                continue
+            x, a, b = xab
+            l = (a, b)
+            if all(i.is_nonnegative for i in l) and not x.is_nonnegative:
+                d = Dummy(positive=True)
+            elif all(i.is_nonpositive for i in l) and not x.is_nonpositive:
+                d = Dummy(negative=True)
+            elif all(i.is_real for i in l) and not x.is_real:
+                d = Dummy(real=True)
+            else:
+                d = None
+            if d:
+                reps[x] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            else:
+                did = did.xreplace(undo)
+            return did
+
+        # continue with existing assumptions
+        undone_limits = []
+        # ulj = free symbols of any undone limits' upper and lower limits
+        ulj = set()
+        for xab in self.limits:
+            # compute uli, the free symbols in the
+            # Upper and Lower limits of limit I
+            if len(xab) == 1:
+                uli = set(xab[:1])
+            elif len(xab) == 2:
+                uli = xab[1].free_symbols
+            elif len(xab) == 3:
+                uli = xab[1].free_symbols.union(xab[2].free_symbols)
+            # this integral can be done as long as there is no blocking
+            # limit that has been undone. An undone limit is blocking if
+            # it contains an integration variable that is in this limit's
+            # upper or lower free symbols or vice versa
+            if xab[0] in ulj or any(v[0] in uli for v in undone_limits):
+                undone_limits.append(xab)
+                ulj.update(uli)
+                function = self.func(*([function] + [xab]))
+                factored_function = function.factor()
+                if not isinstance(factored_function, Integral):
+                    function = factored_function
+                continue
+
+            if function.has(Abs, sign) and (
+                (len(xab) < 3 and all(x.is_extended_real for x in xab)) or
+                (len(xab) == 3 and all(x.is_extended_real and not x.is_infinite for
+                 x in xab[1:]))):
+                    # some improper integrals are better off with Abs
+                    xr = Dummy("xr", real=True)
+                    function = (function.xreplace({xab[0]: xr})
+                        .rewrite(Piecewise).xreplace({xr: xab[0]}))
+            elif function.has(Min, Max):
+                function = function.rewrite(Piecewise)
+            if (function.has(Piecewise) and
+                not isinstance(function, Piecewise)):
+                    function = piecewise_fold(function)
+            if isinstance(function, Piecewise):
+                if len(xab) == 1:
+                    antideriv = function._eval_integral(xab[0],
+                        **eval_kwargs)
+                else:
+                    antideriv = self._eval_integral(
+                        function, xab[0], **eval_kwargs)
+            else:
+                # There are a number of tradeoffs in using the
+                # Meijer G method. It can sometimes be a lot faster
+                # than other methods, and sometimes slower. And
+                # there are certain types of integrals for which it
+                # is more likely to work than others. These
+                # heuristics are incorporated in deciding what
+                # integration methods to try, in what order. See the
+                # integrate() docstring for details.
+                def try_meijerg(function, xab):
+                    ret = None
+                    if len(xab) == 3 and meijerg is not False:
+                        x, a, b = xab
+                        try:
+                            res = meijerint_definite(function, x, a, b)
+                        except NotImplementedError:
+                            _debug('NotImplementedError '
+                                'from meijerint_definite')
+                            res = None
+                        if res is not None:
+                            f, cond = res
+                            if conds == 'piecewise':
+                                u = self.func(function, (x, a, b))
+                                # if Piecewise modifies cond too
+                                # much it may not be recognized by
+                                # _condsimp pattern matching so just
+                                # turn off all evaluation
+                                return Piecewise((f, cond), (u, True),
+                                    evaluate=False)
+                            elif conds == 'separate':
+                                if len(self.limits) != 1:
+                                    raise ValueError(filldedent('''
+                                        conds=separate not supported in
+                                        multiple integrals'''))
+                                ret = f, cond
+                            else:
+                                ret = f
+                    return ret
+
+                meijerg1 = meijerg
+                if (meijerg is not False and
+                        len(xab) == 3 and xab[1].is_extended_real and xab[2].is_extended_real
+                        and not function.is_Poly and
+                        (xab[1].has(oo, -oo) or xab[2].has(oo, -oo))):
+                    ret = try_meijerg(function, xab)
+                    if ret is not None:
+                        function = ret
+                        continue
+                    meijerg1 = False
+                # If the special meijerg code did not succeed in
+                # finding a definite integral, then the code using
+                # meijerint_indefinite will not either (it might
+                # find an antiderivative, but the answer is likely
+                # to be nonsensical). Thus if we are requested to
+                # only use Meijer G-function methods, we give up at
+                # this stage. Otherwise we just disable G-function
+                # methods.
+                if meijerg1 is False and meijerg is True:
+                    antideriv = None
+                else:
+                    antideriv = self._eval_integral(
+                        function, xab[0], **eval_kwargs)
+                    if antideriv is None and meijerg is True:
+                        ret = try_meijerg(function, xab)
+                        if ret is not None:
+                            function = ret
+                            continue
+
+            final = hints.get('final', True)
+            # dotit may be iterated but floor terms making atan and acot
+            # continuous should only be added in the final round
+            if (final and not isinstance(antideriv, Integral) and
+                antideriv is not None):
+                for atan_term in antideriv.atoms(atan):
+                    atan_arg = atan_term.args[0]
+                    # Checking `atan_arg` to be linear combination of `tan` or `cot`
+                    for tan_part in atan_arg.atoms(tan):
+                        x1 = Dummy('x1')
+                        tan_exp1 = atan_arg.subs(tan_part, x1)
+                        # The coefficient of `tan` should be constant
+                        coeff = tan_exp1.diff(x1)
+                        if x1 not in coeff.free_symbols:
+                            a = tan_part.args[0]
+                            antideriv = antideriv.subs(atan_term, Add(atan_term,
+                                sign(coeff)*pi*floor((a-pi/2)/pi)))
+                    for cot_part in atan_arg.atoms(cot):
+                        x1 = Dummy('x1')
+                        cot_exp1 = atan_arg.subs(cot_part, x1)
+                        # The coefficient of `cot` should be constant
+                        coeff = cot_exp1.diff(x1)
+                        if x1 not in coeff.free_symbols:
+                            a = cot_part.args[0]
+                            antideriv = antideriv.subs(atan_term, Add(atan_term,
+                                sign(coeff)*pi*floor((a)/pi)))
+
+            if antideriv is None:
+                undone_limits.append(xab)
+                function = self.func(*([function] + [xab])).factor()
+                factored_function = function.factor()
+                if not isinstance(factored_function, Integral):
+                    function = factored_function
+                continue
+            else:
+                if len(xab) == 1:
+                    function = antideriv
+                else:
+                    if len(xab) == 3:
+                        x, a, b = xab
+                    elif len(xab) == 2:
+                        x, b = xab
+                        a = None
+                    else:
+                        raise NotImplementedError
+
+                    if deep:
+                        if isinstance(a, Basic):
+                            a = a.doit(**hints)
+                        if isinstance(b, Basic):
+                            b = b.doit(**hints)
+
+                    if antideriv.is_Poly:
+                        gens = list(antideriv.gens)
+                        gens.remove(x)
+
+                        antideriv = antideriv.as_expr()
+
+                        function = antideriv._eval_interval(x, a, b)
+                        function = Poly(function, *gens)
+                    else:
+                        def is_indef_int(g, x):
+                            return (isinstance(g, Integral) and
+                                    any(i == (x,) for i in g.limits))
+
+                        def eval_factored(f, x, a, b):
+                            # _eval_interval for integrals with
+                            # (constant) factors
+                            # a single indefinite integral is assumed
+                            args = []
+                            for g in Mul.make_args(f):
+                                if is_indef_int(g, x):
+                                    args.append(g._eval_interval(x, a, b))
+                                else:
+                                    args.append(g)
+                            return Mul(*args)
+
+                        integrals, others, piecewises = [], [], []
+                        for f in Add.make_args(antideriv):
+                            if any(is_indef_int(g, x)
+                                   for g in Mul.make_args(f)):
+                                integrals.append(f)
+                            elif any(isinstance(g, Piecewise)
+                                     for g in Mul.make_args(f)):
+                                piecewises.append(piecewise_fold(f))
+                            else:
+                                others.append(f)
+                        uneval = Add(*[eval_factored(f, x, a, b)
+                                       for f in integrals])
+                        try:
+                            evalued = Add(*others)._eval_interval(x, a, b)
+                            evalued_pw = piecewise_fold(Add(*piecewises))._eval_interval(x, a, b)
+                            function = uneval + evalued + evalued_pw
+                        except NotImplementedError:
+                            # This can happen if _eval_interval depends in a
+                            # complicated way on limits that cannot be computed
+                            undone_limits.append(xab)
+                            function = self.func(*([function] + [xab]))
+                            factored_function = function.factor()
+                            if not isinstance(factored_function, Integral):
+                                function = factored_function
+        return function
+
+    def _eval_derivative(self, sym):
+        """Evaluate the derivative of the current Integral object by
+        differentiating under the integral sign [1], using the Fundamental
+        Theorem of Calculus [2] when possible.
+
+        Explanation
+        ===========
+
+        Whenever an Integral is encountered that is equivalent to zero or
+        has an integrand that is independent of the variable of integration
+        those integrals are performed. All others are returned as Integral
+        instances which can be resolved with doit() (provided they are integrable).
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Differentiation_under_the_integral_sign
+        .. [2] https://en.wikipedia.org/wiki/Fundamental_theorem_of_calculus
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, y
+        >>> i = Integral(x + y, y, (y, 1, x))
+        >>> i.diff(x)
+        Integral(x + y, (y, x)) + Integral(1, y, (y, 1, x))
+        >>> i.doit().diff(x) == i.diff(x).doit()
+        True
+        >>> i.diff(y)
+        0
+
+        The previous must be true since there is no y in the evaluated integral:
+
+        >>> i.free_symbols
+        {x}
+        >>> i.doit()
+        2*x**3/3 - x/2 - 1/6
+
+        """
+
+        # differentiate under the integral sign; we do not
+        # check for regularity conditions (TODO), see issue 4215
+
+        # get limits and the function
+        f, limits = self.function, list(self.limits)
+
+        # the order matters if variables of integration appear in the limits
+        # so work our way in from the outside to the inside.
+        limit = limits.pop(-1)
+        if len(limit) == 3:
+            x, a, b = limit
+        elif len(limit) == 2:
+            x, b = limit
+            a = None
+        else:
+            a = b = None
+            x = limit[0]
+
+        if limits:  # f is the argument to an integral
+            f = self.func(f, *tuple(limits))
+
+        # assemble the pieces
+        def _do(f, ab):
+            dab_dsym = diff(ab, sym)
+            if not dab_dsym:
+                return S.Zero
+            if isinstance(f, Integral):
+                limits = [(x, x) if (len(l) == 1 and l[0] == x) else l
+                          for l in f.limits]
+                f = self.func(f.function, *limits)
+            return f.subs(x, ab)*dab_dsym
+
+        rv = S.Zero
+        if b is not None:
+            rv += _do(f, b)
+        if a is not None:
+            rv -= _do(f, a)
+        if len(limit) == 1 and sym == x:
+            # the dummy variable *is* also the real-world variable
+            arg = f
+            rv += arg
+        else:
+            # the dummy variable might match sym but it's
+            # only a dummy and the actual variable is determined
+            # by the limits, so mask off the variable of integration
+            # while differentiating
+            u = Dummy('u')
+            arg = f.subs(x, u).diff(sym).subs(u, x)
+            if arg:
+                rv += self.func(arg, (x, a, b))
+        return rv
+
+    def _eval_integral(self, f, x, meijerg=None, risch=None, manual=None,
+                       heurisch=None, conds='piecewise',final=None):
+        """
+        Calculate the anti-derivative to the function f(x).
+
+        Explanation
+        ===========
+
+        The following algorithms are applied (roughly in this order):
+
+        1. Simple heuristics (based on pattern matching and integral table):
+
+           - most frequently used functions (e.g. polynomials, products of
+             trig functions)
+
+        2. Integration of rational functions:
+
+           - A complete algorithm for integrating rational functions is
+             implemented (the Lazard-Rioboo-Trager algorithm).  The algorithm
+             also uses the partial fraction decomposition algorithm
+             implemented in apart() as a preprocessor to make this process
+             faster.  Note that the integral of a rational function is always
+             elementary, but in general, it may include a RootSum.
+
+        3. Full Risch algorithm:
+
+           - The Risch algorithm is a complete decision
+             procedure for integrating elementary functions, which means that
+             given any elementary function, it will either compute an
+             elementary antiderivative, or else prove that none exists.
+             Currently, part of transcendental case is implemented, meaning
+             elementary integrals containing exponentials, logarithms, and
+             (soon!) trigonometric functions can be computed.  The algebraic
+             case, e.g., functions containing roots, is much more difficult
+             and is not implemented yet.
+
+           - If the routine fails (because the integrand is not elementary, or
+             because a case is not implemented yet), it continues on to the
+             next algorithms below.  If the routine proves that the integrals
+             is nonelementary, it still moves on to the algorithms below,
+             because we might be able to find a closed-form solution in terms
+             of special functions.  If risch=True, however, it will stop here.
+
+        4. The Meijer G-Function algorithm:
+
+           - This algorithm works by first rewriting the integrand in terms of
+             very general Meijer G-Function (meijerg in SymPy), integrating
+             it, and then rewriting the result back, if possible.  This
+             algorithm is particularly powerful for definite integrals (which
+             is actually part of a different method of Integral), since it can
+             compute closed-form solutions of definite integrals even when no
+             closed-form indefinite integral exists.  But it also is capable
+             of computing many indefinite integrals as well.
+
+           - Another advantage of this method is that it can use some results
+             about the Meijer G-Function to give a result in terms of a
+             Piecewise expression, which allows to express conditionally
+             convergent integrals.
+
+           - Setting meijerg=True will cause integrate() to use only this
+             method.
+
+        5. The "manual integration" algorithm:
+
+           - This algorithm tries to mimic how a person would find an
+             antiderivative by hand, for example by looking for a
+             substitution or applying integration by parts. This algorithm
+             does not handle as many integrands but can return results in a
+             more familiar form.
+
+           - Sometimes this algorithm can evaluate parts of an integral; in
+             this case integrate() will try to evaluate the rest of the
+             integrand using the other methods here.
+
+           - Setting manual=True will cause integrate() to use only this
+             method.
+
+        6. The Heuristic Risch algorithm:
+
+           - This is a heuristic version of the Risch algorithm, meaning that
+             it is not deterministic.  This is tried as a last resort because
+             it can be very slow.  It is still used because not enough of the
+             full Risch algorithm is implemented, so that there are still some
+             integrals that can only be computed using this method.  The goal
+             is to implement enough of the Risch and Meijer G-function methods
+             so that this can be deleted.
+
+             Setting heurisch=True will cause integrate() to use only this
+             method. Set heurisch=False to not use it.
+
+        """
+
+        from sympy.integrals.risch import risch_integrate, NonElementaryIntegral
+        from sympy.integrals.manualintegrate import manualintegrate
+
+        if risch:
+            try:
+                return risch_integrate(f, x, conds=conds)
+            except NotImplementedError:
+                return None
+
+        if manual:
+            try:
+                result = manualintegrate(f, x)
+                if result is not None and result.func != Integral:
+                    return result
+            except (ValueError, PolynomialError):
+                pass
+
+        eval_kwargs = {"meijerg": meijerg, "risch": risch, "manual": manual,
+            "heurisch": heurisch, "conds": conds}
+
+        # if it is a poly(x) then let the polynomial integrate itself (fast)
+        #
+        # It is important to make this check first, otherwise the other code
+        # will return a SymPy expression instead of a Polynomial.
+        #
+        # see Polynomial for details.
+        if isinstance(f, Poly) and not (manual or meijerg or risch):
+            # Note: this is deprecated, but the deprecation warning is already
+            # issued in the Integral constructor.
+            return f.integrate(x)
+
+        # Piecewise antiderivatives need to call special integrate.
+        if isinstance(f, Piecewise):
+            return f.piecewise_integrate(x, **eval_kwargs)
+
+        # let's cut it short if `f` does not depend on `x`; if
+        # x is only a dummy, that will be handled below
+        if not f.has(x):
+            return f*x
+
+        # try to convert to poly(x) and then integrate if successful (fast)
+        poly = f.as_poly(x)
+        if poly is not None and not (manual or meijerg or risch):
+            return poly.integrate().as_expr()
+
+        if risch is not False:
+            try:
+                result, i = risch_integrate(f, x, separate_integral=True,
+                    conds=conds)
+            except NotImplementedError:
+                pass
+            else:
+                if i:
+                    # There was a nonelementary integral. Try integrating it.
+
+                    # if no part of the NonElementaryIntegral is integrated by
+                    # the Risch algorithm, then use the original function to
+                    # integrate, instead of re-written one
+                    if result == 0:
+                        return NonElementaryIntegral(f, x).doit(risch=False)
+                    else:
+                        return result + i.doit(risch=False)
+                else:
+                    return result
+
+        # since Integral(f=g1+g2+...) == Integral(g1) + Integral(g2) + ...
+        # we are going to handle Add terms separately,
+        # if `f` is not Add -- we only have one term
+
+        # Note that in general, this is a bad idea, because Integral(g1) +
+        # Integral(g2) might not be computable, even if Integral(g1 + g2) is.
+        # For example, Integral(x**x + x**x*log(x)).  But many heuristics only
+        # work term-wise.  So we compute this step last, after trying
+        # risch_integrate.  We also try risch_integrate again in this loop,
+        # because maybe the integral is a sum of an elementary part and a
+        # nonelementary part (like erf(x) + exp(x)).  risch_integrate() is
+        # quite fast, so this is acceptable.
+        from sympy.simplify.fu import sincos_to_sum
+        parts = []
+        args = Add.make_args(f)
+        for g in args:
+            coeff, g = g.as_independent(x)
+
+            # g(x) = const
+            if g is S.One and not meijerg:
+                parts.append(coeff*x)
+                continue
+
+            # g(x) = expr + O(x**n)
+            order_term = g.getO()
+
+            if order_term is not None:
+                h = self._eval_integral(g.removeO(), x, **eval_kwargs)
+
+                if h is not None:
+                    h_order_expr = self._eval_integral(order_term.expr, x, **eval_kwargs)
+
+                    if h_order_expr is not None:
+                        h_order_term = order_term.func(
+                            h_order_expr, *order_term.variables)
+                        parts.append(coeff*(h + h_order_term))
+                        continue
+
+                # NOTE: if there is O(x**n) and we fail to integrate then
+                # there is no point in trying other methods because they
+                # will fail, too.
+                return None
+
+            #               c
+            # g(x) = (a*x+b)
+            if g.is_Pow and not g.exp.has(x) and not meijerg:
+                a = Wild('a', exclude=[x])
+                b = Wild('b', exclude=[x])
+
+                M = g.base.match(a*x + b)
+
+                if M is not None:
+                    if g.exp == -1:
+                        h = log(g.base)
+                    elif conds != 'piecewise':
+                        h = g.base**(g.exp + 1) / (g.exp + 1)
+                    else:
+                        h1 = log(g.base)
+                        h2 = g.base**(g.exp + 1) / (g.exp + 1)
+                        h = Piecewise((h2, Ne(g.exp, -1)), (h1, True))
+
+                    parts.append(coeff * h / M[a])
+                    continue
+
+            #        poly(x)
+            # g(x) = -------
+            #        poly(x)
+            if g.is_rational_function(x) and not (manual or meijerg or risch):
+                parts.append(coeff * ratint(g, x))
+                continue
+
+            if not (manual or meijerg or risch):
+                # g(x) = Mul(trig)
+                h = trigintegrate(g, x, conds=conds)
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+                # g(x) has at least a DiracDelta term
+                h = deltaintegrate(g, x)
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+                from .singularityfunctions import singularityintegrate
+                # g(x) has at least a Singularity Function term
+                h = singularityintegrate(g, x)
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+                # Try risch again.
+                if risch is not False:
+                    try:
+                        h, i = risch_integrate(g, x,
+                            separate_integral=True, conds=conds)
+                    except NotImplementedError:
+                        h = None
+                    else:
+                        if i:
+                            h = h + i.doit(risch=False)
+
+                        parts.append(coeff*h)
+                        continue
+
+                # fall back to heurisch
+                if heurisch is not False:
+                    from sympy.integrals.heurisch import (heurisch as heurisch_,
+                                                          heurisch_wrapper)
+                    try:
+                        if conds == 'piecewise':
+                            h = heurisch_wrapper(g, x, hints=[])
+                        else:
+                            h = heurisch_(g, x, hints=[])
+                    except PolynomialError:
+                        # XXX: this exception means there is a bug in the
+                        # implementation of heuristic Risch integration
+                        # algorithm.
+                        h = None
+            else:
+                h = None
+
+            if meijerg is not False and h is None:
+                # rewrite using G functions
+                try:
+                    h = meijerint_indefinite(g, x)
+                except NotImplementedError:
+                    _debug('NotImplementedError from meijerint_definite')
+                if h is not None:
+                    parts.append(coeff * h)
+                    continue
+
+            if h is None and manual is not False:
+                try:
+                    result = manualintegrate(g, x)
+                    if result is not None and not isinstance(result, Integral):
+                        if result.has(Integral) and not manual:
+                            # Try to have other algorithms do the integrals
+                            # manualintegrate can't handle,
+                            # unless we were asked to use manual only.
+                            # Keep the rest of eval_kwargs in case another
+                            # method was set to False already
+                            new_eval_kwargs = eval_kwargs
+                            new_eval_kwargs["manual"] = False
+                            new_eval_kwargs["final"] = False
+                            result = result.func(*[
+                                arg.doit(**new_eval_kwargs) if
+                                arg.has(Integral) else arg
+                                for arg in result.args
+                            ]).expand(multinomial=False,
+                                      log=False,
+                                      power_exp=False,
+                                      power_base=False)
+                        if not result.has(Integral):
+                            parts.append(coeff * result)
+                            continue
+                except (ValueError, PolynomialError):
+                    # can't handle some SymPy expressions
+                    pass
+
+            # if we failed maybe it was because we had
+            # a product that could have been expanded,
+            # so let's try an expansion of the whole
+            # thing before giving up; we don't try this
+            # at the outset because there are things
+            # that cannot be solved unless they are
+            # NOT expanded e.g., x**x*(1+log(x)). There
+            # should probably be a checker somewhere in this
+            # routine to look for such cases and try to do
+            # collection on the expressions if they are already
+            # in an expanded form
+            if not h and len(args) == 1:
+                f = sincos_to_sum(f).expand(mul=True, deep=False)
+                if f.is_Add:
+                    # Note: risch will be identical on the expanded
+                    # expression, but maybe it will be able to pick out parts,
+                    # like x*(exp(x) + erf(x)).
+                    return self._eval_integral(f, x, **eval_kwargs)
+
+            if h is not None:
+                parts.append(coeff * h)
+            else:
+                return None
+
+        return Add(*parts)
+
+    def _eval_lseries(self, x, logx=None, cdir=0):
+        expr = self.as_dummy()
+        symb = x
+        for l in expr.limits:
+            if x in l[1:]:
+                symb = l[0]
+                break
+        for term in expr.function.lseries(symb, logx):
+            yield integrate(term, *expr.limits)
+
+    def _eval_nseries(self, x, n, logx=None, cdir=0):
+        symb = x
+        for l in self.limits:
+            if x in l[1:]:
+                symb = l[0]
+                break
+        terms, order = self.function.nseries(
+            x=symb, n=n, logx=logx).as_coeff_add(Order)
+        order = [o.subs(symb, x) for o in order]
+        return integrate(terms, *self.limits) + Add(*order)*x
+
+    def _eval_as_leading_term(self, x, logx=None, cdir=0):
+        series_gen = self.args[0].lseries(x)
+        for leading_term in series_gen:
+            if leading_term != 0:
+                break
+        return integrate(leading_term, *self.args[1:])
+
+    def _eval_simplify(self, **kwargs):
+        expr = factor_terms(self)
+        if isinstance(expr, Integral):
+            from sympy.simplify.simplify import simplify
+            return expr.func(*[simplify(i, **kwargs) for i in expr.args])
+        return expr.simplify(**kwargs)
+
+    def as_sum(self, n=None, method="midpoint", evaluate=True):
+        """
+        Approximates a definite integral by a sum.
+
+        Parameters
+        ==========
+
+        n :
+            The number of subintervals to use, optional.
+        method :
+            One of: 'left', 'right', 'midpoint', 'trapezoid'.
+        evaluate : bool
+            If False, returns an unevaluated Sum expression. The default
+            is True, evaluate the sum.
+
+        Notes
+        =====
+
+        These methods of approximate integration are described in [1].
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, sin, sqrt
+        >>> from sympy.abc import x, n
+        >>> e = Integral(sin(x), (x, 3, 7))
+        >>> e
+        Integral(sin(x), (x, 3, 7))
+
+        For demonstration purposes, this interval will only be split into 2
+        regions, bounded by [3, 5] and [5, 7].
+
+        The left-hand rule uses function evaluations at the left of each
+        interval:
+
+        >>> e.as_sum(2, 'left')
+        2*sin(5) + 2*sin(3)
+
+        The midpoint rule uses evaluations at the center of each interval:
+
+        >>> e.as_sum(2, 'midpoint')
+        2*sin(4) + 2*sin(6)
+
+        The right-hand rule uses function evaluations at the right of each
+        interval:
+
+        >>> e.as_sum(2, 'right')
+        2*sin(5) + 2*sin(7)
+
+        The trapezoid rule uses function evaluations on both sides of the
+        intervals. This is equivalent to taking the average of the left and
+        right hand rule results:
+
+        >>> s = e.as_sum(2, 'trapezoid')
+        >>> s
+        2*sin(5) + sin(3) + sin(7)
+        >>> (e.as_sum(2, 'left') + e.as_sum(2, 'right'))/2 == s
+        True
+
+        Here, the discontinuity at x = 0 can be avoided by using the
+        midpoint or right-hand method:
+
+        >>> e = Integral(1/sqrt(x), (x, 0, 1))
+        >>> e.as_sum(5).n(4)
+        1.730
+        >>> e.as_sum(10).n(4)
+        1.809
+        >>> e.doit().n(4)  # the actual value is 2
+        2.000
+
+        The left- or trapezoid method will encounter the discontinuity and
+        return infinity:
+
+        >>> e.as_sum(5, 'left')
+        zoo
+
+        The number of intervals can be symbolic. If omitted, a dummy symbol
+        will be used for it.
+
+        >>> e = Integral(x**2, (x, 0, 2))
+        >>> e.as_sum(n, 'right').expand()
+        8/3 + 4/n + 4/(3*n**2)
+
+        This shows that the midpoint rule is more accurate, as its error
+        term decays as the square of n:
+
+        >>> e.as_sum(method='midpoint').expand()
+        8/3 - 2/(3*_n**2)
+
+        A symbolic sum is returned with evaluate=False:
+
+        >>> e.as_sum(n, 'midpoint', evaluate=False)
+        2*Sum((2*_k/n - 1/n)**2, (_k, 1, n))/n
+
+        See Also
+        ========
+
+        Integral.doit : Perform the integration using any hints
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Riemann_sum#Riemann_summation_methods
+        """
+
+        from sympy.concrete.summations import Sum
+        limits = self.limits
+        if len(limits) > 1:
+            raise NotImplementedError(
+                "Multidimensional midpoint rule not implemented yet")
+        else:
+            limit = limits[0]
+            if (len(limit) != 3 or limit[1].is_finite is False or
+                limit[2].is_finite is False):
+                raise ValueError("Expecting a definite integral over "
+                                  "a finite interval.")
+        if n is None:
+            n = Dummy('n', integer=True, positive=True)
+        else:
+            n = sympify(n)
+        if (n.is_positive is False or n.is_integer is False or
+            n.is_finite is False):
+            raise ValueError("n must be a positive integer, got %s" % n)
+        x, a, b = limit
+        dx = (b - a)/n
+        k = Dummy('k', integer=True, positive=True)
+        f = self.function
+
+        if method == "left":
+            result = dx*Sum(f.subs(x, a + (k-1)*dx), (k, 1, n))
+        elif method == "right":
+            result = dx*Sum(f.subs(x, a + k*dx), (k, 1, n))
+        elif method == "midpoint":
+            result = dx*Sum(f.subs(x, a + k*dx - dx/2), (k, 1, n))
+        elif method == "trapezoid":
+            result = dx*((f.subs(x, a) + f.subs(x, b))/2 +
+                Sum(f.subs(x, a + k*dx), (k, 1, n - 1)))
+        else:
+            raise ValueError("Unknown method %s" % method)
+        return result.doit() if evaluate else result
+
+    def principal_value(self, **kwargs):
+        """
+        Compute the Cauchy Principal Value of the definite integral of a real function in the given interval
+        on the real axis.
+
+        Explanation
+        ===========
+
+        In mathematics, the Cauchy principal value, is a method for assigning values to certain improper
+        integrals which would otherwise be undefined.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, oo
+        >>> from sympy.abc import x
+        >>> Integral(x+1, (x, -oo, oo)).principal_value()
+        oo
+        >>> f = 1 / (x**3)
+        >>> Integral(f, (x, -oo, oo)).principal_value()
+        0
+        >>> Integral(f, (x, -10, 10)).principal_value()
+        0
+        >>> Integral(f, (x, -10, oo)).principal_value() + Integral(f, (x, -oo, 10)).principal_value()
+        0
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Cauchy_principal_value
+        .. [2] https://mathworld.wolfram.com/CauchyPrincipalValue.html
+        """
+        if len(self.limits) != 1 or len(list(self.limits[0])) != 3:
+            raise ValueError("You need to insert a variable, lower_limit, and upper_limit correctly to calculate "
+                             "cauchy's principal value")
+        x, a, b = self.limits[0]
+        if not (a.is_comparable and b.is_comparable and a <= b):
+            raise ValueError("The lower_limit must be smaller than or equal to the upper_limit to calculate "
+                             "cauchy's principal value. Also, a and b need to be comparable.")
+        if a == b:
+            return S.Zero
+
+        from sympy.calculus.singularities import singularities
+
+        r = Dummy('r')
+        f = self.function
+        singularities_list = [s for s in singularities(f, x) if s.is_comparable and a <= s <= b]
+        for i in singularities_list:
+            if i in (a, b):
+                raise ValueError(
+                    'The principal value is not defined in the given interval due to singularity at %d.' % (i))
+        F = integrate(f, x, **kwargs)
+        if F.has(Integral):
+            return self
+        if a is -oo and b is oo:
+            I = limit(F - F.subs(x, -x), x, oo)
+        else:
+            I = limit(F, x, b, '-') - limit(F, x, a, '+')
+        for s in singularities_list:
+            I += limit(((F.subs(x, s - r)) - F.subs(x, s + r)), r, 0, '+')
+        return I
+
+
+
+def integrate(*args, meijerg=None, conds='piecewise', risch=None, heurisch=None, manual=None, **kwargs):
+    """integrate(f, var, ...)
+
+    .. deprecated:: 1.6
+
+       Using ``integrate()`` with :class:`~.Poly` is deprecated. Use
+       :meth:`.Poly.integrate` instead. See :ref:`deprecated-integrate-poly`.
+
+    Explanation
+    ===========
+
+    Compute definite or indefinite integral of one or more variables
+    using Risch-Norman algorithm and table lookup. This procedure is
+    able to handle elementary algebraic and transcendental functions
+    and also a huge class of special functions, including Airy,
+    Bessel, Whittaker and Lambert.
+
+    var can be:
+
+    - a symbol                   -- indefinite integration
+    - a tuple (symbol, a)        -- indefinite integration with result
+                                    given with ``a`` replacing ``symbol``
+    - a tuple (symbol, a, b)     -- definite integration
+
+    Several variables can be specified, in which case the result is
+    multiple integration. (If var is omitted and the integrand is
+    univariate, the indefinite integral in that variable will be performed.)
+
+    Indefinite integrals are returned without terms that are independent
+    of the integration variables. (see examples)
+
+    Definite improper integrals often entail delicate convergence
+    conditions. Pass conds='piecewise', 'separate' or 'none' to have
+    these returned, respectively, as a Piecewise function, as a separate
+    result (i.e. result will be a tuple), or not at all (default is
+    'piecewise').
+
+    **Strategy**
+
+    SymPy uses various approaches to definite integration. One method is to
+    find an antiderivative for the integrand, and then use the fundamental
+    theorem of calculus. Various functions are implemented to integrate
+    polynomial, rational and trigonometric functions, and integrands
+    containing DiracDelta terms.
+
+    SymPy also implements the part of the Risch algorithm, which is a decision
+    procedure for integrating elementary functions, i.e., the algorithm can
+    either find an elementary antiderivative, or prove that one does not
+    exist.  There is also a (very successful, albeit somewhat slow) general
+    implementation of the heuristic Risch algorithm.  This algorithm will
+    eventually be phased out as more of the full Risch algorithm is
+    implemented. See the docstring of Integral._eval_integral() for more
+    details on computing the antiderivative using algebraic methods.
+
+    The option risch=True can be used to use only the (full) Risch algorithm.
+    This is useful if you want to know if an elementary function has an
+    elementary antiderivative.  If the indefinite Integral returned by this
+    function is an instance of NonElementaryIntegral, that means that the
+    Risch algorithm has proven that integral to be non-elementary.  Note that
+    by default, additional methods (such as the Meijer G method outlined
+    below) are tried on these integrals, as they may be expressible in terms
+    of special functions, so if you only care about elementary answers, use
+    risch=True.  Also note that an unevaluated Integral returned by this
+    function is not necessarily a NonElementaryIntegral, even with risch=True,
+    as it may just be an indication that the particular part of the Risch
+    algorithm needed to integrate that function is not yet implemented.
+
+    Another family of strategies comes from re-writing the integrand in
+    terms of so-called Meijer G-functions. Indefinite integrals of a
+    single G-function can always be computed, and the definite integral
+    of a product of two G-functions can be computed from zero to
+    infinity. Various strategies are implemented to rewrite integrands
+    as G-functions, and use this information to compute integrals (see
+    the ``meijerint`` module).
+
+    The option manual=True can be used to use only an algorithm that tries
+    to mimic integration by hand. This algorithm does not handle as many
+    integrands as the other algorithms implemented but may return results in
+    a more familiar form. The ``manualintegrate`` module has functions that
+    return the steps used (see the module docstring for more information).
+
+    In general, the algebraic methods work best for computing
+    antiderivatives of (possibly complicated) combinations of elementary
+    functions. The G-function methods work best for computing definite
+    integrals from zero to infinity of moderately complicated
+    combinations of special functions, or indefinite integrals of very
+    simple combinations of special functions.
+
+    The strategy employed by the integration code is as follows:
+
+    - If computing a definite integral, and both limits are real,
+      and at least one limit is +- oo, try the G-function method of
+      definite integration first.
+
+    - Try to find an antiderivative, using all available methods, ordered
+      by performance (that is try fastest method first, slowest last; in
+      particular polynomial integration is tried first, Meijer
+      G-functions second to last, and heuristic Risch last).
+
+    - If still not successful, try G-functions irrespective of the
+      limits.
+
+    The option meijerg=True, False, None can be used to, respectively:
+    always use G-function methods and no others, never use G-function
+    methods, or use all available methods (in order as described above).
+    It defaults to None.
+
+    Examples
+    ========
+
+    >>> from sympy import integrate, log, exp, oo
+    >>> from sympy.abc import a, x, y
+
+    >>> integrate(x*y, x)
+    x**2*y/2
+
+    >>> integrate(log(x), x)
+    x*log(x) - x
+
+    >>> integrate(log(x), (x, 1, a))
+    a*log(a) - a + 1
+
+    >>> integrate(x)
+    x**2/2
+
+    Terms that are independent of x are dropped by indefinite integration:
+
+    >>> from sympy import sqrt
+    >>> integrate(sqrt(1 + x), (x, 0, x))
+    2*(x + 1)**(3/2)/3 - 2/3
+    >>> integrate(sqrt(1 + x), x)
+    2*(x + 1)**(3/2)/3
+
+    >>> integrate(x*y)
+    Traceback (most recent call last):
+    ...
+    ValueError: specify integration variables to integrate x*y
+
+    Note that ``integrate(x)`` syntax is meant only for convenience
+    in interactive sessions and should be avoided in library code.
+
+    >>> integrate(x**a*exp(-x), (x, 0, oo)) # same as conds='piecewise'
+    Piecewise((gamma(a + 1), re(a) > -1),
+        (Integral(x**a*exp(-x), (x, 0, oo)), True))
+
+    >>> integrate(x**a*exp(-x), (x, 0, oo), conds='none')
+    gamma(a + 1)
+
+    >>> integrate(x**a*exp(-x), (x, 0, oo), conds='separate')
+    (gamma(a + 1), re(a) > -1)
+
+    See Also
+    ========
+
+    Integral, Integral.doit
+
+    """
+    doit_flags = {
+        'deep': False,
+        'meijerg': meijerg,
+        'conds': conds,
+        'risch': risch,
+        'heurisch': heurisch,
+        'manual': manual
+        }
+    integral = Integral(*args, **kwargs)
+
+    if isinstance(integral, Integral):
+        return integral.doit(**doit_flags)
+    else:
+        new_args = [a.doit(**doit_flags) if isinstance(a, Integral) else a
+            for a in integral.args]
+        return integral.func(*new_args)
+
+
+def line_integrate(field, curve, vars):
+    """line_integrate(field, Curve, variables)
+
+    Compute the line integral.
+
+    Examples
+    ========
+
+    >>> from sympy import Curve, line_integrate, E, ln
+    >>> from sympy.abc import x, y, t
+    >>> C = Curve([E**t + 1, E**t - 1], (t, 0, ln(2)))
+    >>> line_integrate(x + y, C, [x, y])
+    3*sqrt(2)
+
+    See Also
+    ========
+
+    sympy.integrals.integrals.integrate, Integral
+    """
+    from sympy.geometry import Curve
+    F = sympify(field)
+    if not F:
+        raise ValueError(
+            "Expecting function specifying field as first argument.")
+    if not isinstance(curve, Curve):
+        raise ValueError("Expecting Curve entity as second argument.")
+    if not is_sequence(vars):
+        raise ValueError("Expecting ordered iterable for variables.")
+    if len(curve.functions) != len(vars):
+        raise ValueError("Field variable size does not match curve dimension.")
+
+    if curve.parameter in vars:
+        raise ValueError("Curve parameter clashes with field parameters.")
+
+    # Calculate derivatives for line parameter functions
+    # F(r) -> F(r(t)) and finally F(r(t)*r'(t))
+    Ft = F
+    dldt = 0
+    for i, var in enumerate(vars):
+        _f = curve.functions[i]
+        _dn = diff(_f, curve.parameter)
+        # ...arc length
+        dldt = dldt + (_dn * _dn)
+        Ft = Ft.subs(var, _f)
+    Ft = Ft * sqrt(dldt)
+
+    integral = Integral(Ft, curve.limits).doit(deep=False)
+    return integral
+
+
+### Property function dispatching ###
+
+@shape.register(Integral)
+def _(expr):
+    return shape(expr.function)
+
+# Delayed imports
+from .deltafunctions import deltaintegrate
+from .meijerint import meijerint_definite, meijerint_indefinite, _debug
+from .trigonometry import trigintegrate

parrot/lib/python3.10/site-packages/sympy/integrals/meijerint.py

@@ -0,0 +1,2191 @@
+"""
+Integrate functions by rewriting them as Meijer G-functions.
+
+There are three user-visible functions that can be used by other parts of the
+sympy library to solve various integration problems:
+
+- meijerint_indefinite
+- meijerint_definite
+- meijerint_inversion
+
+They can be used to compute, respectively, indefinite integrals, definite
+integrals over intervals of the real line, and inverse laplace-type integrals
+(from c-I*oo to c+I*oo). See the respective docstrings for details.
+
+The main references for this are:
+
+[L] Luke, Y. L. (1969), The Special Functions and Their Approximations,
+    Volume 1
+
+[R] Kelly B. Roach.  Meijer G Function Representations.
+    In: Proceedings of the 1997 International Symposium on Symbolic and
+    Algebraic Computation, pages 205-211, New York, 1997. ACM.
+
+[P] A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+    Integrals and Series: More Special Functions, Vol. 3,.
+    Gordon and Breach Science Publisher
+"""
+
+from __future__ import annotations
+import itertools
+
+from sympy import SYMPY_DEBUG
+from sympy.core import S, Expr
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.cache import cacheit
+from sympy.core.containers import Tuple
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import (expand, expand_mul, expand_power_base,
+                                 expand_trig, Function)
+from sympy.core.mul import Mul
+from sympy.core.intfunc import ilcm
+from sympy.core.numbers import Rational, pi
+from sympy.core.relational import Eq, Ne, _canonical_coeff
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import Dummy, symbols, Wild, Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (re, im, arg, Abs, sign,
+        unpolarify, polarify, polar_lift, principal_branch, unbranched_argument,
+        periodic_argument)
+from sympy.functions.elementary.exponential import exp, exp_polar, log
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.hyperbolic import (cosh, sinh,
+        _rewrite_hyperbolics_as_exp, HyperbolicFunction)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise, piecewise_fold
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc,
+        TrigonometricFunction)
+from sympy.functions.special.bessel import besselj, bessely, besseli, besselk
+from sympy.functions.special.delta_functions import DiracDelta, Heaviside
+from sympy.functions.special.elliptic_integrals import elliptic_k, elliptic_e
+from sympy.functions.special.error_functions import (erf, erfc, erfi, Ei,
+        expint, Si, Ci, Shi, Chi, fresnels, fresnelc)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper, meijerg
+from sympy.functions.special.singularity_functions import SingularityFunction
+from .integrals import Integral
+from sympy.logic.boolalg import And, Or, BooleanAtom, Not, BooleanFunction
+from sympy.polys import cancel, factor
+from sympy.utilities.iterables import multiset_partitions
+from sympy.utilities.misc import debug as _debug
+from sympy.utilities.misc import debugf as _debugf
+
+# keep this at top for easy reference
+z = Dummy('z')
+
+
+def _has(res, *f):
+    # return True if res has f; in the case of Piecewise
+    # only return True if *all* pieces have f
+    res = piecewise_fold(res)
+    if getattr(res, 'is_Piecewise', False):
+        return all(_has(i, *f) for i in res.args)
+    return res.has(*f)
+
+
+def _create_lookup_table(table):
+    """ Add formulae for the function -> meijerg lookup table. """
+    def wild(n):
+        return Wild(n, exclude=[z])
+    p, q, a, b, c = list(map(wild, 'pqabc'))
+    n = Wild('n', properties=[lambda x: x.is_Integer and x > 0])
+    t = p*z**q
+
+    def add(formula, an, ap, bm, bq, arg=t, fac=S.One, cond=True, hint=True):
+        table.setdefault(_mytype(formula, z), []).append((formula,
+                                     [(fac, meijerg(an, ap, bm, bq, arg))], cond, hint))
+
+    def addi(formula, inst, cond, hint=True):
+        table.setdefault(
+            _mytype(formula, z), []).append((formula, inst, cond, hint))
+
+    def constant(a):
+        return [(a, meijerg([1], [], [], [0], z)),
+                (a, meijerg([], [1], [0], [], z))]
+    table[()] = [(a, constant(a), True, True)]
+
+    # [P], Section 8.
+    class IsNonPositiveInteger(Function):
+
+        @classmethod
+        def eval(cls, arg):
+            arg = unpolarify(arg)
+            if arg.is_Integer is True:
+                return arg <= 0
+
+    # Section 8.4.2
+    # TODO this needs more polar_lift (c/f entry for exp)
+    add(Heaviside(t - b)*(t - b)**(a - 1), [a], [], [], [0], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add(Heaviside(b - t)*(b - t)**(a - 1), [], [a], [0], [], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add(Heaviside(z - (b/p)**(1/q))*(t - b)**(a - 1), [a], [], [], [0], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add(Heaviside((b/p)**(1/q) - z)*(b - t)**(a - 1), [], [a], [0], [], t/b,
+        gamma(a)*b**(a - 1), And(b > 0))
+    add((b + t)**(-a), [1 - a], [], [0], [], t/b, b**(-a)/gamma(a),
+        hint=Not(IsNonPositiveInteger(a)))
+    add(Abs(b - t)**(-a), [1 - a], [(1 - a)/2], [0], [(1 - a)/2], t/b,
+        2*sin(pi*a/2)*gamma(1 - a)*Abs(b)**(-a), re(a) < 1)
+    add((t**a - b**a)/(t - b), [0, a], [], [0, a], [], t/b,
+        b**(a - 1)*sin(a*pi)/pi)
+
+    # 12
+    def A1(r, sign, nu):
+        return pi**Rational(-1, 2)*(-sign*nu/2)**(1 - 2*r)
+
+    def tmpadd(r, sgn):
+        # XXX the a**2 is bad for matching
+        add((sqrt(a**2 + t) + sgn*a)**b/(a**2 + t)**r,
+            [(1 + b)/2, 1 - 2*r + b/2], [],
+            [(b - sgn*b)/2], [(b + sgn*b)/2], t/a**2,
+            a**(b - 2*r)*A1(r, sgn, b))
+    tmpadd(0, 1)
+    tmpadd(0, -1)
+    tmpadd(S.Half, 1)
+    tmpadd(S.Half, -1)
+
+    # 13
+    def tmpadd(r, sgn):
+        add((sqrt(a + p*z**q) + sgn*sqrt(p)*z**(q/2))**b/(a + p*z**q)**r,
+            [1 - r + sgn*b/2], [1 - r - sgn*b/2], [0, S.Half], [],
+            p*z**q/a, a**(b/2 - r)*A1(r, sgn, b))
+    tmpadd(0, 1)
+    tmpadd(0, -1)
+    tmpadd(S.Half, 1)
+    tmpadd(S.Half, -1)
+    # (those after look obscure)
+
+    # Section 8.4.3
+    add(exp(polar_lift(-1)*t), [], [], [0], [])
+
+    # TODO can do sin^n, sinh^n by expansion ... where?
+    # 8.4.4 (hyperbolic functions)
+    add(sinh(t), [], [1], [S.Half], [1, 0], t**2/4, pi**Rational(3, 2))
+    add(cosh(t), [], [S.Half], [0], [S.Half, S.Half], t**2/4, pi**Rational(3, 2))
+
+    # Section 8.4.5
+    # TODO can do t + a. but can also do by expansion... (XXX not really)
+    add(sin(t), [], [], [S.Half], [0], t**2/4, sqrt(pi))
+    add(cos(t), [], [], [0], [S.Half], t**2/4, sqrt(pi))
+
+    # Section 8.4.6 (sinc function)
+    add(sinc(t), [], [], [0], [Rational(-1, 2)], t**2/4, sqrt(pi)/2)
+
+    # Section 8.5.5
+    def make_log1(subs):
+        N = subs[n]
+        return [(S.NegativeOne**N*factorial(N),
+                 meijerg([], [1]*(N + 1), [0]*(N + 1), [], t))]
+
+    def make_log2(subs):
+        N = subs[n]
+        return [(factorial(N),
+                 meijerg([1]*(N + 1), [], [], [0]*(N + 1), t))]
+    # TODO these only hold for positive p, and can be made more general
+    #      but who uses log(x)*Heaviside(a-x) anyway ...
+    # TODO also it would be nice to derive them recursively ...
+    addi(log(t)**n*Heaviside(1 - t), make_log1, True)
+    addi(log(t)**n*Heaviside(t - 1), make_log2, True)
+
+    def make_log3(subs):
+        return make_log1(subs) + make_log2(subs)
+    addi(log(t)**n, make_log3, True)
+    addi(log(t + a),
+         constant(log(a)) + [(S.One, meijerg([1, 1], [], [1], [0], t/a))],
+         True)
+    addi(log(Abs(t - a)), constant(log(Abs(a))) +
+         [(pi, meijerg([1, 1], [S.Half], [1], [0, S.Half], t/a))],
+         True)
+    # TODO log(x)/(x+a) and log(x)/(x-1) can also be done. should they
+    #      be derivable?
+    # TODO further formulae in this section seem obscure
+
+    # Sections 8.4.9-10
+    # TODO
+
+    # Section 8.4.11
+    addi(Ei(t),
+         constant(-S.ImaginaryUnit*pi) + [(S.NegativeOne, meijerg([], [1], [0, 0], [],
+                  t*polar_lift(-1)))],
+         True)
+
+    # Section 8.4.12
+    add(Si(t), [1], [], [S.Half], [0, 0], t**2/4, sqrt(pi)/2)
+    add(Ci(t), [], [1], [0, 0], [S.Half], t**2/4, -sqrt(pi)/2)
+
+    # Section 8.4.13
+    add(Shi(t), [S.Half], [], [0], [Rational(-1, 2), Rational(-1, 2)], polar_lift(-1)*t**2/4,
+        t*sqrt(pi)/4)
+    add(Chi(t), [], [S.Half, 1], [0, 0], [S.Half, S.Half], t**2/4, -
+        pi**S('3/2')/2)
+
+    # generalized exponential integral
+    add(expint(a, t), [], [a], [a - 1, 0], [], t)
+
+    # Section 8.4.14
+    add(erf(t), [1], [], [S.Half], [0], t**2, 1/sqrt(pi))
+    # TODO exp(-x)*erf(I*x) does not work
+    add(erfc(t), [], [1], [0, S.Half], [], t**2, 1/sqrt(pi))
+    # This formula for erfi(z) yields a wrong(?) minus sign
+    #add(erfi(t), [1], [], [S.Half], [0], -t**2, I/sqrt(pi))
+    add(erfi(t), [S.Half], [], [0], [Rational(-1, 2)], -t**2, t/sqrt(pi))
+
+    # Fresnel Integrals
+    add(fresnels(t), [1], [], [Rational(3, 4)], [0, Rational(1, 4)], pi**2*t**4/16, S.Half)
+    add(fresnelc(t), [1], [], [Rational(1, 4)], [0, Rational(3, 4)], pi**2*t**4/16, S.Half)
+
+    ##### bessel-type functions #####
+    # Section 8.4.19
+    add(besselj(a, t), [], [], [a/2], [-a/2], t**2/4)
+
+    # all of the following are derivable
+    #add(sin(t)*besselj(a, t), [Rational(1, 4), Rational(3, 4)], [], [(1+a)/2],
+    #    [-a/2, a/2, (1-a)/2], t**2, 1/sqrt(2))
+    #add(cos(t)*besselj(a, t), [Rational(1, 4), Rational(3, 4)], [], [a/2],
+    #    [-a/2, (1+a)/2, (1-a)/2], t**2, 1/sqrt(2))
+    #add(besselj(a, t)**2, [S.Half], [], [a], [-a, 0], t**2, 1/sqrt(pi))
+    #add(besselj(a, t)*besselj(b, t), [0, S.Half], [], [(a + b)/2],
+    #    [-(a+b)/2, (a - b)/2, (b - a)/2], t**2, 1/sqrt(pi))
+
+    # Section 8.4.20
+    add(bessely(a, t), [], [-(a + 1)/2], [a/2, -a/2], [-(a + 1)/2], t**2/4)
+
+    # TODO all of the following should be derivable
+    #add(sin(t)*bessely(a, t), [Rational(1, 4), Rational(3, 4)], [(1 - a - 1)/2],
+    #    [(1 + a)/2, (1 - a)/2], [(1 - a - 1)/2, (1 - 1 - a)/2, (1 - 1 + a)/2],
+    #    t**2, 1/sqrt(2))
+    #add(cos(t)*bessely(a, t), [Rational(1, 4), Rational(3, 4)], [(0 - a - 1)/2],
+    #    [(0 + a)/2, (0 - a)/2], [(0 - a - 1)/2, (1 - 0 - a)/2, (1 - 0 + a)/2],
+    #    t**2, 1/sqrt(2))
+    #add(besselj(a, t)*bessely(b, t), [0, S.Half], [(a - b - 1)/2],
+    #    [(a + b)/2, (a - b)/2], [(a - b - 1)/2, -(a + b)/2, (b - a)/2],
+    #    t**2, 1/sqrt(pi))
+    #addi(bessely(a, t)**2,
+    #     [(2/sqrt(pi), meijerg([], [S.Half, S.Half - a], [0, a, -a],
+    #                           [S.Half - a], t**2)),
+    #      (1/sqrt(pi), meijerg([S.Half], [], [a], [-a, 0], t**2))],
+    #     True)
+    #addi(bessely(a, t)*bessely(b, t),
+    #     [(2/sqrt(pi), meijerg([], [0, S.Half, (1 - a - b)/2],
+    #                           [(a + b)/2, (a - b)/2, (b - a)/2, -(a + b)/2],
+    #                           [(1 - a - b)/2], t**2)),
+    #      (1/sqrt(pi), meijerg([0, S.Half], [], [(a + b)/2],
+    #                           [-(a + b)/2, (a - b)/2, (b - a)/2], t**2))],
+    #     True)
+
+    # Section 8.4.21 ?
+    # Section 8.4.22
+    add(besseli(a, t), [], [(1 + a)/2], [a/2], [-a/2, (1 + a)/2], t**2/4, pi)
+    # TODO many more formulas. should all be derivable
+
+    # Section 8.4.23
+    add(besselk(a, t), [], [], [a/2, -a/2], [], t**2/4, S.Half)
+    # TODO many more formulas. should all be derivable
+
+    # Complete elliptic integrals K(z) and E(z)
+    add(elliptic_k(t), [S.Half, S.Half], [], [0], [0], -t, S.Half)
+    add(elliptic_e(t), [S.Half, 3*S.Half], [], [0], [0], -t, Rational(-1, 2)/2)
+
+
+####################################################################
+# First some helper functions.
+####################################################################
+
+from sympy.utilities.timeutils import timethis
+timeit = timethis('meijerg')
+
+
+def _mytype(f: Basic, x: Symbol) -> tuple[type[Basic], ...]:
+    """ Create a hashable entity describing the type of f. """
+    def key(x: type[Basic]) -> tuple[int, int, str]:
+        return x.class_key()
+
+    if x not in f.free_symbols:
+        return ()
+    elif f.is_Function:
+        return type(f),
+    return tuple(sorted((t for a in f.args for t in _mytype(a, x)), key=key))
+
+
+class _CoeffExpValueError(ValueError):
+    """
+    Exception raised by _get_coeff_exp, for internal use only.
+    """
+    pass
+
+
+def _get_coeff_exp(expr, x):
+    """
+    When expr is known to be of the form c*x**b, with c and/or b possibly 1,
+    return c, b.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, a, b
+    >>> from sympy.integrals.meijerint import _get_coeff_exp
+    >>> _get_coeff_exp(a*x**b, x)
+    (a, b)
+    >>> _get_coeff_exp(x, x)
+    (1, 1)
+    >>> _get_coeff_exp(2*x, x)
+    (2, 1)
+    >>> _get_coeff_exp(x**3, x)
+    (1, 3)
+    """
+    from sympy.simplify import powsimp
+    (c, m) = expand_power_base(powsimp(expr)).as_coeff_mul(x)
+    if not m:
+        return c, S.Zero
+    [m] = m
+    if m.is_Pow:
+        if m.base != x:
+            raise _CoeffExpValueError('expr not of form a*x**b')
+        return c, m.exp
+    elif m == x:
+        return c, S.One
+    else:
+        raise _CoeffExpValueError('expr not of form a*x**b: %s' % expr)
+
+
+def _exponents(expr, x):
+    """
+    Find the exponents of ``x`` (not including zero) in ``expr``.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _exponents
+    >>> from sympy.abc import x, y
+    >>> from sympy import sin
+    >>> _exponents(x, x)
+    {1}
+    >>> _exponents(x**2, x)
+    {2}
+    >>> _exponents(x**2 + x, x)
+    {1, 2}
+    >>> _exponents(x**3*sin(x + x**y) + 1/x, x)
+    {-1, 1, 3, y}
+    """
+    def _exponents_(expr, x, res):
+        if expr == x:
+            res.update([1])
+            return
+        if expr.is_Pow and expr.base == x:
+            res.update([expr.exp])
+            return
+        for argument in expr.args:
+            _exponents_(argument, x, res)
+    res = set()
+    _exponents_(expr, x, res)
+    return res
+
+
+def _functions(expr, x):
+    """ Find the types of functions in expr, to estimate the complexity. """
+    return {e.func for e in expr.atoms(Function) if x in e.free_symbols}
+
+
+def _find_splitting_points(expr, x):
+    """
+    Find numbers a such that a linear substitution x -> x + a would
+    (hopefully) simplify expr.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _find_splitting_points as fsp
+    >>> from sympy import sin
+    >>> from sympy.abc import x
+    >>> fsp(x, x)
+    {0}
+    >>> fsp((x-1)**3, x)
+    {1}
+    >>> fsp(sin(x+3)*x, x)
+    {-3, 0}
+    """
+    p, q = [Wild(n, exclude=[x]) for n in 'pq']
+
+    def compute_innermost(expr, res):
+        if not isinstance(expr, Expr):
+            return
+        m = expr.match(p*x + q)
+        if m and m[p] != 0:
+            res.add(-m[q]/m[p])
+            return
+        if expr.is_Atom:
+            return
+        for argument in expr.args:
+            compute_innermost(argument, res)
+    innermost = set()
+    compute_innermost(expr, innermost)
+    return innermost
+
+
+def _split_mul(f, x):
+    """
+    Split expression ``f`` into fac, po, g, where fac is a constant factor,
+    po = x**s for some s independent of s, and g is "the rest".
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _split_mul
+    >>> from sympy import sin
+    >>> from sympy.abc import s, x
+    >>> _split_mul((3*x)**s*sin(x**2)*x, x)
+    (3**s, x*x**s, sin(x**2))
+    """
+    fac = S.One
+    po = S.One
+    g = S.One
+    f = expand_power_base(f)
+
+    args = Mul.make_args(f)
+    for a in args:
+        if a == x:
+            po *= x
+        elif x not in a.free_symbols:
+            fac *= a
+        else:
+            if a.is_Pow and x not in a.exp.free_symbols:
+                c, t = a.base.as_coeff_mul(x)
+                if t != (x,):
+                    c, t = expand_mul(a.base).as_coeff_mul(x)
+                if t == (x,):
+                    po *= x**a.exp
+                    fac *= unpolarify(polarify(c**a.exp, subs=False))
+                    continue
+            g *= a
+
+    return fac, po, g
+
+
+def _mul_args(f):
+    """
+    Return a list ``L`` such that ``Mul(*L) == f``.
+
+    If ``f`` is not a ``Mul`` or ``Pow``, ``L=[f]``.
+    If ``f=g**n`` for an integer ``n``, ``L=[g]*n``.
+    If ``f`` is a ``Mul``, ``L`` comes from applying ``_mul_args`` to all factors of ``f``.
+    """
+    args = Mul.make_args(f)
+    gs = []
+    for g in args:
+        if g.is_Pow and g.exp.is_Integer:
+            n = g.exp
+            base = g.base
+            if n < 0:
+                n = -n
+                base = 1/base
+            gs += [base]*n
+        else:
+            gs.append(g)
+    return gs
+
+
+def _mul_as_two_parts(f):
+    """
+    Find all the ways to split ``f`` into a product of two terms.
+    Return None on failure.
+
+    Explanation
+    ===========
+
+    Although the order is canonical from multiset_partitions, this is
+    not necessarily the best order to process the terms. For example,
+    if the case of len(gs) == 2 is removed and multiset is allowed to
+    sort the terms, some tests fail.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _mul_as_two_parts
+    >>> from sympy import sin, exp, ordered
+    >>> from sympy.abc import x
+    >>> list(ordered(_mul_as_two_parts(x*sin(x)*exp(x))))
+    [(x, exp(x)*sin(x)), (x*exp(x), sin(x)), (x*sin(x), exp(x))]
+    """
+
+    gs = _mul_args(f)
+    if len(gs) < 2:
+        return None
+    if len(gs) == 2:
+        return [tuple(gs)]
+    return [(Mul(*x), Mul(*y)) for (x, y) in multiset_partitions(gs, 2)]
+
+
+def _inflate_g(g, n):
+    """ Return C, h such that h is a G function of argument z**n and
+        g = C*h. """
+    # TODO should this be a method of meijerg?
+    # See: [L, page 150, equation (5)]
+    def inflate(params, n):
+        """ (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) """
+        return [(a + i)/n for a, i in itertools.product(params, range(n))]
+    v = S(len(g.ap) - len(g.bq))
+    C = n**(1 + g.nu + v/2)
+    C /= (2*pi)**((n - 1)*g.delta)
+    return C, meijerg(inflate(g.an, n), inflate(g.aother, n),
+                      inflate(g.bm, n), inflate(g.bother, n),
+                      g.argument**n * n**(n*v))
+
+
+def _flip_g(g):
+    """ Turn the G function into one of inverse argument
+        (i.e. G(1/x) -> G'(x)) """
+    # See [L], section 5.2
+    def tr(l):
+        return [1 - a for a in l]
+    return meijerg(tr(g.bm), tr(g.bother), tr(g.an), tr(g.aother), 1/g.argument)
+
+
+def _inflate_fox_h(g, a):
+    r"""
+    Let d denote the integrand in the definition of the G function ``g``.
+    Consider the function H which is defined in the same way, but with
+    integrand d/Gamma(a*s) (contour conventions as usual).
+
+    If ``a`` is rational, the function H can be written as C*G, for a constant C
+    and a G-function G.
+
+    This function returns C, G.
+    """
+    if a < 0:
+        return _inflate_fox_h(_flip_g(g), -a)
+    p = S(a.p)
+    q = S(a.q)
+    # We use the substitution s->qs, i.e. inflate g by q. We are left with an
+    # extra factor of Gamma(p*s), for which we use Gauss' multiplication
+    # theorem.
+    D, g = _inflate_g(g, q)
+    z = g.argument
+    D /= (2*pi)**((1 - p)/2)*p**Rational(-1, 2)
+    z /= p**p
+    bs = [(n + 1)/p for n in range(p)]
+    return D, meijerg(g.an, g.aother, g.bm, list(g.bother) + bs, z)
+
+_dummies: dict[tuple[str, str], Dummy]  = {}
+
+
+def _dummy(name, token, expr, **kwargs):
+    """
+    Return a dummy. This will return the same dummy if the same token+name is
+    requested more than once, and it is not already in expr.
+    This is for being cache-friendly.
+    """
+    d = _dummy_(name, token, **kwargs)
+    if d in expr.free_symbols:
+        return Dummy(name, **kwargs)
+    return d
+
+
+def _dummy_(name, token, **kwargs):
+    """
+    Return a dummy associated to name and token. Same effect as declaring
+    it globally.
+    """
+    global _dummies
+    if not (name, token) in _dummies:
+        _dummies[(name, token)] = Dummy(name, **kwargs)
+    return _dummies[(name, token)]
+
+
+def _is_analytic(f, x):
+    """ Check if f(x), when expressed using G functions on the positive reals,
+        will in fact agree with the G functions almost everywhere """
+    return not any(x in expr.free_symbols for expr in f.atoms(Heaviside, Abs))
+
+
+def _condsimp(cond, first=True):
+    """
+    Do naive simplifications on ``cond``.
+
+    Explanation
+    ===========
+
+    Note that this routine is completely ad-hoc, simplification rules being
+    added as need arises rather than following any logical pattern.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _condsimp as simp
+    >>> from sympy import Or, Eq
+    >>> from sympy.abc import x, y
+    >>> simp(Or(x < y, Eq(x, y)))
+    x <= y
+    """
+    if first:
+        cond = cond.replace(lambda _: _.is_Relational, _canonical_coeff)
+        first = False
+    if not isinstance(cond, BooleanFunction):
+        return cond
+    p, q, r = symbols('p q r', cls=Wild)
+    # transforms tests use 0, 4, 5 and 11-14
+    # meijer tests use 0, 2, 11, 14
+    # joint_rv uses 6, 7
+    rules = [
+        (Or(p < q, Eq(p, q)), p <= q),  # 0
+        # The next two obviously are instances of a general pattern, but it is
+        # easier to spell out the few cases we care about.
+        (And(Abs(arg(p)) <= pi, Abs(arg(p) - 2*pi) <= pi),
+         Eq(arg(p) - pi, 0)),  # 1
+        (And(Abs(2*arg(p) + pi) <= pi, Abs(2*arg(p) - pi) <= pi),
+         Eq(arg(p), 0)), # 2
+        (And(Abs(2*arg(p) + pi) < pi, Abs(2*arg(p) - pi) <= pi),
+         S.false),  # 3
+        (And(Abs(arg(p) - pi/2) <= pi/2, Abs(arg(p) + pi/2) <= pi/2),
+         Eq(arg(p), 0)),  # 4
+        (And(Abs(arg(p) - pi/2) <= pi/2, Abs(arg(p) + pi/2) < pi/2),
+         S.false),  # 5
+        (And(Abs(arg(p**2/2 + 1)) < pi, Ne(Abs(arg(p**2/2 + 1)), pi)),
+         S.true),  # 6
+        (Or(Abs(arg(p**2/2 + 1)) < pi, Ne(1/(p**2/2 + 1), 0)),
+         S.true),  # 7
+        (And(Abs(unbranched_argument(p)) <= pi,
+           Abs(unbranched_argument(exp_polar(-2*pi*S.ImaginaryUnit)*p)) <= pi),
+         Eq(unbranched_argument(exp_polar(-S.ImaginaryUnit*pi)*p), 0)),  # 8
+        (And(Abs(unbranched_argument(p)) <= pi/2,
+           Abs(unbranched_argument(exp_polar(-pi*S.ImaginaryUnit)*p)) <= pi/2),
+         Eq(unbranched_argument(exp_polar(-S.ImaginaryUnit*pi/2)*p), 0)),  # 9
+        (Or(p <= q, And(p < q, r)), p <= q),  # 10
+        (Ne(p**2, 1) & (p**2 > 1), p**2 > 1),  # 11
+        (Ne(1/p, 1) & (cos(Abs(arg(p)))*Abs(p) > 1), Abs(p) > 1),  # 12
+        (Ne(p, 2) & (cos(Abs(arg(p)))*Abs(p) > 2), Abs(p) > 2),  # 13
+        ((Abs(arg(p)) < pi/2) & (cos(Abs(arg(p)))*sqrt(Abs(p**2)) > 1), p**2 > 1),  # 14
+    ]
+    cond = cond.func(*[_condsimp(_, first) for _ in cond.args])
+    change = True
+    while change:
+        change = False
+        for irule, (fro, to) in enumerate(rules):
+            if fro.func != cond.func:
+                continue
+            for n, arg1 in enumerate(cond.args):
+                if r in fro.args[0].free_symbols:
+                    m = arg1.match(fro.args[1])
+                    num = 1
+                else:
+                    num = 0
+                    m = arg1.match(fro.args[0])
+                if not m:
+                    continue
+                otherargs = [x.subs(m) for x in fro.args[:num] + fro.args[num + 1:]]
+                otherlist = [n]
+                for arg2 in otherargs:
+                    for k, arg3 in enumerate(cond.args):
+                        if k in otherlist:
+                            continue
+                        if arg2 == arg3:
+                            otherlist += [k]
+                            break
+                        if isinstance(arg3, And) and arg2.args[1] == r and \
+                                isinstance(arg2, And) and arg2.args[0] in arg3.args:
+                            otherlist += [k]
+                            break
+                        if isinstance(arg3, And) and arg2.args[0] == r and \
+                                isinstance(arg2, And) and arg2.args[1] in arg3.args:
+                            otherlist += [k]
+                            break
+                if len(otherlist) != len(otherargs) + 1:
+                    continue
+                newargs = [arg_ for (k, arg_) in enumerate(cond.args)
+                           if k not in otherlist] + [to.subs(m)]
+                if SYMPY_DEBUG:
+                    if irule not in (0, 2, 4, 5, 6, 7, 11, 12, 13, 14):
+                        print('used new rule:', irule)
+                cond = cond.func(*newargs)
+                change = True
+                break
+
+    # final tweak
+    def rel_touchup(rel):
+        if rel.rel_op != '==' or rel.rhs != 0:
+            return rel
+
+        # handle Eq(*, 0)
+        LHS = rel.lhs
+        m = LHS.match(arg(p)**q)
+        if not m:
+            m = LHS.match(unbranched_argument(polar_lift(p)**q))
+        if not m:
+            if isinstance(LHS, periodic_argument) and not LHS.args[0].is_polar \
+                    and LHS.args[1] is S.Infinity:
+                return (LHS.args[0] > 0)
+            return rel
+        return (m[p] > 0)
+    cond = cond.replace(lambda _: _.is_Relational, rel_touchup)
+    if SYMPY_DEBUG:
+        print('_condsimp: ', cond)
+    return cond
+
+def _eval_cond(cond):
+    """ Re-evaluate the conditions. """
+    if isinstance(cond, bool):
+        return cond
+    return _condsimp(cond.doit())
+
+####################################################################
+# Now the "backbone" functions to do actual integration.
+####################################################################
+
+
+def _my_principal_branch(expr, period, full_pb=False):
+    """ Bring expr nearer to its principal branch by removing superfluous
+        factors.
+        This function does *not* guarantee to yield the principal branch,
+        to avoid introducing opaque principal_branch() objects,
+        unless full_pb=True. """
+    res = principal_branch(expr, period)
+    if not full_pb:
+        res = res.replace(principal_branch, lambda x, y: x)
+    return res
+
+
+def _rewrite_saxena_1(fac, po, g, x):
+    """
+    Rewrite the integral fac*po*g dx, from zero to infinity, as
+    integral fac*G, where G has argument a*x. Note po=x**s.
+    Return fac, G.
+    """
+    _, s = _get_coeff_exp(po, x)
+    a, b = _get_coeff_exp(g.argument, x)
+    period = g.get_period()
+    a = _my_principal_branch(a, period)
+
+    # We substitute t = x**b.
+    C = fac/(Abs(b)*a**((s + 1)/b - 1))
+    # Absorb a factor of (at)**((1 + s)/b - 1).
+
+    def tr(l):
+        return [a + (1 + s)/b - 1 for a in l]
+    return C, meijerg(tr(g.an), tr(g.aother), tr(g.bm), tr(g.bother),
+                      a*x)
+
+
+def _check_antecedents_1(g, x, helper=False):
+    r"""
+    Return a condition under which the mellin transform of g exists.
+    Any power of x has already been absorbed into the G function,
+    so this is just $\int_0^\infty g\, dx$.
+
+    See [L, section 5.6.1]. (Note that s=1.)
+
+    If ``helper`` is True, only check if the MT exists at infinity, i.e. if
+    $\int_1^\infty g\, dx$ exists.
+    """
+    # NOTE if you update these conditions, please update the documentation as well
+    delta = g.delta
+    eta, _ = _get_coeff_exp(g.argument, x)
+    m, n, p, q = S([len(g.bm), len(g.an), len(g.ap), len(g.bq)])
+
+    if p > q:
+        def tr(l):
+            return [1 - x for x in l]
+        return _check_antecedents_1(meijerg(tr(g.bm), tr(g.bother),
+                                            tr(g.an), tr(g.aother), x/eta),
+                                    x)
+
+    tmp = [-re(b) < 1 for b in g.bm] + [1 < 1 - re(a) for a in g.an]
+    cond_3 = And(*tmp)
+
+    tmp += [-re(b) < 1 for b in g.bother]
+    tmp += [1 < 1 - re(a) for a in g.aother]
+    cond_3_star = And(*tmp)
+
+    cond_4 = (-re(g.nu) + (q + 1 - p)/2 > q - p)
+
+    def debug(*msg):
+        _debug(*msg)
+
+    def debugf(string, arg):
+        _debugf(string, arg)
+
+    debug('Checking antecedents for 1 function:')
+    debugf('  delta=%s, eta=%s, m=%s, n=%s, p=%s, q=%s',
+           (delta, eta, m, n, p, q))
+    debugf('  ap = %s, %s', (list(g.an), list(g.aother)))
+    debugf('  bq = %s, %s', (list(g.bm), list(g.bother)))
+    debugf('  cond_3=%s, cond_3*=%s, cond_4=%s', (cond_3, cond_3_star, cond_4))
+
+    conds = []
+
+    # case 1
+    case1 = []
+    tmp1 = [1 <= n, p < q, 1 <= m]
+    tmp2 = [1 <= p, 1 <= m, Eq(q, p + 1), Not(And(Eq(n, 0), Eq(m, p + 1)))]
+    tmp3 = [1 <= p, Eq(q, p)]
+    for k in range(ceiling(delta/2) + 1):
+        tmp3 += [Ne(Abs(unbranched_argument(eta)), (delta - 2*k)*pi)]
+    tmp = [delta > 0, Abs(unbranched_argument(eta)) < delta*pi]
+    extra = [Ne(eta, 0), cond_3]
+    if helper:
+        extra = []
+    for t in [tmp1, tmp2, tmp3]:
+        case1 += [And(*(t + tmp + extra))]
+    conds += case1
+    debug('  case 1:', case1)
+
+    # case 2
+    extra = [cond_3]
+    if helper:
+        extra = []
+    case2 = [And(Eq(n, 0), p + 1 <= m, m <= q,
+                 Abs(unbranched_argument(eta)) < delta*pi, *extra)]
+    conds += case2
+    debug('  case 2:', case2)
+
+    # case 3
+    extra = [cond_3, cond_4]
+    if helper:
+        extra = []
+    case3 = [And(p < q, 1 <= m, delta > 0, Eq(Abs(unbranched_argument(eta)), delta*pi),
+                 *extra)]
+    case3 += [And(p <= q - 2, Eq(delta, 0), Eq(Abs(unbranched_argument(eta)), 0), *extra)]
+    conds += case3
+    debug('  case 3:', case3)
+
+    # TODO altered cases 4-7
+
+    # extra case from wofram functions site:
+    # (reproduced verbatim from Prudnikov, section 2.24.2)
+    # https://functions.wolfram.com/HypergeometricFunctions/MeijerG/21/02/01/
+    case_extra = []
+    case_extra += [Eq(p, q), Eq(delta, 0), Eq(unbranched_argument(eta), 0), Ne(eta, 0)]
+    if not helper:
+        case_extra += [cond_3]
+    s = []
+    for a, b in zip(g.ap, g.bq):
+        s += [b - a]
+    case_extra += [re(Add(*s)) < 0]
+    case_extra = And(*case_extra)
+    conds += [case_extra]
+    debug('  extra case:', [case_extra])
+
+    case_extra_2 = [And(delta > 0, Abs(unbranched_argument(eta)) < delta*pi)]
+    if not helper:
+        case_extra_2 += [cond_3]
+    case_extra_2 = And(*case_extra_2)
+    conds += [case_extra_2]
+    debug('  second extra case:', [case_extra_2])
+
+    # TODO This leaves only one case from the three listed by Prudnikov.
+    #      Investigate if these indeed cover everything; if so, remove the rest.
+
+    return Or(*conds)
+
+
+def _int0oo_1(g, x):
+    r"""
+    Evaluate $\int_0^\infty g\, dx$ using G functions,
+    assuming the necessary conditions are fulfilled.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import a, b, c, d, x, y
+    >>> from sympy import meijerg
+    >>> from sympy.integrals.meijerint import _int0oo_1
+    >>> _int0oo_1(meijerg([a], [b], [c], [d], x*y), x)
+    gamma(-a)*gamma(c + 1)/(y*gamma(-d)*gamma(b + 1))
+    """
+    from sympy.simplify import gammasimp
+    # See [L, section 5.6.1]. Note that s=1.
+    eta, _ = _get_coeff_exp(g.argument, x)
+    res = 1/eta
+    # XXX TODO we should reduce order first
+    for b in g.bm:
+        res *= gamma(b + 1)
+    for a in g.an:
+        res *= gamma(1 - a - 1)
+    for b in g.bother:
+        res /= gamma(1 - b - 1)
+    for a in g.aother:
+        res /= gamma(a + 1)
+    return gammasimp(unpolarify(res))
+
+
+def _rewrite_saxena(fac, po, g1, g2, x, full_pb=False):
+    """
+    Rewrite the integral ``fac*po*g1*g2`` from 0 to oo in terms of G
+    functions with argument ``c*x``.
+
+    Explanation
+    ===========
+
+    Return C, f1, f2 such that integral C f1 f2 from 0 to infinity equals
+    integral fac ``po``, ``g1``, ``g2`` from 0 to infinity.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _rewrite_saxena
+    >>> from sympy.abc import s, t, m
+    >>> from sympy import meijerg
+    >>> g1 = meijerg([], [], [0], [], s*t)
+    >>> g2 = meijerg([], [], [m/2], [-m/2], t**2/4)
+    >>> r = _rewrite_saxena(1, t**0, g1, g2, t)
+    >>> r[0]
+    s/(4*sqrt(pi))
+    >>> r[1]
+    meijerg(((), ()), ((-1/2, 0), ()), s**2*t/4)
+    >>> r[2]
+    meijerg(((), ()), ((m/2,), (-m/2,)), t/4)
+    """
+    def pb(g):
+        a, b = _get_coeff_exp(g.argument, x)
+        per = g.get_period()
+        return meijerg(g.an, g.aother, g.bm, g.bother,
+                       _my_principal_branch(a, per, full_pb)*x**b)
+
+    _, s = _get_coeff_exp(po, x)
+    _, b1 = _get_coeff_exp(g1.argument, x)
+    _, b2 = _get_coeff_exp(g2.argument, x)
+    if (b1 < 0) == True:
+        b1 = -b1
+        g1 = _flip_g(g1)
+    if (b2 < 0) == True:
+        b2 = -b2
+        g2 = _flip_g(g2)
+    if not b1.is_Rational or not b2.is_Rational:
+        return
+    m1, n1 = b1.p, b1.q
+    m2, n2 = b2.p, b2.q
+    tau = ilcm(m1*n2, m2*n1)
+    r1 = tau//(m1*n2)
+    r2 = tau//(m2*n1)
+
+    C1, g1 = _inflate_g(g1, r1)
+    C2, g2 = _inflate_g(g2, r2)
+    g1 = pb(g1)
+    g2 = pb(g2)
+
+    fac *= C1*C2
+    a1, b = _get_coeff_exp(g1.argument, x)
+    a2, _ = _get_coeff_exp(g2.argument, x)
+
+    # arbitrarily tack on the x**s part to g1
+    # TODO should we try both?
+    exp = (s + 1)/b - 1
+    fac = fac/(Abs(b) * a1**exp)
+
+    def tr(l):
+        return [a + exp for a in l]
+    g1 = meijerg(tr(g1.an), tr(g1.aother), tr(g1.bm), tr(g1.bother), a1*x)
+    g2 = meijerg(g2.an, g2.aother, g2.bm, g2.bother, a2*x)
+
+    from sympy.simplify import powdenest
+    return powdenest(fac, polar=True), g1, g2
+
+
+def _check_antecedents(g1, g2, x):
+    """ Return a condition under which the integral theorem applies. """
+    #  Yes, this is madness.
+    # XXX TODO this is a testing *nightmare*
+    # NOTE if you update these conditions, please update the documentation as well
+
+    # The following conditions are found in
+    # [P], Section 2.24.1
+    #
+    # They are also reproduced (verbatim!) at
+    # https://functions.wolfram.com/HypergeometricFunctions/MeijerG/21/02/03/
+    #
+    # Note: k=l=r=alpha=1
+    sigma, _ = _get_coeff_exp(g1.argument, x)
+    omega, _ = _get_coeff_exp(g2.argument, x)
+    s, t, u, v = S([len(g1.bm), len(g1.an), len(g1.ap), len(g1.bq)])
+    m, n, p, q = S([len(g2.bm), len(g2.an), len(g2.ap), len(g2.bq)])
+    bstar = s + t - (u + v)/2
+    cstar = m + n - (p + q)/2
+    rho = g1.nu + (u - v)/2 + 1
+    mu = g2.nu + (p - q)/2 + 1
+    phi = q - p - (v - u)
+    eta = 1 - (v - u) - mu - rho
+    psi = (pi*(q - m - n) + Abs(unbranched_argument(omega)))/(q - p)
+    theta = (pi*(v - s - t) + Abs(unbranched_argument(sigma)))/(v - u)
+
+    _debug('Checking antecedents:')
+    _debugf('  sigma=%s, s=%s, t=%s, u=%s, v=%s, b*=%s, rho=%s',
+            (sigma, s, t, u, v, bstar, rho))
+    _debugf('  omega=%s, m=%s, n=%s, p=%s, q=%s, c*=%s, mu=%s,',
+            (omega, m, n, p, q, cstar, mu))
+    _debugf('  phi=%s, eta=%s, psi=%s, theta=%s', (phi, eta, psi, theta))
+
+    def _c1():
+        for g in [g1, g2]:
+            for i, j in itertools.product(g.an, g.bm):
+                diff = i - j
+                if diff.is_integer and diff.is_positive:
+                    return False
+        return True
+    c1 = _c1()
+    c2 = And(*[re(1 + i + j) > 0 for i in g1.bm for j in g2.bm])
+    c3 = And(*[re(1 + i + j) < 1 + 1 for i in g1.an for j in g2.an])
+    c4 = And(*[(p - q)*re(1 + i - 1) - re(mu) > Rational(-3, 2) for i in g1.an])
+    c5 = And(*[(p - q)*re(1 + i) - re(mu) > Rational(-3, 2) for i in g1.bm])
+    c6 = And(*[(u - v)*re(1 + i - 1) - re(rho) > Rational(-3, 2) for i in g2.an])
+    c7 = And(*[(u - v)*re(1 + i) - re(rho) > Rational(-3, 2) for i in g2.bm])
+    c8 = (Abs(phi) + 2*re((rho - 1)*(q - p) + (v - u)*(q - p) + (mu -
+          1)*(v - u)) > 0)
+    c9 = (Abs(phi) - 2*re((rho - 1)*(q - p) + (v - u)*(q - p) + (mu -
+          1)*(v - u)) > 0)
+    c10 = (Abs(unbranched_argument(sigma)) < bstar*pi)
+    c11 = Eq(Abs(unbranched_argument(sigma)), bstar*pi)
+    c12 = (Abs(unbranched_argument(omega)) < cstar*pi)
+    c13 = Eq(Abs(unbranched_argument(omega)), cstar*pi)
+
+    # The following condition is *not* implemented as stated on the wolfram
+    # function site. In the book of Prudnikov there is an additional part
+    # (the And involving re()). However, I only have this book in russian, and
+    # I don't read any russian. The following condition is what other people
+    # have told me it means.
+    # Worryingly, it is different from the condition implemented in REDUCE.
+    # The REDUCE implementation:
+    #   https://reduce-algebra.svn.sourceforge.net/svnroot/reduce-algebra/trunk/packages/defint/definta.red
+    #   (search for tst14)
+    # The Wolfram alpha version:
+    #   https://functions.wolfram.com/HypergeometricFunctions/MeijerG/21/02/03/03/0014/
+    z0 = exp(-(bstar + cstar)*pi*S.ImaginaryUnit)
+    zos = unpolarify(z0*omega/sigma)
+    zso = unpolarify(z0*sigma/omega)
+    if zos == 1/zso:
+        c14 = And(Eq(phi, 0), bstar + cstar <= 1,
+                  Or(Ne(zos, 1), re(mu + rho + v - u) < 1,
+                     re(mu + rho + q - p) < 1))
+    else:
+        def _cond(z):
+            '''Returns True if abs(arg(1-z)) < pi, avoiding arg(0).
+
+            Explanation
+            ===========
+
+            If ``z`` is 1 then arg is NaN. This raises a
+            TypeError on `NaN < pi`. Previously this gave `False` so
+            this behavior has been hardcoded here but someone should
+            check if this NaN is more serious! This NaN is triggered by
+            test_meijerint() in test_meijerint.py:
+            `meijerint_definite(exp(x), x, 0, I)`
+            '''
+            return z != 1 and Abs(arg(1 - z)) < pi
+
+        c14 = And(Eq(phi, 0), bstar - 1 + cstar <= 0,
+                  Or(And(Ne(zos, 1), _cond(zos)),
+                     And(re(mu + rho + v - u) < 1, Eq(zos, 1))))
+
+        c14_alt = And(Eq(phi, 0), cstar - 1 + bstar <= 0,
+                  Or(And(Ne(zso, 1), _cond(zso)),
+                     And(re(mu + rho + q - p) < 1, Eq(zso, 1))))
+
+        # Since r=k=l=1, in our case there is c14_alt which is the same as calling
+        # us with (g1, g2) = (g2, g1). The conditions below enumerate all cases
+        # (i.e. we don't have to try arguments reversed by hand), and indeed try
+        # all symmetric cases. (i.e. whenever there is a condition involving c14,
+        # there is also a dual condition which is exactly what we would get when g1,
+        # g2 were interchanged, *but c14 was unaltered*).
+        # Hence the following seems correct:
+        c14 = Or(c14, c14_alt)
+
+    '''
+    When `c15` is NaN (e.g. from `psi` being NaN as happens during
+    'test_issue_4992' and/or `theta` is NaN as in 'test_issue_6253',
+    both in `test_integrals.py`) the comparison to 0 formerly gave False
+    whereas now an error is raised. To keep the old behavior, the value
+    of NaN is replaced with False but perhaps a closer look at this condition
+    should be made: XXX how should conditions leading to c15=NaN be handled?
+    '''
+    try:
+        lambda_c = (q - p)*Abs(omega)**(1/(q - p))*cos(psi) \
+            + (v - u)*Abs(sigma)**(1/(v - u))*cos(theta)
+        # the TypeError might be raised here, e.g. if lambda_c is NaN
+        if _eval_cond(lambda_c > 0) != False:
+            c15 = (lambda_c > 0)
+        else:
+            def lambda_s0(c1, c2):
+                return c1*(q - p)*Abs(omega)**(1/(q - p))*sin(psi) \
+                    + c2*(v - u)*Abs(sigma)**(1/(v - u))*sin(theta)
+            lambda_s = Piecewise(
+                ((lambda_s0(+1, +1)*lambda_s0(-1, -1)),
+                 And(Eq(unbranched_argument(sigma), 0), Eq(unbranched_argument(omega), 0))),
+                (lambda_s0(sign(unbranched_argument(omega)), +1)*lambda_s0(sign(unbranched_argument(omega)), -1),
+                 And(Eq(unbranched_argument(sigma), 0), Ne(unbranched_argument(omega), 0))),
+                (lambda_s0(+1, sign(unbranched_argument(sigma)))*lambda_s0(-1, sign(unbranched_argument(sigma))),
+                 And(Ne(unbranched_argument(sigma), 0), Eq(unbranched_argument(omega), 0))),
+                (lambda_s0(sign(unbranched_argument(omega)), sign(unbranched_argument(sigma))), True))
+            tmp = [lambda_c > 0,
+                   And(Eq(lambda_c, 0), Ne(lambda_s, 0), re(eta) > -1),
+                   And(Eq(lambda_c, 0), Eq(lambda_s, 0), re(eta) > 0)]
+            c15 = Or(*tmp)
+    except TypeError:
+        c15 = False
+    for cond, i in [(c1, 1), (c2, 2), (c3, 3), (c4, 4), (c5, 5), (c6, 6),
+                    (c7, 7), (c8, 8), (c9, 9), (c10, 10), (c11, 11),
+                    (c12, 12), (c13, 13), (c14, 14), (c15, 15)]:
+        _debugf('  c%s: %s', (i, cond))
+
+    # We will return Or(*conds)
+    conds = []
+
+    def pr(count):
+        _debugf('  case %s: %s', (count, conds[-1]))
+    conds += [And(m*n*s*t != 0, bstar.is_positive is True, cstar.is_positive is True, c1, c2, c3, c10,
+                  c12)]  # 1
+    pr(1)
+    conds += [And(Eq(u, v), Eq(bstar, 0), cstar.is_positive is True, sigma.is_positive is True, re(rho) < 1,
+                  c1, c2, c3, c12)]  # 2
+    pr(2)
+    conds += [And(Eq(p, q), Eq(cstar, 0), bstar.is_positive is True, omega.is_positive is True, re(mu) < 1,
+                  c1, c2, c3, c10)]  # 3
+    pr(3)
+    conds += [And(Eq(p, q), Eq(u, v), Eq(bstar, 0), Eq(cstar, 0),
+                  sigma.is_positive is True, omega.is_positive is True, re(mu) < 1, re(rho) < 1,
+                  Ne(sigma, omega), c1, c2, c3)]  # 4
+    pr(4)
+    conds += [And(Eq(p, q), Eq(u, v), Eq(bstar, 0), Eq(cstar, 0),
+                  sigma.is_positive is True, omega.is_positive is True, re(mu + rho) < 1,
+                  Ne(omega, sigma), c1, c2, c3)]  # 5
+    pr(5)
+    conds += [And(p > q, s.is_positive is True, bstar.is_positive is True, cstar >= 0,
+                  c1, c2, c3, c5, c10, c13)]  # 6
+    pr(6)
+    conds += [And(p < q, t.is_positive is True, bstar.is_positive is True, cstar >= 0,
+                  c1, c2, c3, c4, c10, c13)]  # 7
+    pr(7)
+    conds += [And(u > v, m.is_positive is True, cstar.is_positive is True, bstar >= 0,
+                  c1, c2, c3, c7, c11, c12)]  # 8
+    pr(8)
+    conds += [And(u < v, n.is_positive is True, cstar.is_positive is True, bstar >= 0,
+                  c1, c2, c3, c6, c11, c12)]  # 9
+    pr(9)
+    conds += [And(p > q, Eq(u, v), Eq(bstar, 0), cstar >= 0, sigma.is_positive is True,
+                  re(rho) < 1, c1, c2, c3, c5, c13)]  # 10
+    pr(10)
+    conds += [And(p < q, Eq(u, v), Eq(bstar, 0), cstar >= 0, sigma.is_positive is True,
+                  re(rho) < 1, c1, c2, c3, c4, c13)]  # 11
+    pr(11)
+    conds += [And(Eq(p, q), u > v, bstar >= 0, Eq(cstar, 0), omega.is_positive is True,
+                  re(mu) < 1, c1, c2, c3, c7, c11)]  # 12
+    pr(12)
+    conds += [And(Eq(p, q), u < v, bstar >= 0, Eq(cstar, 0), omega.is_positive is True,
+                  re(mu) < 1, c1, c2, c3, c6, c11)]  # 13
+    pr(13)
+    conds += [And(p < q, u > v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c4, c7, c11, c13)]  # 14
+    pr(14)
+    conds += [And(p > q, u < v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c5, c6, c11, c13)]  # 15
+    pr(15)
+    conds += [And(p > q, u > v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c5, c7, c8, c11, c13, c14)]  # 16
+    pr(16)
+    conds += [And(p < q, u < v, bstar >= 0, cstar >= 0,
+                  c1, c2, c3, c4, c6, c9, c11, c13, c14)]  # 17
+    pr(17)
+    conds += [And(Eq(t, 0), s.is_positive is True, bstar.is_positive is True, phi.is_positive is True, c1, c2, c10)]  # 18
+    pr(18)
+    conds += [And(Eq(s, 0), t.is_positive is True, bstar.is_positive is True, phi.is_negative is True, c1, c3, c10)]  # 19
+    pr(19)
+    conds += [And(Eq(n, 0), m.is_positive is True, cstar.is_positive is True, phi.is_negative is True, c1, c2, c12)]  # 20
+    pr(20)
+    conds += [And(Eq(m, 0), n.is_positive is True, cstar.is_positive is True, phi.is_positive is True, c1, c3, c12)]  # 21
+    pr(21)
+    conds += [And(Eq(s*t, 0), bstar.is_positive is True, cstar.is_positive is True,
+                  c1, c2, c3, c10, c12)]  # 22
+    pr(22)
+    conds += [And(Eq(m*n, 0), bstar.is_positive is True, cstar.is_positive is True,
+                  c1, c2, c3, c10, c12)]  # 23
+    pr(23)
+
+    # The following case is from [Luke1969]. As far as I can tell, it is *not*
+    # covered by Prudnikov's.
+    # Let G1 and G2 be the two G-functions. Suppose the integral exists from
+    # 0 to a > 0 (this is easy the easy part), that G1 is exponential decay at
+    # infinity, and that the mellin transform of G2 exists.
+    # Then the integral exists.
+    mt1_exists = _check_antecedents_1(g1, x, helper=True)
+    mt2_exists = _check_antecedents_1(g2, x, helper=True)
+    conds += [And(mt2_exists, Eq(t, 0), u < s, bstar.is_positive is True, c10, c1, c2, c3)]
+    pr('E1')
+    conds += [And(mt2_exists, Eq(s, 0), v < t, bstar.is_positive is True, c10, c1, c2, c3)]
+    pr('E2')
+    conds += [And(mt1_exists, Eq(n, 0), p < m, cstar.is_positive is True, c12, c1, c2, c3)]
+    pr('E3')
+    conds += [And(mt1_exists, Eq(m, 0), q < n, cstar.is_positive is True, c12, c1, c2, c3)]
+    pr('E4')
+
+    # Let's short-circuit if this worked ...
+    # the rest is corner-cases and terrible to read.
+    r = Or(*conds)
+    if _eval_cond(r) != False:
+        return r
+
+    conds += [And(m + n > p, Eq(t, 0), Eq(phi, 0), s.is_positive is True, bstar.is_positive is True, cstar.is_negative is True,
+                  Abs(unbranched_argument(omega)) < (m + n - p + 1)*pi,
+                  c1, c2, c10, c14, c15)]  # 24
+    pr(24)
+    conds += [And(m + n > q, Eq(s, 0), Eq(phi, 0), t.is_positive is True, bstar.is_positive is True, cstar.is_negative is True,
+                  Abs(unbranched_argument(omega)) < (m + n - q + 1)*pi,
+                  c1, c3, c10, c14, c15)]  # 25
+    pr(25)
+    conds += [And(Eq(p, q - 1), Eq(t, 0), Eq(phi, 0), s.is_positive is True, bstar.is_positive is True,
+                  cstar >= 0, cstar*pi < Abs(unbranched_argument(omega)),
+                  c1, c2, c10, c14, c15)]  # 26
+    pr(26)
+    conds += [And(Eq(p, q + 1), Eq(s, 0), Eq(phi, 0), t.is_positive is True, bstar.is_positive is True,
+                  cstar >= 0, cstar*pi < Abs(unbranched_argument(omega)),
+                  c1, c3, c10, c14, c15)]  # 27
+    pr(27)
+    conds += [And(p < q - 1, Eq(t, 0), Eq(phi, 0), s.is_positive is True, bstar.is_positive is True,
+                  cstar >= 0, cstar*pi < Abs(unbranched_argument(omega)),
+                  Abs(unbranched_argument(omega)) < (m + n - p + 1)*pi,
+                  c1, c2, c10, c14, c15)]  # 28
+    pr(28)
+    conds += [And(
+        p > q + 1, Eq(s, 0), Eq(phi, 0), t.is_positive is True, bstar.is_positive is True, cstar >= 0,
+                  cstar*pi < Abs(unbranched_argument(omega)),
+                  Abs(unbranched_argument(omega)) < (m + n - q + 1)*pi,
+                  c1, c3, c10, c14, c15)]  # 29
+    pr(29)
+    conds += [And(Eq(n, 0), Eq(phi, 0), s + t > 0, m.is_positive is True, cstar.is_positive is True, bstar.is_negative is True,
+                  Abs(unbranched_argument(sigma)) < (s + t - u + 1)*pi,
+                  c1, c2, c12, c14, c15)]  # 30
+    pr(30)
+    conds += [And(Eq(m, 0), Eq(phi, 0), s + t > v, n.is_positive is True, cstar.is_positive is True, bstar.is_negative is True,
+                  Abs(unbranched_argument(sigma)) < (s + t - v + 1)*pi,
+                  c1, c3, c12, c14, c15)]  # 31
+    pr(31)
+    conds += [And(Eq(n, 0), Eq(phi, 0), Eq(u, v - 1), m.is_positive is True, cstar.is_positive is True,
+                  bstar >= 0, bstar*pi < Abs(unbranched_argument(sigma)),
+                  Abs(unbranched_argument(sigma)) < (bstar + 1)*pi,
+                  c1, c2, c12, c14, c15)]  # 32
+    pr(32)
+    conds += [And(Eq(m, 0), Eq(phi, 0), Eq(u, v + 1), n.is_positive is True, cstar.is_positive is True,
+                  bstar >= 0, bstar*pi < Abs(unbranched_argument(sigma)),
+                  Abs(unbranched_argument(sigma)) < (bstar + 1)*pi,
+                  c1, c3, c12, c14, c15)]  # 33
+    pr(33)
+    conds += [And(
+        Eq(n, 0), Eq(phi, 0), u < v - 1, m.is_positive is True, cstar.is_positive is True, bstar >= 0,
+        bstar*pi < Abs(unbranched_argument(sigma)),
+        Abs(unbranched_argument(sigma)) < (s + t - u + 1)*pi,
+        c1, c2, c12, c14, c15)]  # 34
+    pr(34)
+    conds += [And(
+        Eq(m, 0), Eq(phi, 0), u > v + 1, n.is_positive is True, cstar.is_positive is True, bstar >= 0,
+        bstar*pi < Abs(unbranched_argument(sigma)),
+        Abs(unbranched_argument(sigma)) < (s + t - v + 1)*pi,
+        c1, c3, c12, c14, c15)]  # 35
+    pr(35)
+
+    return Or(*conds)
+
+    # NOTE An alternative, but as far as I can tell weaker, set of conditions
+    #      can be found in [L, section 5.6.2].
+
+
+def _int0oo(g1, g2, x):
+    """
+    Express integral from zero to infinity g1*g2 using a G function,
+    assuming the necessary conditions are fulfilled.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import _int0oo
+    >>> from sympy.abc import s, t, m
+    >>> from sympy import meijerg, S
+    >>> g1 = meijerg([], [], [-S(1)/2, 0], [], s**2*t/4)
+    >>> g2 = meijerg([], [], [m/2], [-m/2], t/4)
+    >>> _int0oo(g1, g2, t)
+    4*meijerg(((0, 1/2), ()), ((m/2,), (-m/2,)), s**(-2))/s**2
+    """
+    # See: [L, section 5.6.2, equation (1)]
+    eta, _ = _get_coeff_exp(g1.argument, x)
+    omega, _ = _get_coeff_exp(g2.argument, x)
+
+    def neg(l):
+        return [-x for x in l]
+    a1 = neg(g1.bm) + list(g2.an)
+    a2 = list(g2.aother) + neg(g1.bother)
+    b1 = neg(g1.an) + list(g2.bm)
+    b2 = list(g2.bother) + neg(g1.aother)
+    return meijerg(a1, a2, b1, b2, omega/eta)/eta
+
+
+def _rewrite_inversion(fac, po, g, x):
+    """ Absorb ``po`` == x**s into g. """
+    _, s = _get_coeff_exp(po, x)
+    a, b = _get_coeff_exp(g.argument, x)
+
+    def tr(l):
+        return [t + s/b for t in l]
+    from sympy.simplify import powdenest
+    return (powdenest(fac/a**(s/b), polar=True),
+            meijerg(tr(g.an), tr(g.aother), tr(g.bm), tr(g.bother), g.argument))
+
+
+def _check_antecedents_inversion(g, x):
+    """ Check antecedents for the laplace inversion integral. """
+    _debug('Checking antecedents for inversion:')
+    z = g.argument
+    _, e = _get_coeff_exp(z, x)
+    if e < 0:
+        _debug('  Flipping G.')
+        # We want to assume that argument gets large as |x| -> oo
+        return _check_antecedents_inversion(_flip_g(g), x)
+
+    def statement_half(a, b, c, z, plus):
+        coeff, exponent = _get_coeff_exp(z, x)
+        a *= exponent
+        b *= coeff**c
+        c *= exponent
+        conds = []
+        wp = b*exp(S.ImaginaryUnit*re(c)*pi/2)
+        wm = b*exp(-S.ImaginaryUnit*re(c)*pi/2)
+        if plus:
+            w = wp
+        else:
+            w = wm
+        conds += [And(Or(Eq(b, 0), re(c) <= 0), re(a) <= -1)]
+        conds += [And(Ne(b, 0), Eq(im(c), 0), re(c) > 0, re(w) < 0)]
+        conds += [And(Ne(b, 0), Eq(im(c), 0), re(c) > 0, re(w) <= 0,
+                      re(a) <= -1)]
+        return Or(*conds)
+
+    def statement(a, b, c, z):
+        """ Provide a convergence statement for z**a * exp(b*z**c),
+             c/f sphinx docs. """
+        return And(statement_half(a, b, c, z, True),
+                   statement_half(a, b, c, z, False))
+
+    # Notations from [L], section 5.7-10
+    m, n, p, q = S([len(g.bm), len(g.an), len(g.ap), len(g.bq)])
+    tau = m + n - p
+    nu = q - m - n
+    rho = (tau - nu)/2
+    sigma = q - p
+    if sigma == 1:
+        epsilon = S.Half
+    elif sigma > 1:
+        epsilon = 1
+    else:
+        epsilon = S.NaN
+    theta = ((1 - sigma)/2 + Add(*g.bq) - Add(*g.ap))/sigma
+    delta = g.delta
+    _debugf('  m=%s, n=%s, p=%s, q=%s, tau=%s, nu=%s, rho=%s, sigma=%s',
+            (m, n, p, q, tau, nu, rho, sigma))
+    _debugf('  epsilon=%s, theta=%s, delta=%s', (epsilon, theta, delta))
+
+    # First check if the computation is valid.
+    if not (g.delta >= e/2 or (p >= 1 and p >= q)):
+        _debug('  Computation not valid for these parameters.')
+        return False
+
+    # Now check if the inversion integral exists.
+
+    # Test "condition A"
+    for a, b in itertools.product(g.an, g.bm):
+        if (a - b).is_integer and a > b:
+            _debug('  Not a valid G function.')
+            return False
+
+    # There are two cases. If p >= q, we can directly use a slater expansion
+    # like [L], 5.2 (11). Note in particular that the asymptotics of such an
+    # expansion even hold when some of the parameters differ by integers, i.e.
+    # the formula itself would not be valid! (b/c G functions are cts. in their
+    # parameters)
+    # When p < q, we need to use the theorems of [L], 5.10.
+
+    if p >= q:
+        _debug('  Using asymptotic Slater expansion.')
+        return And(*[statement(a - 1, 0, 0, z) for a in g.an])
+
+    def E(z):
+        return And(*[statement(a - 1, 0, 0, z) for a in g.an])
+
+    def H(z):
+        return statement(theta, -sigma, 1/sigma, z)
+
+    def Hp(z):
+        return statement_half(theta, -sigma, 1/sigma, z, True)
+
+    def Hm(z):
+        return statement_half(theta, -sigma, 1/sigma, z, False)
+
+    # [L], section 5.10
+    conds = []
+    # Theorem 1 -- p < q from test above
+    conds += [And(1 <= n, 1 <= m, rho*pi - delta >= pi/2, delta > 0,
+                  E(z*exp(S.ImaginaryUnit*pi*(nu + 1))))]
+    # Theorem 2, statements (2) and (3)
+    conds += [And(p + 1 <= m, m + 1 <= q, delta > 0, delta < pi/2, n == 0,
+                  (m - p + 1)*pi - delta >= pi/2,
+                  Hp(z*exp(S.ImaginaryUnit*pi*(q - m))),
+                  Hm(z*exp(-S.ImaginaryUnit*pi*(q - m))))]
+    # Theorem 2, statement (5)  -- p < q from test above
+    conds += [And(m == q, n == 0, delta > 0,
+                  (sigma + epsilon)*pi - delta >= pi/2, H(z))]
+    # Theorem 3, statements (6) and (7)
+    conds += [And(Or(And(p <= q - 2, 1 <= tau, tau <= sigma/2),
+                     And(p + 1 <= m + n, m + n <= (p + q)/2)),
+                  delta > 0, delta < pi/2, (tau + 1)*pi - delta >= pi/2,
+                  Hp(z*exp(S.ImaginaryUnit*pi*nu)),
+                  Hm(z*exp(-S.ImaginaryUnit*pi*nu)))]
+    # Theorem 4, statements (10) and (11)  -- p < q from test above
+    conds += [And(1 <= m, rho > 0, delta > 0, delta + rho*pi < pi/2,
+                  (tau + epsilon)*pi - delta >= pi/2,
+                  Hp(z*exp(S.ImaginaryUnit*pi*nu)),
+                  Hm(z*exp(-S.ImaginaryUnit*pi*nu)))]
+    # Trivial case
+    conds += [m == 0]
+
+    # TODO
+    # Theorem 5 is quite general
+    # Theorem 6 contains special cases for q=p+1
+
+    return Or(*conds)
+
+
+def _int_inversion(g, x, t):
+    """
+    Compute the laplace inversion integral, assuming the formula applies.
+    """
+    b, a = _get_coeff_exp(g.argument, x)
+    C, g = _inflate_fox_h(meijerg(g.an, g.aother, g.bm, g.bother, b/t**a), -a)
+    return C/t*g
+
+
+####################################################################
+# Finally, the real meat.
+####################################################################
+
+_lookup_table = None
+
+
+@cacheit
+@timeit
+def _rewrite_single(f, x, recursive=True):
+    """
+    Try to rewrite f as a sum of single G functions of the form
+    C*x**s*G(a*x**b), where b is a rational number and C is independent of x.
+    We guarantee that result.argument.as_coeff_mul(x) returns (a, (x**b,))
+    or (a, ()).
+    Returns a list of tuples (C, s, G) and a condition cond.
+    Returns None on failure.
+    """
+    from .transforms import (mellin_transform, inverse_mellin_transform,
+        IntegralTransformError, MellinTransformStripError)
+
+    global _lookup_table
+    if not _lookup_table:
+        _lookup_table = {}
+        _create_lookup_table(_lookup_table)
+
+    if isinstance(f, meijerg):
+        coeff, m = factor(f.argument, x).as_coeff_mul(x)
+        if len(m) > 1:
+            return None
+        m = m[0]
+        if m.is_Pow:
+            if m.base != x or not m.exp.is_Rational:
+                return None
+        elif m != x:
+            return None
+        return [(1, 0, meijerg(f.an, f.aother, f.bm, f.bother, coeff*m))], True
+
+    f_ = f
+    f = f.subs(x, z)
+    t = _mytype(f, z)
+    if t in _lookup_table:
+        l = _lookup_table[t]
+        for formula, terms, cond, hint in l:
+            subs = f.match(formula, old=True)
+            if subs:
+                subs_ = {}
+                for fro, to in subs.items():
+                    subs_[fro] = unpolarify(polarify(to, lift=True),
+                                            exponents_only=True)
+                subs = subs_
+                if not isinstance(hint, bool):
+                    hint = hint.subs(subs)
+                if hint == False:
+                    continue
+                if not isinstance(cond, (bool, BooleanAtom)):
+                    cond = unpolarify(cond.subs(subs))
+                if _eval_cond(cond) == False:
+                    continue
+                if not isinstance(terms, list):
+                    terms = terms(subs)
+                res = []
+                for fac, g in terms:
+                    r1 = _get_coeff_exp(unpolarify(fac.subs(subs).subs(z, x),
+                                                   exponents_only=True), x)
+                    try:
+                        g = g.subs(subs).subs(z, x)
+                    except ValueError:
+                        continue
+                    # NOTE these substitutions can in principle introduce oo,
+                    #      zoo and other absurdities. It shouldn't matter,
+                    #      but better be safe.
+                    if Tuple(*(r1 + (g,))).has(S.Infinity, S.ComplexInfinity, S.NegativeInfinity):
+                        continue
+                    g = meijerg(g.an, g.aother, g.bm, g.bother,
+                                unpolarify(g.argument, exponents_only=True))
+                    res.append(r1 + (g,))
+                if res:
+                    return res, cond
+
+    # try recursive mellin transform
+    if not recursive:
+        return None
+    _debug('Trying recursive Mellin transform method.')
+
+    def my_imt(F, s, x, strip):
+        """ Calling simplify() all the time is slow and not helpful, since
+            most of the time it only factors things in a way that has to be
+            un-done anyway. But sometimes it can remove apparent poles. """
+        # XXX should this be in inverse_mellin_transform?
+        try:
+            return inverse_mellin_transform(F, s, x, strip,
+                                            as_meijerg=True, needeval=True)
+        except MellinTransformStripError:
+            from sympy.simplify import simplify
+            return inverse_mellin_transform(
+                simplify(cancel(expand(F))), s, x, strip,
+                as_meijerg=True, needeval=True)
+    f = f_
+    s = _dummy('s', 'rewrite-single', f)
+    # to avoid infinite recursion, we have to force the two g functions case
+
+    def my_integrator(f, x):
+        r = _meijerint_definite_4(f, x, only_double=True)
+        if r is not None:
+            from sympy.simplify import hyperexpand
+            res, cond = r
+            res = _my_unpolarify(hyperexpand(res, rewrite='nonrepsmall'))
+            return Piecewise((res, cond),
+                             (Integral(f, (x, S.Zero, S.Infinity)), True))
+        return Integral(f, (x, S.Zero, S.Infinity))
+    try:
+        F, strip, _ = mellin_transform(f, x, s, integrator=my_integrator,
+                                       simplify=False, needeval=True)
+        g = my_imt(F, s, x, strip)
+    except IntegralTransformError:
+        g = None
+    if g is None:
+        # We try to find an expression by analytic continuation.
+        # (also if the dummy is already in the expression, there is no point in
+        #  putting in another one)
+        a = _dummy_('a', 'rewrite-single')
+        if a not in f.free_symbols and _is_analytic(f, x):
+            try:
+                F, strip, _ = mellin_transform(f.subs(x, a*x), x, s,
+                                               integrator=my_integrator,
+                                               needeval=True, simplify=False)
+                g = my_imt(F, s, x, strip).subs(a, 1)
+            except IntegralTransformError:
+                g = None
+    if g is None or g.has(S.Infinity, S.NaN, S.ComplexInfinity):
+        _debug('Recursive Mellin transform failed.')
+        return None
+    args = Add.make_args(g)
+    res = []
+    for f in args:
+        c, m = f.as_coeff_mul(x)
+        if len(m) > 1:
+            raise NotImplementedError('Unexpected form...')
+        g = m[0]
+        a, b = _get_coeff_exp(g.argument, x)
+        res += [(c, 0, meijerg(g.an, g.aother, g.bm, g.bother,
+                               unpolarify(polarify(
+                                   a, lift=True), exponents_only=True)
+                               *x**b))]
+    _debug('Recursive Mellin transform worked:', g)
+    return res, True
+
+
+def _rewrite1(f, x, recursive=True):
+    """
+    Try to rewrite ``f`` using a (sum of) single G functions with argument a*x**b.
+    Return fac, po, g such that f = fac*po*g, fac is independent of ``x``.
+    and po = x**s.
+    Here g is a result from _rewrite_single.
+    Return None on failure.
+    """
+    fac, po, g = _split_mul(f, x)
+    g = _rewrite_single(g, x, recursive)
+    if g:
+        return fac, po, g[0], g[1]
+
+
+def _rewrite2(f, x):
+    """
+    Try to rewrite ``f`` as a product of two G functions of arguments a*x**b.
+    Return fac, po, g1, g2 such that f = fac*po*g1*g2, where fac is
+    independent of x and po is x**s.
+    Here g1 and g2 are results of _rewrite_single.
+    Returns None on failure.
+    """
+    fac, po, g = _split_mul(f, x)
+    if any(_rewrite_single(expr, x, False) is None for expr in _mul_args(g)):
+        return None
+    l = _mul_as_two_parts(g)
+    if not l:
+        return None
+    l = list(ordered(l, [
+        lambda p: max(len(_exponents(p[0], x)), len(_exponents(p[1], x))),
+        lambda p: max(len(_functions(p[0], x)), len(_functions(p[1], x))),
+        lambda p: max(len(_find_splitting_points(p[0], x)),
+                      len(_find_splitting_points(p[1], x)))]))
+
+    for recursive, (fac1, fac2) in itertools.product((False, True), l):
+        g1 = _rewrite_single(fac1, x, recursive)
+        g2 = _rewrite_single(fac2, x, recursive)
+        if g1 and g2:
+            cond = And(g1[1], g2[1])
+            if cond != False:
+                return fac, po, g1[0], g2[0], cond
+
+
+def meijerint_indefinite(f, x):
+    """
+    Compute an indefinite integral of ``f`` by rewriting it as a G function.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import meijerint_indefinite
+    >>> from sympy import sin
+    >>> from sympy.abc import x
+    >>> meijerint_indefinite(sin(x), x)
+    -cos(x)
+    """
+    f = sympify(f)
+    results = []
+    for a in sorted(_find_splitting_points(f, x) | {S.Zero}, key=default_sort_key):
+        res = _meijerint_indefinite_1(f.subs(x, x + a), x)
+        if not res:
+            continue
+        res = res.subs(x, x - a)
+        if _has(res, hyper, meijerg):
+            results.append(res)
+        else:
+            return res
+    if f.has(HyperbolicFunction):
+        _debug('Try rewriting hyperbolics in terms of exp.')
+        rv = meijerint_indefinite(
+            _rewrite_hyperbolics_as_exp(f), x)
+        if rv:
+            if not isinstance(rv, list):
+                from sympy.simplify.radsimp import collect
+                return collect(factor_terms(rv), rv.atoms(exp))
+            results.extend(rv)
+    if results:
+        return next(ordered(results))
+
+
+def _meijerint_indefinite_1(f, x):
+    """ Helper that does not attempt any substitution. """
+    _debug('Trying to compute the indefinite integral of', f, 'wrt', x)
+    from sympy.simplify import hyperexpand, powdenest
+
+    gs = _rewrite1(f, x)
+    if gs is None:
+        # Note: the code that calls us will do expand() and try again
+        return None
+
+    fac, po, gl, cond = gs
+    _debug(' could rewrite:', gs)
+    res = S.Zero
+    for C, s, g in gl:
+        a, b = _get_coeff_exp(g.argument, x)
+        _, c = _get_coeff_exp(po, x)
+        c += s
+
+        # we do a substitution t=a*x**b, get integrand fac*t**rho*g
+        fac_ = fac * C * x**(1 + c) / b
+        rho = (c + 1)/b
+
+        # we now use t**rho*G(params, t) = G(params + rho, t)
+        # [L, page 150, equation (4)]
+        # and integral G(params, t) dt = G(1, params+1, 0, t)
+        #   (or a similar expression with 1 and 0 exchanged ... pick the one
+        #    which yields a well-defined function)
+        # [R, section 5]
+        # (Note that this dummy will immediately go away again, so we
+        #  can safely pass S.One for ``expr``.)
+        t = _dummy('t', 'meijerint-indefinite', S.One)
+
+        def tr(p):
+            return [a + rho for a in p]
+        if any(b.is_integer and (b <= 0) == True for b in tr(g.bm)):
+            r = -meijerg(
+                list(g.an), list(g.aother) + [1-rho], list(g.bm) + [-rho], list(g.bother), t)
+        else:
+            r = meijerg(
+                list(g.an) + [1-rho], list(g.aother), list(g.bm), list(g.bother) + [-rho], t)
+        # The antiderivative is most often expected to be defined
+        # in the neighborhood of  x = 0.
+        if b.is_extended_nonnegative and not f.subs(x, 0).has(S.NaN, S.ComplexInfinity):
+            place = 0  # Assume we can expand at zero
+        else:
+            place = None
+        r = hyperexpand(r.subs(t, a*x**b), place=place)
+
+        # now substitute back
+        # Note: we really do want the powers of x to combine.
+        res += powdenest(fac_*r, polar=True)
+
+    def _clean(res):
+        """This multiplies out superfluous powers of x we created, and chops off
+        constants:
+
+            >> _clean(x*(exp(x)/x - 1/x) + 3)
+            exp(x)
+
+        cancel is used before mul_expand since it is possible for an
+        expression to have an additive constant that does not become isolated
+        with simple expansion. Such a situation was identified in issue 6369:
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt, cancel
+        >>> from sympy.abc import x
+        >>> a = sqrt(2*x + 1)
+        >>> bad = (3*x*a**5 + 2*x - a**5 + 1)/a**2
+        >>> bad.expand().as_independent(x)[0]
+        0
+        >>> cancel(bad).expand().as_independent(x)[0]
+        1
+        """
+        res = expand_mul(cancel(res), deep=False)
+        return Add._from_args(res.as_coeff_add(x)[1])
+
+    res = piecewise_fold(res, evaluate=None)
+    if res.is_Piecewise:
+        newargs = []
+        for e, c in res.args:
+            e = _my_unpolarify(_clean(e))
+            newargs += [(e, c)]
+        res = Piecewise(*newargs, evaluate=False)
+    else:
+        res = _my_unpolarify(_clean(res))
+    return Piecewise((res, _my_unpolarify(cond)), (Integral(f, x), True))
+
+
+@timeit
+def meijerint_definite(f, x, a, b):
+    """
+    Integrate ``f`` over the interval [``a``, ``b``], by rewriting it as a product
+    of two G functions, or as a single G function.
+
+    Return res, cond, where cond are convergence conditions.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.meijerint import meijerint_definite
+    >>> from sympy import exp, oo
+    >>> from sympy.abc import x
+    >>> meijerint_definite(exp(-x**2), x, -oo, oo)
+    (sqrt(pi), True)
+
+    This function is implemented as a succession of functions
+    meijerint_definite, _meijerint_definite_2, _meijerint_definite_3,
+    _meijerint_definite_4. Each function in the list calls the next one
+    (presumably) several times. This means that calling meijerint_definite
+    can be very costly.
+    """
+    # This consists of three steps:
+    # 1) Change the integration limits to 0, oo
+    # 2) Rewrite in terms of G functions
+    # 3) Evaluate the integral
+    #
+    # There are usually several ways of doing this, and we want to try all.
+    # This function does (1), calls _meijerint_definite_2 for step (2).
+    _debugf('Integrating %s wrt %s from %s to %s.', (f, x, a, b))
+    f = sympify(f)
+    if f.has(DiracDelta):
+        _debug('Integrand has DiracDelta terms - giving up.')
+        return None
+
+    if f.has(SingularityFunction):
+        _debug('Integrand has Singularity Function terms - giving up.')
+        return None
+
+    f_, x_, a_, b_ = f, x, a, b
+
+    # Let's use a dummy in case any of the boundaries has x.
+    d = Dummy('x')
+    f = f.subs(x, d)
+    x = d
+
+    if a == b:
+        return (S.Zero, True)
+
+    results = []
+    if a is S.NegativeInfinity and b is not S.Infinity:
+        return meijerint_definite(f.subs(x, -x), x, -b, -a)
+
+    elif a is S.NegativeInfinity:
+        # Integrating -oo to oo. We need to find a place to split the integral.
+        _debug('  Integrating -oo to +oo.')
+        innermost = _find_splitting_points(f, x)
+        _debug('  Sensible splitting points:', innermost)
+        for c in sorted(innermost, key=default_sort_key, reverse=True) + [S.Zero]:
+            _debug('  Trying to split at', c)
+            if not c.is_extended_real:
+                _debug('  Non-real splitting point.')
+                continue
+            res1 = _meijerint_definite_2(f.subs(x, x + c), x)
+            if res1 is None:
+                _debug('  But could not compute first integral.')
+                continue
+            res2 = _meijerint_definite_2(f.subs(x, c - x), x)
+            if res2 is None:
+                _debug('  But could not compute second integral.')
+                continue
+            res1, cond1 = res1
+            res2, cond2 = res2
+            cond = _condsimp(And(cond1, cond2))
+            if cond == False:
+                _debug('  But combined condition is always false.')
+                continue
+            res = res1 + res2
+            return res, cond
+
+    elif a is S.Infinity:
+        res = meijerint_definite(f, x, b, S.Infinity)
+        return -res[0], res[1]
+
+    elif (a, b) == (S.Zero, S.Infinity):
+        # This is a common case - try it directly first.
+        res = _meijerint_definite_2(f, x)
+        if res:
+            if _has(res[0], meijerg):
+                results.append(res)
+            else:
+                return res
+
+    else:
+        if b is S.Infinity:
+            for split in _find_splitting_points(f, x):
+                if (a - split >= 0) == True:
+                    _debugf('Trying x -> x + %s', split)
+                    res = _meijerint_definite_2(f.subs(x, x + split)
+                                                *Heaviside(x + split - a), x)
+                    if res:
+                        if _has(res[0], meijerg):
+                            results.append(res)
+                        else:
+                            return res
+
+        f = f.subs(x, x + a)
+        b = b - a
+        a = 0
+        if b is not S.Infinity:
+            phi = exp(S.ImaginaryUnit*arg(b))
+            b = Abs(b)
+            f = f.subs(x, phi*x)
+            f *= Heaviside(b - x)*phi
+            b = S.Infinity
+
+        _debug('Changed limits to', a, b)
+        _debug('Changed function to', f)
+        res = _meijerint_definite_2(f, x)
+        if res:
+            if _has(res[0], meijerg):
+                results.append(res)
+            else:
+                return res
+    if f_.has(HyperbolicFunction):
+        _debug('Try rewriting hyperbolics in terms of exp.')
+        rv = meijerint_definite(
+            _rewrite_hyperbolics_as_exp(f_), x_, a_, b_)
+        if rv:
+            if not isinstance(rv, list):
+                from sympy.simplify.radsimp import collect
+                rv = (collect(factor_terms(rv[0]), rv[0].atoms(exp)),) + rv[1:]
+                return rv
+            results.extend(rv)
+    if results:
+        return next(ordered(results))
+
+
+def _guess_expansion(f, x):
+    """ Try to guess sensible rewritings for integrand f(x). """
+    res = [(f, 'original integrand')]
+
+    orig = res[-1][0]
+    saw = {orig}
+    expanded = expand_mul(orig)
+    if expanded not in saw:
+        res += [(expanded, 'expand_mul')]
+        saw.add(expanded)
+
+    expanded = expand(orig)
+    if expanded not in saw:
+        res += [(expanded, 'expand')]
+        saw.add(expanded)
+
+    if orig.has(TrigonometricFunction, HyperbolicFunction):
+        expanded = expand_mul(expand_trig(orig))
+        if expanded not in saw:
+            res += [(expanded, 'expand_trig, expand_mul')]
+            saw.add(expanded)
+
+    if orig.has(cos, sin):
+        from sympy.simplify.fu import sincos_to_sum
+        reduced = sincos_to_sum(orig)
+        if reduced not in saw:
+            res += [(reduced, 'trig power reduction')]
+            saw.add(reduced)
+
+    return res
+
+
+def _meijerint_definite_2(f, x):
+    """
+    Try to integrate f dx from zero to infinity.
+
+    The body of this function computes various 'simplifications'
+    f1, f2, ... of f (e.g. by calling expand_mul(), trigexpand()
+    - see _guess_expansion) and calls _meijerint_definite_3 with each of
+    these in succession.
+    If _meijerint_definite_3 succeeds with any of the simplified functions,
+    returns this result.
+    """
+    # This function does preparation for (2), calls
+    # _meijerint_definite_3 for (2) and (3) combined.
+
+    # use a positive dummy - we integrate from 0 to oo
+    # XXX if a nonnegative symbol is used there will be test failures
+    dummy = _dummy('x', 'meijerint-definite2', f, positive=True)
+    f = f.subs(x, dummy)
+    x = dummy
+
+    if f == 0:
+        return S.Zero, True
+
+    for g, explanation in _guess_expansion(f, x):
+        _debug('Trying', explanation)
+        res = _meijerint_definite_3(g, x)
+        if res:
+            return res
+
+
+def _meijerint_definite_3(f, x):
+    """
+    Try to integrate f dx from zero to infinity.
+
+    This function calls _meijerint_definite_4 to try to compute the
+    integral. If this fails, it tries using linearity.
+    """
+    res = _meijerint_definite_4(f, x)
+    if res and res[1] != False:
+        return res
+    if f.is_Add:
+        _debug('Expanding and evaluating all terms.')
+        ress = [_meijerint_definite_4(g, x) for g in f.args]
+        if all(r is not None for r in ress):
+            conds = []
+            res = S.Zero
+            for r, c in ress:
+                res += r
+                conds += [c]
+            c = And(*conds)
+            if c != False:
+                return res, c
+
+
+def _my_unpolarify(f):
+    return _eval_cond(unpolarify(f))
+
+
+@timeit
+def _meijerint_definite_4(f, x, only_double=False):
+    """
+    Try to integrate f dx from zero to infinity.
+
+    Explanation
+    ===========
+
+    This function tries to apply the integration theorems found in literature,
+    i.e. it tries to rewrite f as either one or a product of two G-functions.
+
+    The parameter ``only_double`` is used internally in the recursive algorithm
+    to disable trying to rewrite f as a single G-function.
+    """
+    from sympy.simplify import hyperexpand
+    # This function does (2) and (3)
+    _debug('Integrating', f)
+    # Try single G function.
+    if not only_double:
+        gs = _rewrite1(f, x, recursive=False)
+        if gs is not None:
+            fac, po, g, cond = gs
+            _debug('Could rewrite as single G function:', fac, po, g)
+            res = S.Zero
+            for C, s, f in g:
+                if C == 0:
+                    continue
+                C, f = _rewrite_saxena_1(fac*C, po*x**s, f, x)
+                res += C*_int0oo_1(f, x)
+                cond = And(cond, _check_antecedents_1(f, x))
+                if cond == False:
+                    break
+            cond = _my_unpolarify(cond)
+            if cond == False:
+                _debug('But cond is always False.')
+            else:
+                _debug('Result before branch substitutions is:', res)
+                return _my_unpolarify(hyperexpand(res)), cond
+
+    # Try two G functions.
+    gs = _rewrite2(f, x)
+    if gs is not None:
+        for full_pb in [False, True]:
+            fac, po, g1, g2, cond = gs
+            _debug('Could rewrite as two G functions:', fac, po, g1, g2)
+            res = S.Zero
+            for C1, s1, f1 in g1:
+                for C2, s2, f2 in g2:
+                    r = _rewrite_saxena(fac*C1*C2, po*x**(s1 + s2),
+                                        f1, f2, x, full_pb)
+                    if r is None:
+                        _debug('Non-rational exponents.')
+                        return
+                    C, f1_, f2_ = r
+                    _debug('Saxena subst for yielded:', C, f1_, f2_)
+                    cond = And(cond, _check_antecedents(f1_, f2_, x))
+                    if cond == False:
+                        break
+                    res += C*_int0oo(f1_, f2_, x)
+                else:
+                    continue
+                break
+            cond = _my_unpolarify(cond)
+            if cond == False:
+                _debugf('But cond is always False (full_pb=%s).', full_pb)
+            else:
+                _debugf('Result before branch substitutions is: %s', (res, ))
+                if only_double:
+                    return res, cond
+                return _my_unpolarify(hyperexpand(res)), cond
+
+
+def meijerint_inversion(f, x, t):
+    r"""
+    Compute the inverse laplace transform
+    $\int_{c+i\infty}^{c-i\infty} f(x) e^{tx}\, dx$,
+    for real c larger than the real part of all singularities of ``f``.
+
+    Note that ``t`` is always assumed real and positive.
+
+    Return None if the integral does not exist or could not be evaluated.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, t
+    >>> from sympy.integrals.meijerint import meijerint_inversion
+    >>> meijerint_inversion(1/x, x, t)
+    Heaviside(t)
+    """
+    f_ = f
+    t_ = t
+    t = Dummy('t', polar=True)  # We don't want sqrt(t**2) = abs(t) etc
+    f = f.subs(t_, t)
+    _debug('Laplace-inverting', f)
+    if not _is_analytic(f, x):
+        _debug('But expression is not analytic.')
+        return None
+    # Exponentials correspond to shifts; we filter them out and then
+    # shift the result later.  If we are given an Add this will not
+    # work, but the calling code will take care of that.
+    shift = S.Zero
+
+    if f.is_Mul:
+        args = list(f.args)
+    elif isinstance(f, exp):
+        args = [f]
+    else:
+        args = None
+
+    if args:
+        newargs = []
+        exponentials = []
+        while args:
+            arg = args.pop()
+            if isinstance(arg, exp):
+                arg2 = expand(arg)
+                if arg2.is_Mul:
+                    args += arg2.args
+                    continue
+                try:
+                    a, b = _get_coeff_exp(arg.args[0], x)
+                except _CoeffExpValueError:
+                    b = 0
+                if b == 1:
+                    exponentials.append(a)
+                else:
+                    newargs.append(arg)
+            elif arg.is_Pow:
+                arg2 = expand(arg)
+                if arg2.is_Mul:
+                    args += arg2.args
+                    continue
+                if x not in arg.base.free_symbols:
+                    try:
+                        a, b = _get_coeff_exp(arg.exp, x)
+                    except _CoeffExpValueError:
+                        b = 0
+                    if b == 1:
+                        exponentials.append(a*log(arg.base))
+                newargs.append(arg)
+            else:
+                newargs.append(arg)
+        shift = Add(*exponentials)
+        f = Mul(*newargs)
+
+    if x not in f.free_symbols:
+        _debug('Expression consists of constant and exp shift:', f, shift)
+        cond = Eq(im(shift), 0)
+        if cond == False:
+            _debug('but shift is nonreal, cannot be a Laplace transform')
+            return None
+        res = f*DiracDelta(t + shift)
+        _debug('Result is a delta function, possibly conditional:', res, cond)
+        # cond is True or Eq
+        return Piecewise((res.subs(t, t_), cond))
+
+    gs = _rewrite1(f, x)
+    if gs is not None:
+        fac, po, g, cond = gs
+        _debug('Could rewrite as single G function:', fac, po, g)
+        res = S.Zero
+        for C, s, f in g:
+            C, f = _rewrite_inversion(fac*C, po*x**s, f, x)
+            res += C*_int_inversion(f, x, t)
+            cond = And(cond, _check_antecedents_inversion(f, x))
+            if cond == False:
+                break
+        cond = _my_unpolarify(cond)
+        if cond == False:
+            _debug('But cond is always False.')
+        else:
+            _debug('Result before branch substitution:', res)
+            from sympy.simplify import hyperexpand
+            res = _my_unpolarify(hyperexpand(res))
+            if not res.has(Heaviside):
+                res *= Heaviside(t)
+            res = res.subs(t, t + shift)
+            if not isinstance(cond, bool):
+                cond = cond.subs(t, t + shift)
+            from .transforms import InverseLaplaceTransform
+            return Piecewise((res.subs(t, t_), cond),
+                             (InverseLaplaceTransform(f_.subs(t, t_), x, t_, None), True))

parrot/lib/python3.10/site-packages/sympy/integrals/rationaltools.py

@@ -0,0 +1,429 @@
+"""This module implements tools for integrating rational functions. """
+
+from sympy.core.function import Lambda
+from sympy.core.numbers import I
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import atan
+from sympy.polys.polyroots import roots
+from sympy.polys.polytools import cancel
+from sympy.polys.rootoftools import RootSum
+from sympy.polys import Poly, resultant, ZZ
+
+
+def ratint(f, x, **flags):
+    """
+    Performs indefinite integration of rational functions.
+
+    Explanation
+    ===========
+
+    Given a field :math:`K` and a rational function :math:`f = p/q`,
+    where :math:`p` and :math:`q` are polynomials in :math:`K[x]`,
+    returns a function :math:`g` such that :math:`f = g'`.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.rationaltools import ratint
+    >>> from sympy.abc import x
+
+    >>> ratint(36/(x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2), x)
+    (12*x + 6)/(x**2 - 1) + 4*log(x - 2) - 4*log(x + 1)
+
+    References
+    ==========
+
+    .. [1] M. Bronstein, Symbolic Integration I: Transcendental
+       Functions, Second Edition, Springer-Verlag, 2005, pp. 35-70
+
+    See Also
+    ========
+
+    sympy.integrals.integrals.Integral.doit
+    sympy.integrals.rationaltools.ratint_logpart
+    sympy.integrals.rationaltools.ratint_ratpart
+
+    """
+    if isinstance(f, tuple):
+        p, q = f
+    else:
+        p, q = f.as_numer_denom()
+
+    p, q = Poly(p, x, composite=False, field=True), Poly(q, x, composite=False, field=True)
+
+    coeff, p, q = p.cancel(q)
+    poly, p = p.div(q)
+
+    result = poly.integrate(x).as_expr()
+
+    if p.is_zero:
+        return coeff*result
+
+    g, h = ratint_ratpart(p, q, x)
+
+    P, Q = h.as_numer_denom()
+
+    P = Poly(P, x)
+    Q = Poly(Q, x)
+
+    q, r = P.div(Q)
+
+    result += g + q.integrate(x).as_expr()
+
+    if not r.is_zero:
+        symbol = flags.get('symbol', 't')
+
+        if not isinstance(symbol, Symbol):
+            t = Dummy(symbol)
+        else:
+            t = symbol.as_dummy()
+
+        L = ratint_logpart(r, Q, x, t)
+
+        real = flags.get('real')
+
+        if real is None:
+            if isinstance(f, tuple):
+                p, q = f
+                atoms = p.atoms() | q.atoms()
+            else:
+                atoms = f.atoms()
+
+            for elt in atoms - {x}:
+                if not elt.is_extended_real:
+                    real = False
+                    break
+            else:
+                real = True
+
+        eps = S.Zero
+
+        if not real:
+            for h, q in L:
+                _, h = h.primitive()
+                eps += RootSum(
+                    q, Lambda(t, t*log(h.as_expr())), quadratic=True)
+        else:
+            for h, q in L:
+                _, h = h.primitive()
+                R = log_to_real(h, q, x, t)
+
+                if R is not None:
+                    eps += R
+                else:
+                    eps += RootSum(
+                        q, Lambda(t, t*log(h.as_expr())), quadratic=True)
+
+        result += eps
+
+    return coeff*result
+
+
+def ratint_ratpart(f, g, x):
+    """
+    Horowitz-Ostrogradsky algorithm.
+
+    Explanation
+    ===========
+
+    Given a field K and polynomials f and g in K[x], such that f and g
+    are coprime and deg(f) < deg(g), returns fractions A and B in K(x),
+    such that f/g = A' + B and B has square-free denominator.
+
+    Examples
+    ========
+
+        >>> from sympy.integrals.rationaltools import ratint_ratpart
+        >>> from sympy.abc import x, y
+        >>> from sympy import Poly
+        >>> ratint_ratpart(Poly(1, x, domain='ZZ'),
+        ... Poly(x + 1, x, domain='ZZ'), x)
+        (0, 1/(x + 1))
+        >>> ratint_ratpart(Poly(1, x, domain='EX'),
+        ... Poly(x**2 + y**2, x, domain='EX'), x)
+        (0, 1/(x**2 + y**2))
+        >>> ratint_ratpart(Poly(36, x, domain='ZZ'),
+        ... Poly(x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2, x, domain='ZZ'), x)
+        ((12*x + 6)/(x**2 - 1), 12/(x**2 - x - 2))
+
+    See Also
+    ========
+
+    ratint, ratint_logpart
+    """
+    from sympy.solvers.solvers import solve
+
+    f = Poly(f, x)
+    g = Poly(g, x)
+
+    u, v, _ = g.cofactors(g.diff())
+
+    n = u.degree()
+    m = v.degree()
+
+    A_coeffs = [ Dummy('a' + str(n - i)) for i in range(0, n) ]
+    B_coeffs = [ Dummy('b' + str(m - i)) for i in range(0, m) ]
+
+    C_coeffs = A_coeffs + B_coeffs
+
+    A = Poly(A_coeffs, x, domain=ZZ[C_coeffs])
+    B = Poly(B_coeffs, x, domain=ZZ[C_coeffs])
+
+    H = f - A.diff()*v + A*(u.diff()*v).quo(u) - B*u
+
+    result = solve(H.coeffs(), C_coeffs)
+
+    A = A.as_expr().subs(result)
+    B = B.as_expr().subs(result)
+
+    rat_part = cancel(A/u.as_expr(), x)
+    log_part = cancel(B/v.as_expr(), x)
+
+    return rat_part, log_part
+
+
+def ratint_logpart(f, g, x, t=None):
+    r"""
+    Lazard-Rioboo-Trager algorithm.
+
+    Explanation
+    ===========
+
+    Given a field K and polynomials f and g in K[x], such that f and g
+    are coprime, deg(f) < deg(g) and g is square-free, returns a list
+    of tuples (s_i, q_i) of polynomials, for i = 1..n, such that s_i
+    in K[t, x] and q_i in K[t], and::
+
+                           ___    ___
+                 d  f   d  \  `   \  `
+                 -- - = --  )      )   a log(s_i(a, x))
+                 dx g   dx /__,   /__,
+                          i=1..n a | q_i(a) = 0
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.rationaltools import ratint_logpart
+    >>> from sympy.abc import x
+    >>> from sympy import Poly
+    >>> ratint_logpart(Poly(1, x, domain='ZZ'),
+    ... Poly(x**2 + x + 1, x, domain='ZZ'), x)
+    [(Poly(x + 3*_t/2 + 1/2, x, domain='QQ[_t]'),
+    ...Poly(3*_t**2 + 1, _t, domain='ZZ'))]
+    >>> ratint_logpart(Poly(12, x, domain='ZZ'),
+    ... Poly(x**2 - x - 2, x, domain='ZZ'), x)
+    [(Poly(x - 3*_t/8 - 1/2, x, domain='QQ[_t]'),
+    ...Poly(-_t**2 + 16, _t, domain='ZZ'))]
+
+    See Also
+    ========
+
+    ratint, ratint_ratpart
+    """
+    f, g = Poly(f, x), Poly(g, x)
+
+    t = t or Dummy('t')
+    a, b = g, f - g.diff()*Poly(t, x)
+
+    res, R = resultant(a, b, includePRS=True)
+    res = Poly(res, t, composite=False)
+
+    assert res, "BUG: resultant(%s, %s) cannot be zero" % (a, b)
+
+    R_map, H = {}, []
+
+    for r in R:
+        R_map[r.degree()] = r
+
+    def _include_sign(c, sqf):
+        if c.is_extended_real and (c < 0) == True:
+            h, k = sqf[0]
+            c_poly = c.as_poly(h.gens)
+            sqf[0] = h*c_poly, k
+
+    C, res_sqf = res.sqf_list()
+    _include_sign(C, res_sqf)
+
+    for q, i in res_sqf:
+        _, q = q.primitive()
+
+        if g.degree() == i:
+            H.append((g, q))
+        else:
+            h = R_map[i]
+            h_lc = Poly(h.LC(), t, field=True)
+
+            c, h_lc_sqf = h_lc.sqf_list(all=True)
+            _include_sign(c, h_lc_sqf)
+
+            for a, j in h_lc_sqf:
+                h = h.quo(Poly(a.gcd(q)**j, x))
+
+            inv, coeffs = h_lc.invert(q), [S.One]
+
+            for coeff in h.coeffs()[1:]:
+                coeff = coeff.as_poly(inv.gens)
+                T = (inv*coeff).rem(q)
+                coeffs.append(T.as_expr())
+
+            h = Poly(dict(list(zip(h.monoms(), coeffs))), x)
+
+            H.append((h, q))
+
+    return H
+
+
+def log_to_atan(f, g):
+    """
+    Convert complex logarithms to real arctangents.
+
+    Explanation
+    ===========
+
+    Given a real field K and polynomials f and g in K[x], with g != 0,
+    returns a sum h of arctangents of polynomials in K[x], such that:
+
+                   dh   d         f + I g
+                   -- = -- I log( ------- )
+                   dx   dx        f - I g
+
+    Examples
+    ========
+
+        >>> from sympy.integrals.rationaltools import log_to_atan
+        >>> from sympy.abc import x
+        >>> from sympy import Poly, sqrt, S
+        >>> log_to_atan(Poly(x, x, domain='ZZ'), Poly(1, x, domain='ZZ'))
+        2*atan(x)
+        >>> log_to_atan(Poly(x + S(1)/2, x, domain='QQ'),
+        ... Poly(sqrt(3)/2, x, domain='EX'))
+        2*atan(2*sqrt(3)*x/3 + sqrt(3)/3)
+
+    See Also
+    ========
+
+    log_to_real
+    """
+    if f.degree() < g.degree():
+        f, g = -g, f
+
+    f = f.to_field()
+    g = g.to_field()
+
+    p, q = f.div(g)
+
+    if q.is_zero:
+        return 2*atan(p.as_expr())
+    else:
+        s, t, h = g.gcdex(-f)
+        u = (f*s + g*t).quo(h)
+        A = 2*atan(u.as_expr())
+
+        return A + log_to_atan(s, t)
+
+
+def log_to_real(h, q, x, t):
+    r"""
+    Convert complex logarithms to real functions.
+
+    Explanation
+    ===========
+
+    Given real field K and polynomials h in K[t,x] and q in K[t],
+    returns real function f such that:
+                          ___
+                  df   d  \  `
+                  -- = --  )  a log(h(a, x))
+                  dx   dx /__,
+                         a | q(a) = 0
+
+    Examples
+    ========
+
+        >>> from sympy.integrals.rationaltools import log_to_real
+        >>> from sympy.abc import x, y
+        >>> from sympy import Poly, S
+        >>> log_to_real(Poly(x + 3*y/2 + S(1)/2, x, domain='QQ[y]'),
+        ... Poly(3*y**2 + 1, y, domain='ZZ'), x, y)
+        2*sqrt(3)*atan(2*sqrt(3)*x/3 + sqrt(3)/3)/3
+        >>> log_to_real(Poly(x**2 - 1, x, domain='ZZ'),
+        ... Poly(-2*y + 1, y, domain='ZZ'), x, y)
+        log(x**2 - 1)/2
+
+    See Also
+    ========
+
+    log_to_atan
+    """
+    from sympy.simplify.radsimp import collect
+    u, v = symbols('u,v', cls=Dummy)
+
+    H = h.as_expr().xreplace({t: u + I*v}).expand()
+    Q = q.as_expr().xreplace({t: u + I*v}).expand()
+
+    H_map = collect(H, I, evaluate=False)
+    Q_map = collect(Q, I, evaluate=False)
+
+    a, b = H_map.get(S.One, S.Zero), H_map.get(I, S.Zero)
+    c, d = Q_map.get(S.One, S.Zero), Q_map.get(I, S.Zero)
+
+    R = Poly(resultant(c, d, v), u)
+
+    R_u = roots(R, filter='R')
+
+    if len(R_u) != R.count_roots():
+        return None
+
+    result = S.Zero
+
+    for r_u in R_u.keys():
+        C = Poly(c.xreplace({u: r_u}), v)
+        if not C:
+            # t was split into real and imaginary parts
+            # and denom Q(u, v) = c + I*d. We just found
+            # that c(r_u) is 0 so the roots are in d
+            C = Poly(d.xreplace({u: r_u}), v)
+            # we were going to reject roots from C that
+            # did not set d to zero, but since we are now
+            # using C = d and c is already 0, there is
+            # nothing to check
+            d = S.Zero
+
+        R_v = roots(C, filter='R')
+
+        if len(R_v) != C.count_roots():
+            return None
+
+        R_v_paired = [] # take one from each pair of conjugate roots
+        for r_v in R_v:
+            if r_v not in R_v_paired and -r_v not in R_v_paired:
+                if r_v.is_negative or r_v.could_extract_minus_sign():
+                    R_v_paired.append(-r_v)
+                elif not r_v.is_zero:
+                    R_v_paired.append(r_v)
+
+        for r_v in R_v_paired:
+
+            D = d.xreplace({u: r_u, v: r_v})
+
+            if D.evalf(chop=True) != 0:
+                continue
+
+            A = Poly(a.xreplace({u: r_u, v: r_v}), x)
+            B = Poly(b.xreplace({u: r_u, v: r_v}), x)
+
+            AB = (A**2 + B**2).as_expr()
+
+            result += r_u*log(AB) + r_v*log_to_atan(A, B)
+
+    R_q = roots(q, filter='R')
+
+    if len(R_q) != q.count_roots():
+        return None
+
+    for r in R_q.keys():
+        result += r*log(h.as_expr().subs(t, r))
+
+    return result

parrot/lib/python3.10/site-packages/sympy/integrals/singularityfunctions.py

@@ -0,0 +1,63 @@
+from sympy.functions import SingularityFunction, DiracDelta
+from sympy.integrals import integrate
+
+
+def singularityintegrate(f, x):
+    """
+    This function handles the indefinite integrations of Singularity functions.
+    The ``integrate`` function calls this function internally whenever an
+    instance of SingularityFunction is passed as argument.
+
+    Explanation
+    ===========
+
+    The idea for integration is the following:
+
+    - If we are dealing with a SingularityFunction expression,
+      i.e. ``SingularityFunction(x, a, n)``, we just return
+      ``SingularityFunction(x, a, n + 1)/(n + 1)`` if ``n >= 0`` and
+      ``SingularityFunction(x, a, n + 1)`` if ``n < 0``.
+
+    - If the node is a multiplication or power node having a
+      SingularityFunction term we rewrite the whole expression in terms of
+      Heaviside and DiracDelta and then integrate the output. Lastly, we
+      rewrite the output of integration back in terms of SingularityFunction.
+
+    - If none of the above case arises, we return None.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.singularityfunctions import singularityintegrate
+    >>> from sympy import SingularityFunction, symbols, Function
+    >>> x, a, n, y = symbols('x a n y')
+    >>> f = Function('f')
+    >>> singularityintegrate(SingularityFunction(x, a, 3), x)
+    SingularityFunction(x, a, 4)/4
+    >>> singularityintegrate(5*SingularityFunction(x, 5, -2), x)
+    5*SingularityFunction(x, 5, -1)
+    >>> singularityintegrate(6*SingularityFunction(x, 5, -1), x)
+    6*SingularityFunction(x, 5, 0)
+    >>> singularityintegrate(x*SingularityFunction(x, 0, -1), x)
+    0
+    >>> singularityintegrate(SingularityFunction(x, 1, -1) * f(x), x)
+    f(1)*SingularityFunction(x, 1, 0)
+
+    """
+
+    if not f.has(SingularityFunction):
+        return None
+
+    if isinstance(f, SingularityFunction):
+        x, a, n = f.args
+        if n.is_positive or n.is_zero:
+            return SingularityFunction(x, a, n + 1)/(n + 1)
+        elif n in (-1, -2, -3, -4):
+            return SingularityFunction(x, a, n + 1)
+
+    if f.is_Mul or f.is_Pow:
+
+        expr = f.rewrite(DiracDelta)
+        expr = integrate(expr, x)
+        return expr.rewrite(SingularityFunction)
+    return None

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_deltafunctions.py

@@ -0,0 +1,79 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.integrals.deltafunctions import change_mul, deltaintegrate
+
+f = Function("f")
+x_1, x_2, x, y, z = symbols("x_1 x_2 x y z")
+
+
+def test_change_mul():
+    assert change_mul(x, x) == (None, None)
+    assert change_mul(x*y, x) == (None, None)
+    assert change_mul(x*y*DiracDelta(x), x) == (DiracDelta(x), x*y)
+    assert change_mul(x*y*DiracDelta(x)*DiracDelta(y), x) == \
+        (DiracDelta(x), x*y*DiracDelta(y))
+    assert change_mul(DiracDelta(x)**2, x) == \
+        (DiracDelta(x), DiracDelta(x))
+    assert change_mul(y*DiracDelta(x)**2, x) == \
+        (DiracDelta(x), y*DiracDelta(x))
+
+
+def test_deltaintegrate():
+    assert deltaintegrate(x, x) is None
+    assert deltaintegrate(x + DiracDelta(x), x) is None
+    assert deltaintegrate(DiracDelta(x, 0), x) == Heaviside(x)
+    for n in range(10):
+        assert deltaintegrate(DiracDelta(x, n + 1), x) == DiracDelta(x, n)
+    assert deltaintegrate(DiracDelta(x), x) == Heaviside(x)
+    assert deltaintegrate(DiracDelta(-x), x) == Heaviside(x)
+    assert deltaintegrate(DiracDelta(x - y), x) == Heaviside(x - y)
+    assert deltaintegrate(DiracDelta(y - x), x) == Heaviside(x - y)
+
+    assert deltaintegrate(x*DiracDelta(x), x) == 0
+    assert deltaintegrate((x - y)*DiracDelta(x - y), x) == 0
+
+    assert deltaintegrate(DiracDelta(x)**2, x) == DiracDelta(0)*Heaviside(x)
+    assert deltaintegrate(y*DiracDelta(x)**2, x) == \
+        y*DiracDelta(0)*Heaviside(x)
+    assert deltaintegrate(DiracDelta(x, 1), x) == DiracDelta(x, 0)
+    assert deltaintegrate(y*DiracDelta(x, 1), x) == y*DiracDelta(x, 0)
+    assert deltaintegrate(DiracDelta(x, 1)**2, x) == -DiracDelta(0, 2)*Heaviside(x)
+    assert deltaintegrate(y*DiracDelta(x, 1)**2, x) == -y*DiracDelta(0, 2)*Heaviside(x)
+
+
+    assert deltaintegrate(DiracDelta(x) * f(x), x) == f(0) * Heaviside(x)
+    assert deltaintegrate(DiracDelta(-x) * f(x), x) == f(0) * Heaviside(x)
+    assert deltaintegrate(DiracDelta(x - 1) * f(x), x) == f(1) * Heaviside(x - 1)
+    assert deltaintegrate(DiracDelta(1 - x) * f(x), x) == f(1) * Heaviside(x - 1)
+    assert deltaintegrate(DiracDelta(x**2 + x - 2), x) == \
+        Heaviside(x - 1)/3 + Heaviside(x + 2)/3
+
+    p = cos(x)*(DiracDelta(x) + DiracDelta(x**2 - 1))*sin(x)*(x - pi)
+    assert deltaintegrate(p, x) - (-pi*(cos(1)*Heaviside(-1 + x)*sin(1)/2 - \
+        cos(1)*Heaviside(1 + x)*sin(1)/2) + \
+        cos(1)*Heaviside(1 + x)*sin(1)/2 + \
+        cos(1)*Heaviside(-1 + x)*sin(1)/2) == 0
+
+    p = x_2*DiracDelta(x - x_2)*DiracDelta(x_2 - x_1)
+    assert deltaintegrate(p, x_2) == x*DiracDelta(x - x_1)*Heaviside(x_2 - x)
+
+    p = x*y**2*z*DiracDelta(y - x)*DiracDelta(y - z)*DiracDelta(x - z)
+    assert deltaintegrate(p, y) == x**3*z*DiracDelta(x - z)**2*Heaviside(y - x)
+    assert deltaintegrate((x + 1)*DiracDelta(2*x), x) == S.Half * Heaviside(x)
+    assert deltaintegrate((x + 1)*DiracDelta(x*Rational(2, 3) + Rational(4, 9)), x) == \
+        S.Half * Heaviside(x + Rational(2, 3))
+
+    a, b, c = symbols('a b c', commutative=False)
+    assert deltaintegrate(DiracDelta(x - y)*f(x - b)*f(x - a), x) == \
+        f(y - b)*f(y - a)*Heaviside(x - y)
+
+    p = f(x - a)*DiracDelta(x - y)*f(x - c)*f(x - b)
+    assert deltaintegrate(p, x) == f(y - a)*f(y - c)*f(y - b)*Heaviside(x - y)
+
+    p = DiracDelta(x - z)*f(x - b)*f(x - a)*DiracDelta(x - y)
+    assert deltaintegrate(p, x) == DiracDelta(y - z)*f(y - b)*f(y - a) * \
+        Heaviside(x - y)

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_failing_integrals.py

@@ -0,0 +1,277 @@
+# A collection of failing integrals from the issues.
+
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (sech, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, atan, cos, sin, tan)
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.simplify.fu import fu
+
+
+from sympy.testing.pytest import XFAIL, slow, tooslow
+
+from sympy.abc import x, k, c, y, b, h, a, m, z, n, t
+
+
+@tooslow
+@XFAIL
+def test_issue_3880():
+    # integrate_hyperexponential(Poly(t*2*(1 - t0**2)*t0*(x**3 + x**2), t), Poly((1 + t0**2)**2*2*(x**2 + x + 1), t), [Poly(1, x), Poly(1 + t0**2, t0), Poly(t, t)], [x, t0, t], [exp, tan])
+    assert not integrate(exp(x)*cos(2*x)*sin(2*x) * (x**3 + x**2)/(2*(x**2 + x + 1)), x).has(Integral)
+
+
+def test_issue_4212_real():
+    xr = symbols('xr', real=True)
+    negabsx = Piecewise((-xr, xr < 0), (xr, True))
+    assert integrate(sign(xr), xr) == negabsx
+
+
+@XFAIL
+def test_issue_4212():
+    # XXX: Maybe this should be expected to fail without real assumptions on x.
+    # As a complex function sign(x) is not analytic and so there is no complex
+    # function whose complex derivative is sign(x). With real assumptions this
+    # works (see test_issue_4212_real above).
+    assert not integrate(sign(x), x).has(Integral)
+
+
+def test_issue_4511():
+    # This works, but gives a slightly over-complicated answer.
+    f = integrate(cos(x)**2 / (1 - sin(x)), x)
+    assert fu(f) == x - cos(x) - 1
+    assert f == ((x*tan(x/2)**2 + x - 2)/(tan(x/2)**2 + 1)).expand()
+
+
+def test_integrate_DiracDelta_no_meijerg():
+    assert integrate(integrate(integrate(
+        DiracDelta(x - y - z), (z, 0, oo)), (y, 0, 1), meijerg=False), (x, 0, 1)) == S.Half
+
+
+@XFAIL
+def test_integrate_DiracDelta_fails():
+    # issue 6427
+    # works without meijerg. See test_integrate_DiracDelta_no_meijerg above.
+    assert integrate(integrate(integrate(
+        DiracDelta(x - y - z), (z, 0, oo)), (y, 0, 1)), (x, 0, 1)) == S.Half
+
+
+@XFAIL
+@slow
+def test_issue_4525():
+    # Warning: takes a long time
+    assert not integrate((x**m * (1 - x)**n * (a + b*x + c*x**2))/(1 + x**2), (x, 0, 1)).has(Integral)
+
+
+@XFAIL
+@tooslow
+def test_issue_4540():
+    # Note, this integral is probably nonelementary
+    assert not integrate(
+        (sin(1/x) - x*exp(x)) /
+        ((-sin(1/x) + x*exp(x))*x + x*sin(1/x)), x).has(Integral)
+
+
+@XFAIL
+@slow
+def test_issue_4891():
+    # Requires the hypergeometric function.
+    assert not integrate(cos(x)**y, x).has(Integral)
+
+
+@XFAIL
+@slow
+def test_issue_1796a():
+    assert not integrate(exp(2*b*x)*exp(-a*x**2), x).has(Integral)
+
+
+@XFAIL
+def test_issue_4895b():
+    assert not integrate(exp(2*b*x)*exp(-a*x**2), (x, -oo, 0)).has(Integral)
+
+
+@XFAIL
+def test_issue_4895c():
+    assert not integrate(exp(2*b*x)*exp(-a*x**2), (x, -oo, oo)).has(Integral)
+
+
+@XFAIL
+def test_issue_4895d():
+    assert not integrate(exp(2*b*x)*exp(-a*x**2), (x, 0, oo)).has(Integral)
+
+
+@XFAIL
+@slow
+def test_issue_4941():
+    assert not integrate(sqrt(1 + sinh(x/20)**2), (x, -25, 25)).has(Integral)
+
+
+@XFAIL
+def test_issue_4992():
+    # Nonelementary integral.  Requires hypergeometric/Meijer-G handling.
+    assert not integrate(log(x) * x**(k - 1) * exp(-x) / gamma(k), (x, 0, oo)).has(Integral)
+
+
+@XFAIL
+def test_issue_16396a():
+    i = integrate(1/(1+sqrt(tan(x))), (x, pi/3, pi/6))
+    assert not i.has(Integral)
+
+
+@XFAIL
+def test_issue_16396b():
+    i = integrate(x*sin(x)/(1+cos(x)**2), (x, 0, pi))
+    assert not i.has(Integral)
+
+
+@XFAIL
+def test_issue_16046():
+    assert integrate(exp(exp(I*x)), [x, 0, 2*pi]) == 2*pi
+
+
+@XFAIL
+def test_issue_15925a():
+    assert not integrate(sqrt((1+sin(x))**2+(cos(x))**2), (x, -pi/2, pi/2)).has(Integral)
+
+
+def test_issue_15925b():
+    f = sqrt((-12*cos(x)**2*sin(x))**2+(12*cos(x)*sin(x)**2)**2)
+    assert integrate(f, (x, 0, pi/6)) == Rational(3, 2)
+
+
+@XFAIL
+def test_issue_15925b_manual():
+    assert not integrate(sqrt((-12*cos(x)**2*sin(x))**2+(12*cos(x)*sin(x)**2)**2),
+                         (x, 0, pi/6), manual=True).has(Integral)
+
+
+@XFAIL
+@tooslow
+def test_issue_15227():
+    i = integrate(log(1-x)*log((1+x)**2)/x, (x, 0, 1))
+    assert not i.has(Integral)
+    # assert i == -5*zeta(3)/4
+
+
+@XFAIL
+@slow
+def test_issue_14716():
+    i = integrate(log(x + 5)*cos(pi*x),(x, S.Half, 1))
+    assert not i.has(Integral)
+    # Mathematica can not solve it either, but
+    # integrate(log(x + 5)*cos(pi*x),(x, S.Half, 1)).transform(x, y - 5).doit()
+    # works
+    # assert i == -log(Rational(11, 2))/pi - Si(pi*Rational(11, 2))/pi + Si(6*pi)/pi
+
+
+@XFAIL
+def test_issue_14709a():
+    i = integrate(x*acos(1 - 2*x/h), (x, 0, h))
+    assert not i.has(Integral)
+    # assert i == 5*h**2*pi/16
+
+
+@slow
+@XFAIL
+def test_issue_14398():
+    assert not integrate(exp(x**2)*cos(x), x).has(Integral)
+
+
+@XFAIL
+def test_issue_14074():
+    i = integrate(log(sin(x)), (x, 0, pi/2))
+    assert not i.has(Integral)
+    # assert i == -pi*log(2)/2
+
+
+@XFAIL
+@slow
+def test_issue_14078b():
+    i = integrate((atan(4*x)-atan(2*x))/x, (x, 0, oo))
+    assert not i.has(Integral)
+    # assert i == pi*log(2)/2
+
+
+@XFAIL
+def test_issue_13792():
+    i =  integrate(log(1/x) / (1 - x), (x, 0, 1))
+    assert not i.has(Integral)
+    # assert i in [polylog(2, -exp_polar(I*pi)), pi**2/6]
+
+
+@XFAIL
+def test_issue_11845a():
+    assert not integrate(exp(y - x**3), (x, 0, 1)).has(Integral)
+
+
+@XFAIL
+def test_issue_11845b():
+    assert not integrate(exp(-y - x**3), (x, 0, 1)).has(Integral)
+
+
+@XFAIL
+def test_issue_11813():
+    assert not integrate((a - x)**Rational(-1, 2)*x, (x, 0, a)).has(Integral)
+
+
+@XFAIL
+def test_issue_11254c():
+    assert not integrate(sech(x)**2, (x, 0, 1)).has(Integral)
+
+
+@XFAIL
+def test_issue_10584():
+    assert not integrate(sqrt(x**2 + 1/x**2), x).has(Integral)
+
+
+@XFAIL
+def test_issue_9101():
+    assert not integrate(log(x + sqrt(x**2 + y**2 + z**2)), z).has(Integral)
+
+
+@XFAIL
+def test_issue_7147():
+    assert not integrate(x/sqrt(a*x**2 + b*x + c)**3, x).has(Integral)
+
+
+@XFAIL
+def test_issue_7109():
+    assert not integrate(sqrt(a**2/(a**2 - x**2)), x).has(Integral)
+
+
+@XFAIL
+def test_integrate_Piecewise_rational_over_reals():
+    f = Piecewise(
+        (0,                                              t - 478.515625*pi <  0),
+        (13.2075145209219*pi/(0.000871222*t + 0.995)**2, t - 478.515625*pi >= 0))
+
+    assert abs((integrate(f, (t, 0, oo)) - 15235.9375*pi).evalf()) <= 1e-7
+
+
+@XFAIL
+def test_issue_4311_slow():
+    # Not slow when bypassing heurish
+    assert not integrate(x*abs(9-x**2), x).has(Integral)
+
+@XFAIL
+def test_issue_20370():
+    a = symbols('a', positive=True)
+    assert integrate((1 + a * cos(x))**-1, (x, 0, 2 * pi)) == (2 * pi / sqrt(1 - a**2))
+
+
+@XFAIL
+def test_polylog():
+    # log(1/x)*log(x+1)-polylog(2, -x)
+    assert not integrate(log(1/x)/(x + 1), x).has(Integral)
+
+
+@XFAIL
+def test_polylog_manual():
+    # Make sure _parts_rule does not go into an infinite loop here
+    assert not integrate(log(1/x)/(x + 1), x, manual=True).has(Integral)

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_heurisch.py

@@ -0,0 +1,419 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq, Ne
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (LambertW, exp, log)
+from sympy.functions.elementary.hyperbolic import (asinh, cosh, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, tan)
+from sympy.functions.special.bessel import (besselj, besselk, bessely, jn)
+from sympy.functions.special.error_functions import erf
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And
+from sympy.matrices import Matrix
+from sympy.simplify.ratsimp import ratsimp
+from sympy.simplify.simplify import simplify
+from sympy.integrals.heurisch import components, heurisch, heurisch_wrapper
+from sympy.testing.pytest import XFAIL, slow
+from sympy.integrals.integrals import integrate
+from sympy import S
+
+x, y, z, nu = symbols('x,y,z,nu')
+f = Function('f')
+
+
+def test_components():
+    assert components(x*y, x) == {x}
+    assert components(1/(x + y), x) == {x}
+    assert components(sin(x), x) == {sin(x), x}
+    assert components(sin(x)*sqrt(log(x)), x) == \
+        {log(x), sin(x), sqrt(log(x)), x}
+    assert components(x*sin(exp(x)*y), x) == \
+        {sin(y*exp(x)), x, exp(x)}
+    assert components(x**Rational(17, 54)/sqrt(sin(x)), x) == \
+        {sin(x), x**Rational(1, 54), sqrt(sin(x)), x}
+
+    assert components(f(x), x) == \
+        {x, f(x)}
+    assert components(Derivative(f(x), x), x) == \
+        {x, f(x), Derivative(f(x), x)}
+    assert components(f(x)*diff(f(x), x), x) == \
+        {x, f(x), Derivative(f(x), x), Derivative(f(x), x)}
+
+
+def test_issue_10680():
+    assert isinstance(integrate(x**log(x**log(x**log(x))),x), Integral)
+
+
+def test_issue_21166():
+    assert integrate(sin(x/sqrt(abs(x))), (x, -1, 1)) == 0
+
+
+def test_heurisch_polynomials():
+    assert heurisch(1, x) == x
+    assert heurisch(x, x) == x**2/2
+    assert heurisch(x**17, x) == x**18/18
+    # For coverage
+    assert heurisch_wrapper(y, x) == y*x
+
+
+def test_heurisch_fractions():
+    assert heurisch(1/x, x) == log(x)
+    assert heurisch(1/(2 + x), x) == log(x + 2)
+    assert heurisch(1/(x + sin(y)), x) == log(x + sin(y))
+
+    # Up to a constant, where C = pi*I*Rational(5, 12), Mathematica gives identical
+    # result in the first case. The difference is because SymPy changes
+    # signs of expressions without any care.
+    # XXX ^ ^ ^ is this still correct?
+    assert heurisch(5*x**5/(
+        2*x**6 - 5), x) in [5*log(2*x**6 - 5) / 12, 5*log(-2*x**6 + 5) / 12]
+    assert heurisch(5*x**5/(2*x**6 + 5), x) == 5*log(2*x**6 + 5) / 12
+
+    assert heurisch(1/x**2, x) == -1/x
+    assert heurisch(-1/x**5, x) == 1/(4*x**4)
+
+
+def test_heurisch_log():
+    assert heurisch(log(x), x) == x*log(x) - x
+    assert heurisch(log(3*x), x) == -x + x*log(3) + x*log(x)
+    assert heurisch(log(x**2), x) in [x*log(x**2) - 2*x, 2*x*log(x) - 2*x]
+
+
+def test_heurisch_exp():
+    assert heurisch(exp(x), x) == exp(x)
+    assert heurisch(exp(-x), x) == -exp(-x)
+    assert heurisch(exp(17*x), x) == exp(17*x) / 17
+    assert heurisch(x*exp(x), x) == x*exp(x) - exp(x)
+    assert heurisch(x*exp(x**2), x) == exp(x**2) / 2
+
+    assert heurisch(exp(-x**2), x) is None
+
+    assert heurisch(2**x, x) == 2**x/log(2)
+    assert heurisch(x*2**x, x) == x*2**x/log(2) - 2**x*log(2)**(-2)
+
+    assert heurisch(Integral(x**z*y, (y, 1, 2), (z, 2, 3)).function, x) == (x*x**z*y)/(z+1)
+    assert heurisch(Sum(x**z, (z, 1, 2)).function, z) == x**z/log(x)
+
+    # https://github.com/sympy/sympy/issues/23707
+    anti = -exp(z)/(sqrt(x - y)*exp(z*sqrt(x - y)) - exp(z*sqrt(x - y)))
+    assert heurisch(exp(z)*exp(-z*sqrt(x - y)), z) == anti
+
+
+def test_heurisch_trigonometric():
+    assert heurisch(sin(x), x) == -cos(x)
+    assert heurisch(pi*sin(x) + 1, x) == x - pi*cos(x)
+
+    assert heurisch(cos(x), x) == sin(x)
+    assert heurisch(tan(x), x) in [
+        log(1 + tan(x)**2)/2,
+        log(tan(x) + I) + I*x,
+        log(tan(x) - I) - I*x,
+    ]
+
+    assert heurisch(sin(x)*sin(y), x) == -cos(x)*sin(y)
+    assert heurisch(sin(x)*sin(y), y) == -cos(y)*sin(x)
+
+    # gives sin(x) in answer when run via setup.py and cos(x) when run via py.test
+    assert heurisch(sin(x)*cos(x), x) in [sin(x)**2 / 2, -cos(x)**2 / 2]
+    assert heurisch(cos(x)/sin(x), x) == log(sin(x))
+
+    assert heurisch(x*sin(7*x), x) == sin(7*x) / 49 - x*cos(7*x) / 7
+    assert heurisch(1/pi/4 * x**2*cos(x), x) == 1/pi/4*(x**2*sin(x) -
+                    2*sin(x) + 2*x*cos(x))
+
+    assert heurisch(acos(x/4) * asin(x/4), x) == 2*x - (sqrt(16 - x**2))*asin(x/4) \
+        + (sqrt(16 - x**2))*acos(x/4) + x*asin(x/4)*acos(x/4)
+
+    assert heurisch(sin(x)/(cos(x)**2+1), x) == -atan(cos(x)) #fixes issue 13723
+    assert heurisch(1/(cos(x)+2), x) == 2*sqrt(3)*atan(sqrt(3)*tan(x/2)/3)/3
+    assert heurisch(2*sin(x)*cos(x)/(sin(x)**4 + 1), x) == atan(sqrt(2)*sin(x)
+        - 1) - atan(sqrt(2)*sin(x) + 1)
+
+    assert heurisch(1/cosh(x), x) == 2*atan(tanh(x/2))
+
+
+def test_heurisch_hyperbolic():
+    assert heurisch(sinh(x), x) == cosh(x)
+    assert heurisch(cosh(x), x) == sinh(x)
+
+    assert heurisch(x*sinh(x), x) == x*cosh(x) - sinh(x)
+    assert heurisch(x*cosh(x), x) == x*sinh(x) - cosh(x)
+
+    assert heurisch(
+        x*asinh(x/2), x) == x**2*asinh(x/2)/2 + asinh(x/2) - x*sqrt(4 + x**2)/4
+
+
+def test_heurisch_mixed():
+    assert heurisch(sin(x)*exp(x), x) == exp(x)*sin(x)/2 - exp(x)*cos(x)/2
+    assert heurisch(sin(x/sqrt(-x)), x) == 2*x*cos(x/sqrt(-x))/sqrt(-x) - 2*sin(x/sqrt(-x))
+
+
+def test_heurisch_radicals():
+    assert heurisch(1/sqrt(x), x) == 2*sqrt(x)
+    assert heurisch(1/sqrt(x)**3, x) == -2/sqrt(x)
+    assert heurisch(sqrt(x)**3, x) == 2*sqrt(x)**5/5
+
+    assert heurisch(sin(x)*sqrt(cos(x)), x) == -2*sqrt(cos(x))**3/3
+    y = Symbol('y')
+    assert heurisch(sin(y*sqrt(x)), x) == 2/y**2*sin(y*sqrt(x)) - \
+        2*sqrt(x)*cos(y*sqrt(x))/y
+    assert heurisch_wrapper(sin(y*sqrt(x)), x) == Piecewise(
+        (-2*sqrt(x)*cos(sqrt(x)*y)/y + 2*sin(sqrt(x)*y)/y**2, Ne(y, 0)),
+        (0, True))
+    y = Symbol('y', positive=True)
+    assert heurisch_wrapper(sin(y*sqrt(x)), x) == 2/y**2*sin(y*sqrt(x)) - \
+        2*sqrt(x)*cos(y*sqrt(x))/y
+
+
+def test_heurisch_special():
+    assert heurisch(erf(x), x) == x*erf(x) + exp(-x**2)/sqrt(pi)
+    assert heurisch(exp(-x**2)*erf(x), x) == sqrt(pi)*erf(x)**2 / 4
+
+
+def test_heurisch_symbolic_coeffs():
+    assert heurisch(1/(x + y), x) == log(x + y)
+    assert heurisch(1/(x + sqrt(2)), x) == log(x + sqrt(2))
+    assert simplify(diff(heurisch(log(x + y + z), y), y)) == log(x + y + z)
+
+
+def test_heurisch_symbolic_coeffs_1130():
+    y = Symbol('y')
+    assert heurisch_wrapper(1/(x**2 + y), x) == Piecewise(
+    (log(x - sqrt(-y))/(2*sqrt(-y)) - log(x + sqrt(-y))/(2*sqrt(-y)),
+    Ne(y, 0)), (-1/x, True))
+    y = Symbol('y', positive=True)
+    assert heurisch_wrapper(1/(x**2 + y), x) == (atan(x/sqrt(y))/sqrt(y))
+
+
+def test_heurisch_hacking():
+    assert heurisch(sqrt(1 + 7*x**2), x, hints=[]) == \
+        x*sqrt(1 + 7*x**2)/2 + sqrt(7)*asinh(sqrt(7)*x)/14
+    assert heurisch(sqrt(1 - 7*x**2), x, hints=[]) == \
+        x*sqrt(1 - 7*x**2)/2 + sqrt(7)*asin(sqrt(7)*x)/14
+
+    assert heurisch(1/sqrt(1 + 7*x**2), x, hints=[]) == \
+        sqrt(7)*asinh(sqrt(7)*x)/7
+    assert heurisch(1/sqrt(1 - 7*x**2), x, hints=[]) == \
+        sqrt(7)*asin(sqrt(7)*x)/7
+
+    assert heurisch(exp(-7*x**2), x, hints=[]) == \
+        sqrt(7*pi)*erf(sqrt(7)*x)/14
+
+    assert heurisch(1/sqrt(9 - 4*x**2), x, hints=[]) == \
+        asin(x*Rational(2, 3))/2
+
+    assert heurisch(1/sqrt(9 + 4*x**2), x, hints=[]) == \
+        asinh(x*Rational(2, 3))/2
+
+    assert heurisch(1/sqrt(3*x**2-4), x, hints=[]) == \
+           sqrt(3)*log(3*x + sqrt(3)*sqrt(3*x**2 - 4))/3
+
+
+def test_heurisch_function():
+    assert heurisch(f(x), x) is None
+
+@XFAIL
+def test_heurisch_function_derivative():
+    # TODO: it looks like this used to work just by coincindence and
+    # thanks to sloppy implementation. Investigate why this used to
+    # work at all and if support for this can be restored.
+
+    df = diff(f(x), x)
+
+    assert heurisch(f(x)*df, x) == f(x)**2/2
+    assert heurisch(f(x)**2*df, x) == f(x)**3/3
+    assert heurisch(df/f(x), x) == log(f(x))
+
+
+def test_heurisch_wrapper():
+    f = 1/(y + x)
+    assert heurisch_wrapper(f, x) == log(x + y)
+    f = 1/(y - x)
+    assert heurisch_wrapper(f, x) == -log(x - y)
+    f = 1/((y - x)*(y + x))
+    assert heurisch_wrapper(f, x) == Piecewise(
+        (-log(x - y)/(2*y) + log(x + y)/(2*y), Ne(y, 0)), (1/x, True))
+    # issue 6926
+    f = sqrt(x**2/((y - x)*(y + x)))
+    assert heurisch_wrapper(f, x) == x*sqrt(-x**2/(x**2 - y**2)) \
+    - y**2*sqrt(-x**2/(x**2 - y**2))/x
+
+
+def test_issue_3609():
+    assert heurisch(1/(x * (1 + log(x)**2)), x) == atan(log(x))
+
+### These are examples from the Poor Man's Integrator
+### http://www-sop.inria.fr/cafe/Manuel.Bronstein/pmint/examples/
+
+
+def test_pmint_rat():
+    # TODO: heurisch() is off by a constant: -3/4. Possibly different permutation
+    # would give the optimal result?
+
+    def drop_const(expr, x):
+        if expr.is_Add:
+            return Add(*[ arg for arg in expr.args if arg.has(x) ])
+        else:
+            return expr
+
+    f = (x**7 - 24*x**4 - 4*x**2 + 8*x - 8)/(x**8 + 6*x**6 + 12*x**4 + 8*x**2)
+    g = (4 + 8*x**2 + 6*x + 3*x**3)/(x**5 + 4*x**3 + 4*x) + log(x)
+
+    assert drop_const(ratsimp(heurisch(f, x)), x) == g
+
+
+def test_pmint_trig():
+    f = (x - tan(x)) / tan(x)**2 + tan(x)
+    g = -x**2/2 - x/tan(x) + log(tan(x)**2 + 1)/2
+
+    assert heurisch(f, x) == g
+
+
+def test_pmint_logexp():
+    f = (1 + x + x*exp(x))*(x + log(x) + exp(x) - 1)/(x + log(x) + exp(x))**2/x
+    g = log(x + exp(x) + log(x)) + 1/(x + exp(x) + log(x))
+
+    assert ratsimp(heurisch(f, x)) == g
+
+
+def test_pmint_erf():
+    f = exp(-x**2)*erf(x)/(erf(x)**3 - erf(x)**2 - erf(x) + 1)
+    g = sqrt(pi)*log(erf(x) - 1)/8 - sqrt(pi)*log(erf(x) + 1)/8 - sqrt(pi)/(4*erf(x) - 4)
+
+    assert ratsimp(heurisch(f, x)) == g
+
+
+def test_pmint_LambertW():
+    f = LambertW(x)
+    g = x*LambertW(x) - x + x/LambertW(x)
+
+    assert heurisch(f, x) == g
+
+
+def test_pmint_besselj():
+    f = besselj(nu + 1, x)/besselj(nu, x)
+    g = nu*log(x) - log(besselj(nu, x))
+
+    assert heurisch(f, x) == g
+
+    f = (nu*besselj(nu, x) - x*besselj(nu + 1, x))/x
+    g = besselj(nu, x)
+
+    assert heurisch(f, x) == g
+
+    f = jn(nu + 1, x)/jn(nu, x)
+    g = nu*log(x) - log(jn(nu, x))
+
+    assert heurisch(f, x) == g
+
+
+@slow
+def test_pmint_bessel_products():
+    f = x*besselj(nu, x)*bessely(nu, 2*x)
+    g = -2*x*besselj(nu, x)*bessely(nu - 1, 2*x)/3 + x*besselj(nu - 1, x)*bessely(nu, 2*x)/3
+
+    assert heurisch(f, x) == g
+
+    f = x*besselj(nu, x)*besselk(nu, 2*x)
+    g = -2*x*besselj(nu, x)*besselk(nu - 1, 2*x)/5 - x*besselj(nu - 1, x)*besselk(nu, 2*x)/5
+
+    assert heurisch(f, x) == g
+
+
+def test_pmint_WrightOmega():
+    def omega(x):
+        return LambertW(exp(x))
+
+    f = (1 + omega(x) * (2 + cos(omega(x)) * (x + omega(x))))/(1 + omega(x))/(x + omega(x))
+    g = log(x + LambertW(exp(x))) + sin(LambertW(exp(x)))
+
+    assert heurisch(f, x) == g
+
+
+def test_RR():
+    # Make sure the algorithm does the right thing if the ring is RR. See
+    # issue 8685.
+    assert heurisch(sqrt(1 + 0.25*x**2), x, hints=[]) == \
+        0.5*x*sqrt(0.25*x**2 + 1) + 1.0*asinh(0.5*x)
+
+# TODO: convert the rest of PMINT tests:
+# Airy functions
+# f = (x - AiryAi(x)*AiryAi(1, x)) / (x**2 - AiryAi(x)**2)
+# g = Rational(1,2)*ln(x + AiryAi(x)) + Rational(1,2)*ln(x - AiryAi(x))
+# f = x**2 * AiryAi(x)
+# g = -AiryAi(x) + AiryAi(1, x)*x
+# Whittaker functions
+# f = WhittakerW(mu + 1, nu, x) / (WhittakerW(mu, nu, x) * x)
+# g = x/2 - mu*ln(x) - ln(WhittakerW(mu, nu, x))
+
+
+def test_issue_22527():
+    t, R = symbols(r't R')
+    z = Function('z')(t)
+    def f(x):
+      return x/sqrt(R**2 - x**2)
+    Uz = integrate(f(z), z)
+    Ut = integrate(f(t), t)
+    assert Ut == Uz.subs(z, t)
+
+
+def test_heurisch_complex_erf_issue_26338():
+    r = symbols('r', real=True)
+    a = exp(-r**2/(2*(2 - I)**2))
+    assert heurisch(a, r, hints=[]) is None  # None, not a wrong soln
+    a = sqrt(pi)*erf((1 + I)/2)/2
+    assert integrate(exp(-I*r**2/2), (r, 0, 1)) == a - I*a
+
+    a = exp(-x**2/(2*(2 - I)**2))
+    assert heurisch(a, x, hints=[]) is None  # None, not a wrong soln
+    a = exp(-r**2/(2*(2 - I)**2))
+    assert heurisch(a, r, hints=[]) is None
+    a = sqrt(pi)*erf((1 + I)/2)/2
+    assert integrate(exp(-I*x**2/2), (x, 0, 1)) == a - I*a
+
+
+def test_issue_15498():
+    Z0 = Function('Z0')
+    k01, k10, t, s= symbols('k01 k10 t s', real=True, positive=True)
+    m = Matrix([[exp(-k10*t)]])
+    _83 = Rational(83, 100)  # 0.83 works, too
+    [a, b, c, d, e, f, g] = [100, 0.5, _83, 50, 0.6, 2, 120]
+    AIF_btf = a*(d*e*(1 - exp(-(t - b)/e)) + f*g*(1 - exp(-(t - b)/g)))
+    AIF_atf = a*(d*e*exp(-(t - b)/e)*(exp((c - b)/e) - 1
+        ) + f*g*exp(-(t - b)/g)*(exp((c - b)/g) - 1))
+    AIF_sym = Piecewise((0, t < b), (AIF_btf, And(b <= t, t < c)), (AIF_atf, c <= t))
+    aif_eq = Eq(Z0(t), AIF_sym)
+    f_vec = Matrix([[k01*Z0(t)]])
+    integrand = m*m.subs(t, s)**-1*f_vec.subs(aif_eq.lhs, aif_eq.rhs).subs(t, s)
+    solution = integrate(integrand[0], (s, 0, t))
+    assert solution is not None  # does not hang and takes less than 10 s
+
+
+@slow
+def test_heurisch_issue_26930():
+    integrand = x**Rational(4, 3)*log(x)
+    anti = 3*x**(S(7)/3)*log(x)/7 - 9*x**(S(7)/3)/49
+    assert heurisch(integrand, x) == anti
+    assert integrate(integrand, x) == anti
+    assert integrate(integrand, (x, 0, 1)) == -S(9)/49
+
+
+def test_heurisch_issue_26922():
+
+    a, b, x = symbols("a, b, x", real=True, positive=True)
+    C = symbols("C", real=True)
+    i1 = -C*x*exp(-a*x**2 - sqrt(b)*x)
+    i2 = C*x*exp(-a*x**2 + sqrt(b)*x)
+    i = Integral(i1, x) + Integral(i2, x)
+    res = (
+        -C*exp(-a*x**2)*exp(sqrt(b)*x)/(2*a)
+        + C*exp(-a*x**2)*exp(-sqrt(b)*x)/(2*a)
+        + sqrt(pi)*C*sqrt(b)*exp(b/(4*a))*erf(sqrt(a)*x - sqrt(b)/(2*sqrt(a)))/(4*a**(S(3)/2))
+        + sqrt(pi)*C*sqrt(b)*exp(b/(4*a))*erf(sqrt(a)*x + sqrt(b)/(2*sqrt(a)))/(4*a**(S(3)/2))
+    )
+
+    assert i.doit(heurisch=False).expand() == res

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_intpoly.py

@@ -0,0 +1,627 @@
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+
+from sympy.core import S, Rational
+
+from sympy.integrals.intpoly import (decompose, best_origin, distance_to_side,
+                                     polytope_integrate, point_sort,
+                                     hyperplane_parameters, main_integrate3d,
+                                     main_integrate, polygon_integrate,
+                                     lineseg_integrate, integration_reduction,
+                                     integration_reduction_dynamic, is_vertex)
+
+from sympy.geometry.line import Segment2D
+from sympy.geometry.polygon import Polygon
+from sympy.geometry.point import Point, Point2D
+from sympy.abc import x, y, z
+
+from sympy.testing.pytest import slow
+
+
+def test_decompose():
+    assert decompose(x) == {1: x}
+    assert decompose(x**2) == {2: x**2}
+    assert decompose(x*y) == {2: x*y}
+    assert decompose(x + y) == {1: x + y}
+    assert decompose(x**2 + y) == {1: y, 2: x**2}
+    assert decompose(8*x**2 + 4*y + 7) == {0: 7, 1: 4*y, 2: 8*x**2}
+    assert decompose(x**2 + 3*y*x) == {2: x**2 + 3*x*y}
+    assert decompose(9*x**2 + y + 4*x + x**3 + y**2*x + 3) ==\
+        {0: 3, 1: 4*x + y, 2: 9*x**2, 3: x**3 + x*y**2}
+
+    assert decompose(x, True) == {x}
+    assert decompose(x ** 2, True) == {x**2}
+    assert decompose(x * y, True) == {x * y}
+    assert decompose(x + y, True) == {x, y}
+    assert decompose(x ** 2 + y, True) == {y, x ** 2}
+    assert decompose(8 * x ** 2 + 4 * y + 7, True) == {7, 4*y, 8*x**2}
+    assert decompose(x ** 2 + 3 * y * x, True) == {x ** 2, 3 * x * y}
+    assert decompose(9 * x ** 2 + y + 4 * x + x ** 3 + y ** 2 * x + 3, True) == \
+           {3, y, 4*x, 9*x**2, x*y**2, x**3}
+
+
+def test_best_origin():
+    expr1 = y ** 2 * x ** 5 + y ** 5 * x ** 7 + 7 * x + x ** 12 + y ** 7 * x
+
+    l1 = Segment2D(Point(0, 3), Point(1, 1))
+    l2 = Segment2D(Point(S(3) / 2, 0), Point(S(3) / 2, 3))
+    l3 = Segment2D(Point(0, S(3) / 2), Point(3, S(3) / 2))
+    l4 = Segment2D(Point(0, 2), Point(2, 0))
+    l5 = Segment2D(Point(0, 2), Point(1, 1))
+    l6 = Segment2D(Point(2, 0), Point(1, 1))
+
+    assert best_origin((2, 1), 3, l1, expr1) == (0, 3)
+    # XXX: Should these return exact Rational output? Maybe best_origin should
+    #      sympify its arguments...
+    assert best_origin((2, 0), 3, l2, x ** 7) == (1.5, 0)
+    assert best_origin((0, 2), 3, l3, x ** 7) == (0, 1.5)
+    assert best_origin((1, 1), 2, l4, x ** 7 * y ** 3) == (0, 2)
+    assert best_origin((1, 1), 2, l4, x ** 3 * y ** 7) == (2, 0)
+    assert best_origin((1, 1), 2, l5, x ** 2 * y ** 9) == (0, 2)
+    assert best_origin((1, 1), 2, l6, x ** 9 * y ** 2) == (2, 0)
+
+
+@slow
+def test_polytope_integrate():
+    #  Convex 2-Polytopes
+    #  Vertex representation
+    assert polytope_integrate(Polygon(Point(0, 0), Point(0, 2),
+                                      Point(4, 0)), 1) == 4
+    assert polytope_integrate(Polygon(Point(0, 0), Point(0, 1),
+                                      Point(1, 1), Point(1, 0)), x * y) ==\
+                                      Rational(1, 4)
+    assert polytope_integrate(Polygon(Point(0, 3), Point(5, 3), Point(1, 1)),
+                              6*x**2 - 40*y) == Rational(-935, 3)
+
+    assert polytope_integrate(Polygon(Point(0, 0), Point(0, sqrt(3)),
+                                      Point(sqrt(3), sqrt(3)),
+                                      Point(sqrt(3), 0)), 1) == 3
+
+    hexagon = Polygon(Point(0, 0), Point(-sqrt(3) / 2, S.Half),
+                      Point(-sqrt(3) / 2, S(3) / 2), Point(0, 2),
+                      Point(sqrt(3) / 2, S(3) / 2), Point(sqrt(3) / 2, S.Half))
+
+    assert polytope_integrate(hexagon, 1) == S(3*sqrt(3)) / 2
+
+    #  Hyperplane representation
+    assert polytope_integrate([((-1, 0), 0), ((1, 2), 4),
+                               ((0, -1), 0)], 1) == 4
+    assert polytope_integrate([((-1, 0), 0), ((0, 1), 1),
+                               ((1, 0), 1), ((0, -1), 0)], x * y) == Rational(1, 4)
+    assert polytope_integrate([((0, 1), 3), ((1, -2), -1),
+                               ((-2, -1), -3)], 6*x**2 - 40*y) == Rational(-935, 3)
+    assert polytope_integrate([((-1, 0), 0), ((0, sqrt(3)), 3),
+                               ((sqrt(3), 0), 3), ((0, -1), 0)], 1) == 3
+
+    hexagon = [((Rational(-1, 2), -sqrt(3) / 2), 0),
+               ((-1, 0), sqrt(3) / 2),
+               ((Rational(-1, 2), sqrt(3) / 2), sqrt(3)),
+               ((S.Half, sqrt(3) / 2), sqrt(3)),
+               ((1, 0), sqrt(3) / 2),
+               ((S.Half, -sqrt(3) / 2), 0)]
+    assert polytope_integrate(hexagon, 1) == S(3*sqrt(3)) / 2
+
+    #  Non-convex polytopes
+    #  Vertex representation
+    assert polytope_integrate(Polygon(Point(-1, -1), Point(-1, 1),
+                                      Point(1, 1), Point(0, 0),
+                                      Point(1, -1)), 1) == 3
+    assert polytope_integrate(Polygon(Point(-1, -1), Point(-1, 1),
+                                      Point(0, 0), Point(1, 1),
+                                      Point(1, -1), Point(0, 0)), 1) == 2
+    #  Hyperplane representation
+    assert polytope_integrate([((-1, 0), 1), ((0, 1), 1), ((1, -1), 0),
+                               ((1, 1), 0), ((0, -1), 1)], 1) == 3
+    assert polytope_integrate([((-1, 0), 1), ((1, 1), 0), ((-1, 1), 0),
+                               ((1, 0), 1), ((-1, -1), 0),
+                               ((1, -1), 0)], 1) == 2
+
+    #  Tests for 2D polytopes mentioned in Chin et al(Page 10):
+    #  http://dilbert.engr.ucdavis.edu/~suku/quadrature/cls-integration.pdf
+    fig1 = Polygon(Point(1.220, -0.827), Point(-1.490, -4.503),
+                   Point(-3.766, -1.622), Point(-4.240, -0.091),
+                   Point(-3.160, 4), Point(-0.981, 4.447),
+                   Point(0.132, 4.027))
+    assert polytope_integrate(fig1, x**2 + x*y + y**2) ==\
+        S(2031627344735367)/(8*10**12)
+
+    fig2 = Polygon(Point(4.561, 2.317), Point(1.491, -1.315),
+                   Point(-3.310, -3.164), Point(-4.845, -3.110),
+                   Point(-4.569, 1.867))
+    assert polytope_integrate(fig2, x**2 + x*y + y**2) ==\
+        S(517091313866043)/(16*10**11)
+
+    fig3 = Polygon(Point(-2.740, -1.888), Point(-3.292, 4.233),
+                   Point(-2.723, -0.697), Point(-0.643, -3.151))
+    assert polytope_integrate(fig3, x**2 + x*y + y**2) ==\
+        S(147449361647041)/(8*10**12)
+
+    fig4 = Polygon(Point(0.211, -4.622), Point(-2.684, 3.851),
+                   Point(0.468, 4.879), Point(4.630, -1.325),
+                   Point(-0.411, -1.044))
+    assert polytope_integrate(fig4, x**2 + x*y + y**2) ==\
+        S(180742845225803)/(10**12)
+
+    #  Tests for many polynomials with maximum degree given(2D case).
+    tri = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    polys = []
+    expr1 = x**9*y + x**7*y**3 + 2*x**2*y**8
+    expr2 = x**6*y**4 + x**5*y**5 + 2*y**10
+    expr3 = x**10 + x**9*y + x**8*y**2 + x**5*y**5
+    polys.extend((expr1, expr2, expr3))
+    result_dict = polytope_integrate(tri, polys, max_degree=10)
+    assert result_dict[expr1] == Rational(615780107, 594)
+    assert result_dict[expr2] == Rational(13062161, 27)
+    assert result_dict[expr3] == Rational(1946257153, 924)
+
+    tri = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    expr1 = x**7*y**1 + 2*x**2*y**6
+    expr2 = x**6*y**4 + x**5*y**5 + 2*y**10
+    expr3 = x**10 + x**9*y + x**8*y**2 + x**5*y**5
+    polys.extend((expr1, expr2, expr3))
+    assert polytope_integrate(tri, polys, max_degree=9) == \
+        {x**7*y + 2*x**2*y**6: Rational(489262, 9)}
+
+    #  Tests when all integral of all monomials up to a max_degree is to be
+    #  calculated.
+    assert polytope_integrate(Polygon(Point(0, 0), Point(0, 1),
+                                      Point(1, 1), Point(1, 0)),
+                              max_degree=4) == {0: 0, 1: 1, x: S.Half,
+                                                x ** 2 * y ** 2: S.One / 9,
+                                                x ** 4: S.One / 5,
+                                                y ** 4: S.One / 5,
+                                                y: S.Half,
+                                                x * y ** 2: S.One / 6,
+                                                y ** 2: S.One / 3,
+                                                x ** 3: S.One / 4,
+                                                x ** 2 * y: S.One / 6,
+                                                x ** 3 * y: S.One / 8,
+                                                x * y: S.One / 4,
+                                                y ** 3: S.One / 4,
+                                                x ** 2: S.One / 3,
+                                                x * y ** 3: S.One / 8}
+
+    #  Tests for 3D polytopes
+    cube1 = [[(0, 0, 0), (0, 6, 6), (6, 6, 6), (3, 6, 0),
+              (0, 6, 0), (6, 0, 6), (3, 0, 0), (0, 0, 6)],
+             [1, 2, 3, 4], [3, 2, 5, 6], [1, 7, 5, 2], [0, 6, 5, 7],
+             [1, 4, 0, 7], [0, 4, 3, 6]]
+    assert polytope_integrate(cube1, 1) == S(162)
+
+    #  3D Test cases in Chin et al(2015)
+    cube2 = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),
+             (5, 0, 5), (5, 5, 0), (5, 5, 5)],
+             [3, 7, 6, 2], [1, 5, 7, 3], [5, 4, 6, 7], [0, 4, 5, 1],
+             [2, 0, 1, 3], [2, 6, 4, 0]]
+
+    cube3 = [[(0, 0, 0), (5, 0, 0), (5, 4, 0), (3, 2, 0), (3, 5, 0),
+              (0, 5, 0), (0, 0, 5), (5, 0, 5), (5, 4, 5), (3, 2, 5),
+              (3, 5, 5), (0, 5, 5)],
+             [6, 11, 5, 0], [1, 7, 6, 0], [5, 4, 3, 2, 1, 0], [11, 10, 4, 5],
+             [10, 9, 3, 4], [9, 8, 2, 3], [8, 7, 1, 2], [7, 8, 9, 10, 11, 6]]
+
+    cube4 = [[(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1),
+              (S.One / 4, S.One / 4, S.One / 4)],
+             [0, 2, 1], [1, 3, 0], [4, 2, 3], [4, 3, 1],
+             [0, 1, 2], [2, 4, 1], [0, 3, 2]]
+
+    assert polytope_integrate(cube2, x ** 2 + y ** 2 + x * y + z ** 2) ==\
+           Rational(15625, 4)
+    assert polytope_integrate(cube3, x ** 2 + y ** 2 + x * y + z ** 2) ==\
+           S(33835) / 12
+    assert polytope_integrate(cube4, x ** 2 + y ** 2 + x * y + z ** 2) ==\
+           S(37) / 960
+
+    #  Test cases from Mathematica's PolyhedronData library
+    octahedron = [[(S.NegativeOne / sqrt(2), 0, 0), (0, S.One / sqrt(2), 0),
+                   (0, 0, S.NegativeOne / sqrt(2)), (0, 0, S.One / sqrt(2)),
+                   (0, S.NegativeOne / sqrt(2), 0), (S.One / sqrt(2), 0, 0)],
+                  [3, 4, 5], [3, 5, 1], [3, 1, 0], [3, 0, 4], [4, 0, 2],
+                  [4, 2, 5], [2, 0, 1], [5, 2, 1]]
+
+    assert polytope_integrate(octahedron, 1) == sqrt(2) / 3
+
+    great_stellated_dodecahedron =\
+        [[(-0.32491969623290634095, 0, 0.42532540417601993887),
+          (0.32491969623290634095, 0, -0.42532540417601993887),
+          (-0.52573111211913359231, 0, 0.10040570794311363956),
+          (0.52573111211913359231, 0, -0.10040570794311363956),
+          (-0.10040570794311363956, -0.3090169943749474241, 0.42532540417601993887),
+          (-0.10040570794311363956, 0.30901699437494742410, 0.42532540417601993887),
+          (0.10040570794311363956, -0.3090169943749474241, -0.42532540417601993887),
+          (0.10040570794311363956, 0.30901699437494742410, -0.42532540417601993887),
+          (-0.16245984811645317047, -0.5, 0.10040570794311363956),
+          (-0.16245984811645317047,  0.5, 0.10040570794311363956),
+          (0.16245984811645317047,  -0.5, -0.10040570794311363956),
+          (0.16245984811645317047,   0.5, -0.10040570794311363956),
+          (-0.42532540417601993887, -0.3090169943749474241, -0.10040570794311363956),
+          (-0.42532540417601993887, 0.30901699437494742410, -0.10040570794311363956),
+          (-0.26286555605956679615, 0.1909830056250525759, -0.42532540417601993887),
+          (-0.26286555605956679615, -0.1909830056250525759, -0.42532540417601993887),
+          (0.26286555605956679615, 0.1909830056250525759, 0.42532540417601993887),
+          (0.26286555605956679615, -0.1909830056250525759, 0.42532540417601993887),
+          (0.42532540417601993887, -0.3090169943749474241, 0.10040570794311363956),
+          (0.42532540417601993887, 0.30901699437494742410, 0.10040570794311363956)],
+         [12, 3, 0, 6, 16], [17, 7, 0, 3, 13],
+         [9, 6, 0, 7, 8], [18, 2, 1, 4, 14],
+         [15, 5, 1, 2, 19], [11, 4, 1, 5, 10],
+         [8, 19, 2, 18, 9], [10, 13, 3, 12, 11],
+         [16, 14, 4, 11, 12], [13, 10, 5, 15, 17],
+         [14, 16, 6, 9, 18], [19, 8, 7, 17, 15]]
+    #  Actual volume is : 0.163118960624632
+    assert Abs(polytope_integrate(great_stellated_dodecahedron, 1) -\
+        0.163118960624632) < 1e-12
+
+    expr = x **2 + y ** 2 + z ** 2
+    octahedron_five_compound = [[(0, -0.7071067811865475244, 0),
+                                 (0, 0.70710678118654752440, 0),
+                                 (0.1148764602736805918,
+                                  -0.35355339059327376220, -0.60150095500754567366),
+                                 (0.1148764602736805918, 0.35355339059327376220,
+                                     -0.60150095500754567366),
+                                 (0.18587401723009224507,
+                                  -0.57206140281768429760, 0.37174803446018449013),
+                                 (0.18587401723009224507,  0.57206140281768429760,
+                                  0.37174803446018449013),
+                                 (0.30075047750377283683, -0.21850801222441053540,
+                                  0.60150095500754567366),
+                                 (0.30075047750377283683, 0.21850801222441053540,
+                                  0.60150095500754567366),
+                                 (0.48662449473386508189, -0.35355339059327376220,
+                                  -0.37174803446018449013),
+                                 (0.48662449473386508189, 0.35355339059327376220,
+                                  -0.37174803446018449013),
+                                 (-0.60150095500754567366, 0, -0.37174803446018449013),
+                                 (-0.30075047750377283683, -0.21850801222441053540,
+                                  -0.60150095500754567366),
+                                 (-0.30075047750377283683, 0.21850801222441053540,
+                                  -0.60150095500754567366),
+                                 (0.60150095500754567366, 0, 0.37174803446018449013),
+                                 (0.4156269377774534286, -0.57206140281768429760, 0),
+                                 (0.4156269377774534286, 0.57206140281768429760, 0),
+                                 (0.37174803446018449013, 0, -0.60150095500754567366),
+                                 (-0.4156269377774534286, -0.57206140281768429760, 0),
+                                 (-0.4156269377774534286, 0.57206140281768429760, 0),
+                                 (-0.67249851196395732696, -0.21850801222441053540, 0),
+                                 (-0.67249851196395732696, 0.21850801222441053540, 0),
+                                 (0.67249851196395732696, -0.21850801222441053540, 0),
+                                 (0.67249851196395732696, 0.21850801222441053540, 0),
+                                 (-0.37174803446018449013, 0, 0.60150095500754567366),
+                                 (-0.48662449473386508189, -0.35355339059327376220,
+                                 0.37174803446018449013),
+                                 (-0.48662449473386508189, 0.35355339059327376220,
+                                  0.37174803446018449013),
+                                 (-0.18587401723009224507, -0.57206140281768429760,
+                                  -0.37174803446018449013),
+                                 (-0.18587401723009224507, 0.57206140281768429760,
+                                  -0.37174803446018449013),
+                                 (-0.11487646027368059176, -0.35355339059327376220,
+                                  0.60150095500754567366),
+                                 (-0.11487646027368059176, 0.35355339059327376220,
+                                 0.60150095500754567366)],
+                                 [0, 10, 16], [23, 10, 0], [16, 13, 0],
+                                 [0, 13, 23], [16, 10, 1], [1, 10, 23],
+                                 [1, 13, 16], [23, 13, 1], [2, 4, 19],
+                                 [22, 4, 2], [2, 19, 27], [27, 22, 2],
+                                 [20, 5, 3], [3, 5, 21], [26, 20, 3],
+                                 [3, 21, 26], [29, 19, 4], [4, 22, 29],
+                                 [5, 20, 28], [28, 21, 5], [6, 8, 15],
+                                 [17, 8, 6], [6, 15, 25], [25, 17, 6],
+                                 [14, 9, 7], [7, 9, 18], [24, 14, 7],
+                                 [7, 18, 24], [8, 12, 15], [17, 12, 8],
+                                 [14, 11, 9], [9, 11, 18], [11, 14, 24],
+                                 [24, 18, 11], [25, 15, 12], [12, 17, 25],
+                                 [29, 27, 19], [20, 26, 28], [28, 26, 21],
+                                 [22, 27, 29]]
+    assert Abs(polytope_integrate(octahedron_five_compound, expr)) - 0.353553\
+        < 1e-6
+
+    cube_five_compound = [[(-0.1624598481164531631, -0.5, -0.6881909602355867691),
+                           (-0.1624598481164531631, 0.5, -0.6881909602355867691),
+                           (0.1624598481164531631, -0.5, 0.68819096023558676910),
+                           (0.1624598481164531631, 0.5, 0.68819096023558676910),
+                          (-0.52573111211913359231, 0, -0.6881909602355867691),
+                          (0.52573111211913359231, 0, 0.68819096023558676910),
+                          (-0.26286555605956679615, -0.8090169943749474241,
+                           -0.1624598481164531631),
+                          (-0.26286555605956679615, 0.8090169943749474241,
+                           -0.1624598481164531631),
+                          (0.26286555605956680301, -0.8090169943749474241,
+                           0.1624598481164531631),
+                          (0.26286555605956680301, 0.8090169943749474241,
+                           0.1624598481164531631),
+                          (-0.42532540417601993887, -0.3090169943749474241,
+                           0.68819096023558676910),
+                          (-0.42532540417601993887, 0.30901699437494742410,
+                           0.68819096023558676910),
+                          (0.42532540417601996609, -0.3090169943749474241,
+                           -0.6881909602355867691),
+                          (0.42532540417601996609, 0.30901699437494742410,
+                           -0.6881909602355867691),
+                          (-0.6881909602355867691, -0.5, 0.1624598481164531631),
+                          (-0.6881909602355867691, 0.5,  0.1624598481164531631),
+                          (0.68819096023558676910, -0.5, -0.1624598481164531631),
+                          (0.68819096023558676910, 0.5, -0.1624598481164531631),
+                          (-0.85065080835203998877, 0, -0.1624598481164531631),
+                          (0.85065080835203993218, 0, 0.1624598481164531631)],
+                          [18, 10, 3, 7], [13, 19, 8, 0], [18, 0, 8, 10],
+                          [3, 19, 13, 7], [18, 7, 13, 0], [8, 19, 3, 10],
+                          [6, 2, 11, 18], [1, 9, 19, 12], [11, 9, 1, 18],
+                          [6, 12, 19, 2], [1, 12, 6, 18], [11, 2, 19, 9],
+                          [4, 14, 11, 7], [17, 5, 8, 12], [4, 12, 8, 14],
+                          [11, 5, 17, 7], [4, 7, 17, 12], [8, 5, 11, 14],
+                          [6, 10, 15, 4], [13, 9, 5, 16], [15, 9, 13, 4],
+                          [6, 16, 5, 10], [13, 16, 6, 4], [15, 10, 5, 9],
+                          [14, 15, 1, 0], [16, 17, 3, 2], [14, 2, 3, 15],
+                          [1, 17, 16, 0], [14, 0, 16, 2], [3, 17, 1, 15]]
+    assert Abs(polytope_integrate(cube_five_compound, expr) - 1.25) < 1e-12
+
+    echidnahedron = [[(0, 0, -2.4898982848827801995),
+                      (0, 0, 2.4898982848827802734),
+                      (0, -4.2360679774997896964, -2.4898982848827801995),
+                      (0, -4.2360679774997896964, 2.4898982848827802734),
+                      (0, 4.2360679774997896964, -2.4898982848827801995),
+                      (0, 4.2360679774997896964, 2.4898982848827802734),
+                      (-4.0287400534704067567, -1.3090169943749474241, -2.4898982848827801995),
+                      (-4.0287400534704067567, -1.3090169943749474241, 2.4898982848827802734),
+                      (-4.0287400534704067567, 1.3090169943749474241, -2.4898982848827801995),
+                      (-4.0287400534704067567, 1.3090169943749474241, 2.4898982848827802734),
+                      (4.0287400534704069747, -1.3090169943749474241, -2.4898982848827801995),
+                      (4.0287400534704069747, -1.3090169943749474241, 2.4898982848827802734),
+                      (4.0287400534704069747, 1.3090169943749474241, -2.4898982848827801995),
+                      (4.0287400534704069747, 1.3090169943749474241, 2.4898982848827802734),
+                      (-2.4898982848827801995, -3.4270509831248422723, -2.4898982848827801995),
+                      (-2.4898982848827801995, -3.4270509831248422723, 2.4898982848827802734),
+                      (-2.4898982848827801995, 3.4270509831248422723, -2.4898982848827801995),
+                      (-2.4898982848827801995, 3.4270509831248422723, 2.4898982848827802734),
+                      (2.4898982848827802734, -3.4270509831248422723, -2.4898982848827801995),
+                      (2.4898982848827802734, -3.4270509831248422723, 2.4898982848827802734),
+                      (2.4898982848827802734, 3.4270509831248422723, -2.4898982848827801995),
+                      (2.4898982848827802734, 3.4270509831248422723, 2.4898982848827802734),
+                      (-4.7169310137059934362, -0.8090169943749474241, -1.1135163644116066184),
+                      (-4.7169310137059934362, 0.8090169943749474241, -1.1135163644116066184),
+                      (4.7169310137059937438, -0.8090169943749474241, 1.11351636441160673519),
+                      (4.7169310137059937438, 0.8090169943749474241, 1.11351636441160673519),
+                      (-4.2916056095299737777, -2.1180339887498948482, 1.11351636441160673519),
+                      (-4.2916056095299737777, 2.1180339887498948482, 1.11351636441160673519),
+                      (4.2916056095299737777, -2.1180339887498948482, -1.1135163644116066184),
+                      (4.2916056095299737777, 2.1180339887498948482, -1.1135163644116066184),
+                      (-3.6034146492943870399, 0, -3.3405490932348205213),
+                      (3.6034146492943870399, 0, 3.3405490932348202056),
+                      (-3.3405490932348205213, -3.4270509831248422723, 1.11351636441160673519),
+                      (-3.3405490932348205213, 3.4270509831248422723, 1.11351636441160673519),
+                      (3.3405490932348202056, -3.4270509831248422723, -1.1135163644116066184),
+                      (3.3405490932348202056, 3.4270509831248422723, -1.1135163644116066184),
+                      (-2.9152236890588002395, -2.1180339887498948482, 3.3405490932348202056),
+                      (-2.9152236890588002395, 2.1180339887498948482, 3.3405490932348202056),
+                      (2.9152236890588002395, -2.1180339887498948482, -3.3405490932348205213),
+                      (2.9152236890588002395, 2.1180339887498948482, -3.3405490932348205213),
+                      (-2.2270327288232132368, 0, -1.1135163644116066184),
+                      (-2.2270327288232132368, -4.2360679774997896964, -1.1135163644116066184),
+                      (-2.2270327288232132368, 4.2360679774997896964, -1.1135163644116066184),
+                      (2.2270327288232134704, 0, 1.11351636441160673519),
+                      (2.2270327288232134704, -4.2360679774997896964, 1.11351636441160673519),
+                      (2.2270327288232134704, 4.2360679774997896964, 1.11351636441160673519),
+                      (-1.8017073246471935200, -1.3090169943749474241, 1.11351636441160673519),
+                      (-1.8017073246471935200, 1.3090169943749474241, 1.11351636441160673519),
+                      (1.8017073246471935043, -1.3090169943749474241, -1.1135163644116066184),
+                      (1.8017073246471935043, 1.3090169943749474241, -1.1135163644116066184),
+                      (-1.3763819204711735382, 0, -4.7169310137059934362),
+                      (-1.3763819204711735382, 0, 0.26286555605956679615),
+                      (1.37638192047117353821, 0, 4.7169310137059937438),
+                      (1.37638192047117353821, 0, -0.26286555605956679615),
+                      (-1.1135163644116066184, -3.4270509831248422723, -3.3405490932348205213),
+                      (-1.1135163644116066184, -0.8090169943749474241, 4.7169310137059937438),
+                      (-1.1135163644116066184, -0.8090169943749474241, -0.26286555605956679615),
+                      (-1.1135163644116066184, 0.8090169943749474241, 4.7169310137059937438),
+                      (-1.1135163644116066184, 0.8090169943749474241, -0.26286555605956679615),
+                      (-1.1135163644116066184, 3.4270509831248422723, -3.3405490932348205213),
+                      (1.11351636441160673519, -3.4270509831248422723, 3.3405490932348202056),
+                      (1.11351636441160673519, -0.8090169943749474241, -4.7169310137059934362),
+                      (1.11351636441160673519, -0.8090169943749474241, 0.26286555605956679615),
+                      (1.11351636441160673519, 0.8090169943749474241, -4.7169310137059934362),
+                      (1.11351636441160673519, 0.8090169943749474241, 0.26286555605956679615),
+                      (1.11351636441160673519, 3.4270509831248422723, 3.3405490932348202056),
+                      (-0.85065080835203998877, 0, 1.11351636441160673519),
+                      (0.85065080835203993218, 0, -1.1135163644116066184),
+                      (-0.6881909602355867691, -0.5, -1.1135163644116066184),
+                      (-0.6881909602355867691, 0.5, -1.1135163644116066184),
+                      (-0.6881909602355867691, -4.7360679774997896964, -1.1135163644116066184),
+                      (-0.6881909602355867691, -2.1180339887498948482, -1.1135163644116066184),
+                      (-0.6881909602355867691, 2.1180339887498948482, -1.1135163644116066184),
+                      (-0.6881909602355867691, 4.7360679774997896964, -1.1135163644116066184),
+                      (0.68819096023558676910, -0.5, 1.11351636441160673519),
+                      (0.68819096023558676910, 0.5, 1.11351636441160673519),
+                      (0.68819096023558676910, -4.7360679774997896964, 1.11351636441160673519),
+                      (0.68819096023558676910, -2.1180339887498948482, 1.11351636441160673519),
+                      (0.68819096023558676910, 2.1180339887498948482, 1.11351636441160673519),
+                      (0.68819096023558676910, 4.7360679774997896964, 1.11351636441160673519),
+                      (-0.42532540417601993887, -1.3090169943749474241, -4.7169310137059934362),
+                      (-0.42532540417601993887, -1.3090169943749474241, 0.26286555605956679615),
+                      (-0.42532540417601993887, 1.3090169943749474241, -4.7169310137059934362),
+                      (-0.42532540417601993887, 1.3090169943749474241, 0.26286555605956679615),
+                      (-0.26286555605956679615, -0.8090169943749474241, 1.11351636441160673519),
+                      (-0.26286555605956679615, 0.8090169943749474241, 1.11351636441160673519),
+                      (0.26286555605956679615, -0.8090169943749474241, -1.1135163644116066184),
+                      (0.26286555605956679615, 0.8090169943749474241, -1.1135163644116066184),
+                      (0.42532540417601996609, -1.3090169943749474241, 4.7169310137059937438),
+                      (0.42532540417601996609, -1.3090169943749474241, -0.26286555605956679615),
+                      (0.42532540417601996609, 1.3090169943749474241, 4.7169310137059937438),
+                      (0.42532540417601996609, 1.3090169943749474241, -0.26286555605956679615)],
+                      [9, 66, 47], [44, 62, 77], [20, 91, 49], [33, 47, 83],
+                      [3, 77, 84], [12, 49, 53], [36, 84, 66], [28, 53, 62],
+                      [73, 83, 91], [15, 84, 46], [25, 64, 43], [16, 58, 72],
+                      [26, 46, 51], [11, 43, 74], [4, 72, 91], [60, 74, 84],
+                      [35, 91, 64], [23, 51, 58], [19, 74, 77], [79, 83, 78],
+                      [6, 56, 40], [76, 77, 81], [21, 78, 75], [8, 40, 58],
+                      [31, 75, 74], [42, 58, 83], [41, 81, 56], [13, 75, 43],
+                      [27, 51, 47], [2, 89, 71], [24, 43, 62], [17, 47, 85],
+                      [14, 71, 56], [65, 85, 75], [22, 56, 51], [34, 62, 89],
+                      [5, 85, 78], [32, 81, 46], [10, 53, 48], [45, 78, 64],
+                      [7, 46, 66], [18, 48, 89], [37, 66, 85], [70, 89, 81],
+                      [29, 64, 53], [88, 74, 1], [38, 67, 48], [42, 83, 72],
+                      [57, 1, 85], [34, 48, 62], [59, 72, 87], [19, 62, 74],
+                      [63, 87, 67], [17, 85, 83], [52, 75, 1], [39, 87, 49],
+                      [22, 51, 40], [55, 1, 66], [29, 49, 64], [30, 40, 69],
+                      [13, 64, 75], [82, 69, 87], [7, 66, 51], [90, 85, 1],
+                      [59, 69, 72], [70, 81, 71], [88, 1, 84], [73, 72, 83],
+                      [54, 71, 68], [5, 83, 85], [50, 68, 69], [3, 84, 81],
+                      [57, 66, 1], [30, 68, 40], [28, 62, 48], [52, 1, 74],
+                      [23, 40, 51], [38, 48, 86], [9, 51, 66], [80, 86, 68],
+                      [11, 74, 62], [55, 84, 1], [54, 86, 71], [35, 64, 49],
+                      [90, 1, 75], [41, 71, 81], [39, 49, 67], [15, 81, 84],
+                      [61, 67, 86], [21, 75, 64], [24, 53, 43], [50, 69, 0],
+                      [37, 85, 47], [31, 43, 75], [61, 0, 67], [27, 47, 58],
+                      [10, 67, 53], [8, 58, 69], [90, 75, 85], [45, 91, 78],
+                      [80, 68, 0], [36, 66, 46], [65, 78, 85], [63, 0, 87],
+                      [32, 46, 56], [20, 87, 91], [14, 56, 68], [57, 85, 66],
+                      [33, 58, 47], [61, 86, 0], [60, 84, 77], [37, 47, 66],
+                      [82, 0, 69], [44, 77, 89], [16, 69, 58], [18, 89, 86],
+                      [55, 66, 84], [26, 56, 46], [63, 67, 0], [31, 74, 43],
+                      [36, 46, 84], [50, 0, 68], [25, 43, 53], [6, 68, 56],
+                      [12, 53, 67], [88, 84, 74], [76, 89, 77], [82, 87, 0],
+                      [65, 75, 78], [60, 77, 74], [80, 0, 86], [79, 78, 91],
+                      [2, 86, 89], [4, 91, 87], [52, 74, 75], [21, 64, 78],
+                      [18, 86, 48], [23, 58, 40], [5, 78, 83], [28, 48, 53],
+                      [6, 40, 68], [25, 53, 64], [54, 68, 86], [33, 83, 58],
+                      [17, 83, 47], [12, 67, 49], [41, 56, 71], [9, 47, 51],
+                      [35, 49, 91], [2, 71, 86], [79, 91, 83], [38, 86, 67],
+                      [26, 51, 56], [7, 51, 46], [4, 87, 72], [34, 89, 48],
+                      [15, 46, 81], [42, 72, 58], [10, 48, 67], [27, 58, 51],
+                      [39, 67, 87], [76, 81, 89], [3, 81, 77], [8, 69, 40],
+                      [29, 53, 49], [19, 77, 62], [22, 40, 56], [20, 49, 87],
+                      [32, 56, 81], [59, 87, 69], [24, 62, 53], [11, 62, 43],
+                      [14, 68, 71], [73, 91, 72], [13, 43, 64], [70, 71, 89],
+                      [16, 72, 69], [44, 89, 62], [30, 69, 68], [45, 64, 91]]
+    #  Actual volume is : 51.405764746872634
+    assert Abs(polytope_integrate(echidnahedron, 1) - 51.4057647468726) < 1e-12
+    assert Abs(polytope_integrate(echidnahedron, expr) - 253.569603474519) <\
+    1e-12
+
+    #  Tests for many polynomials with maximum degree given(2D case).
+    assert polytope_integrate(cube2, [x**2, y*z], max_degree=2) == \
+        {y * z: 3125 / S(4), x ** 2: 3125 / S(3)}
+
+    assert polytope_integrate(cube2, max_degree=2) == \
+        {1: 125, x: 625 / S(2), x * z: 3125 / S(4), y: 625 / S(2),
+         y * z: 3125 / S(4), z ** 2: 3125 / S(3), y ** 2: 3125 / S(3),
+         z: 625 / S(2), x * y: 3125 / S(4), x ** 2: 3125 / S(3)}
+
+def test_point_sort():
+    assert point_sort([Point(0, 0), Point(1, 0), Point(1, 1)]) == \
+        [Point2D(1, 1), Point2D(1, 0), Point2D(0, 0)]
+
+    fig6 = Polygon((0, 0), (1, 0), (1, 1))
+    assert polytope_integrate(fig6, x*y) == Rational(-1, 8)
+    assert polytope_integrate(fig6, x*y, clockwise = True) == Rational(1, 8)
+
+
+def test_polytopes_intersecting_sides():
+    fig5 = Polygon(Point(-4.165, -0.832), Point(-3.668, 1.568),
+                   Point(-3.266, 1.279), Point(-1.090, -2.080),
+                   Point(3.313, -0.683), Point(3.033, -4.845),
+                   Point(-4.395, 4.840), Point(-1.007, -3.328))
+    assert polytope_integrate(fig5, x**2 + x*y + y**2) ==\
+        S(1633405224899363)/(24*10**12)
+
+    fig6 = Polygon(Point(-3.018, -4.473), Point(-0.103, 2.378),
+                   Point(-1.605, -2.308), Point(4.516, -0.771),
+                   Point(4.203, 0.478))
+    assert polytope_integrate(fig6, x**2 + x*y + y**2) ==\
+        S(88161333955921)/(3*10**12)
+
+
+def test_max_degree():
+    polygon = Polygon((0, 0), (0, 1), (1, 1), (1, 0))
+    polys = [1, x, y, x*y, x**2*y, x*y**2]
+    assert polytope_integrate(polygon, polys, max_degree=3) == \
+        {1: 1, x: S.Half, y: S.Half, x*y: Rational(1, 4), x**2*y: Rational(1, 6), x*y**2: Rational(1, 6)}
+    assert polytope_integrate(polygon, polys, max_degree=2) == \
+        {1: 1, x: S.Half, y: S.Half, x*y: Rational(1, 4)}
+    assert polytope_integrate(polygon, polys, max_degree=1) == \
+        {1: 1, x: S.Half, y: S.Half}
+
+
+def test_main_integrate3d():
+    cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),\
+             (5, 0, 5), (5, 5, 0), (5, 5, 5)],\
+            [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],\
+            [3, 1, 0, 2], [0, 4, 6, 2]]
+    vertices = cube[0]
+    faces = cube[1:]
+    hp_params = hyperplane_parameters(faces, vertices)
+    assert main_integrate3d(1, faces, vertices, hp_params) == -125
+    assert main_integrate3d(1, faces, vertices, hp_params, max_degree=1) == \
+        {1: -125, y: Rational(-625, 2), z: Rational(-625, 2), x: Rational(-625, 2)}
+
+
+def test_main_integrate():
+    triangle = Polygon((0, 3), (5, 3), (1, 1))
+    facets = triangle.sides
+    hp_params = hyperplane_parameters(triangle)
+    assert main_integrate(x**2 + y**2, facets, hp_params) == Rational(325, 6)
+    assert main_integrate(x**2 + y**2, facets, hp_params, max_degree=1) == \
+        {0: 0, 1: 5, y: Rational(35, 3), x: 10}
+
+
+def test_polygon_integrate():
+    cube = [[(0, 0, 0), (0, 0, 5), (0, 5, 0), (0, 5, 5), (5, 0, 0),\
+             (5, 0, 5), (5, 5, 0), (5, 5, 5)],\
+            [2, 6, 7, 3], [3, 7, 5, 1], [7, 6, 4, 5], [1, 5, 4, 0],\
+            [3, 1, 0, 2], [0, 4, 6, 2]]
+    facet = cube[1]
+    facets = cube[1:]
+    vertices = cube[0]
+    assert polygon_integrate(facet, [(0, 1, 0), 5], 0, facets, vertices, 1, 0) == -25
+
+
+def test_distance_to_side():
+    point = (0, 0, 0)
+    assert distance_to_side(point, [(0, 0, 1), (0, 1, 0)], (1, 0, 0)) == -sqrt(2)/2
+
+
+def test_lineseg_integrate():
+    polygon = [(0, 5, 0), (5, 5, 0), (5, 5, 5), (0, 5, 5)]
+    line_seg = [(0, 5, 0), (5, 5, 0)]
+    assert lineseg_integrate(polygon, 0, line_seg, 1, 0) == 5
+    assert lineseg_integrate(polygon, 0, line_seg, 0, 0) == 0
+
+
+def test_integration_reduction():
+    triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    facets = triangle.sides
+    a, b = hyperplane_parameters(triangle)[0]
+    assert integration_reduction(facets, 0, a, b, 1, (x, y), 0) == 5
+    assert integration_reduction(facets, 0, a, b, 0, (x, y), 0) == 0
+
+
+def test_integration_reduction_dynamic():
+    triangle = Polygon(Point(0, 3), Point(5, 3), Point(1, 1))
+    facets = triangle.sides
+    a, b = hyperplane_parameters(triangle)[0]
+    x0 = facets[0].points[0]
+    monomial_values = [[0, 0, 0, 0], [1, 0, 0, 5],\
+                       [y, 0, 1, 15], [x, 1, 0, None]]
+
+    assert integration_reduction_dynamic(facets, 0, a, b, x, 1, (x, y), 1,\
+                                         0, 1, x0, monomial_values, 3) == Rational(25, 2)
+    assert integration_reduction_dynamic(facets, 0, a, b, 0, 1, (x, y), 1,\
+                                         0, 1, x0, monomial_values, 3) == 0
+
+
+def test_is_vertex():
+    assert is_vertex(2) is False
+    assert is_vertex((2, 3)) is True
+    assert is_vertex(Point(2, 3)) is True
+    assert is_vertex((2, 3, 4)) is True
+    assert is_vertex((2, 3, 4, 5)) is False
+
+
+def test_issue_19234():
+    polygon = Polygon(Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
+    polys =  [ 1, x, y, x*y, x**2*y, x*y**2]
+    assert polytope_integrate(polygon, polys) == \
+        {1: 1, x: S.Half, y: S.Half, x*y: Rational(1, 4), x**2*y: Rational(1, 6), x*y**2: Rational(1, 6)}
+    polys =  [ 1, x, y, x*y, 3 + x**2*y, x + x*y**2]
+    assert polytope_integrate(polygon, polys) == \
+        {1: 1, x: S.Half, y: S.Half, x*y: Rational(1, 4), x**2*y + 3: Rational(19, 6), x*y**2 + x: Rational(2, 3)}

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_laplace.py

@@ -0,0 +1,769 @@
+from sympy.integrals.laplace import (
+    laplace_transform, inverse_laplace_transform,
+    LaplaceTransform, InverseLaplaceTransform,
+    _laplace_deep_collect, laplace_correspondence,
+    laplace_initial_conds)
+from sympy.core.function import Function, expand_mul
+from sympy.core import EulerGamma, Subs, Derivative, diff
+from sympy.core.exprtools import factor_terms
+from sympy.core.numbers import I, oo, pi
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, symbols
+from sympy.simplify.simplify import simplify
+from sympy.functions.elementary.complexes import Abs, re
+from sympy.functions.elementary.exponential import exp, log, exp_polar
+from sympy.functions.elementary.hyperbolic import cosh, sinh, coth, asinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import atan, cos, sin
+from sympy.logic.boolalg import And
+from sympy.functions.special.gamma_functions import (
+    lowergamma, gamma, uppergamma)
+from sympy.functions.special.delta_functions import DiracDelta, Heaviside
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.functions.special.zeta_functions import lerchphi
+from sympy.functions.special.error_functions import (
+    fresnelc, fresnels, erf, erfc, Ei, Ci, expint, E1)
+from sympy.functions.special.bessel import besseli, besselj, besselk, bessely
+from sympy.testing.pytest import slow, warns_deprecated_sympy
+from sympy.matrices import Matrix, eye
+from sympy.abc import s
+
+
+@slow
+def test_laplace_transform():
+    LT = laplace_transform
+    ILT = inverse_laplace_transform
+    a, b, c = symbols('a, b, c', positive=True)
+    np = symbols('np', integer=True, positive=True)
+    t, w, x = symbols('t, w, x')
+    f = Function('f')
+    F = Function('F')
+    g = Function('g')
+    y = Function('y')
+    Y = Function('Y')
+
+    # Test helper functions
+    assert (
+        _laplace_deep_collect(exp((t+a)*(t+b)) +
+                              besselj(2, exp((t+a)*(t+b)-t**2)), t) ==
+        exp(a*b + t**2 + t*(a + b)) + besselj(2, exp(a*b + t*(a + b))))
+    L = laplace_transform(diff(y(t), t, 3), t, s, noconds=True)
+    L = laplace_correspondence(L, {y: Y})
+    L = laplace_initial_conds(L, t, {y: [2, 4, 8, 16, 32]})
+    assert L == s**3*Y(s) - 2*s**2 - 4*s - 8
+    # Test whether `noconds=True` in `doit`:
+    assert (2*LaplaceTransform(exp(t), t, s) - 1).doit() == -1 + 2/(s - 1)
+    assert (LT(a*t+t**2+t**(S(5)/2), t, s) ==
+            (a/s**2 + 2/s**3 + 15*sqrt(pi)/(8*s**(S(7)/2)), 0, True))
+    assert LT(b/(t+a), t, s) == (-b*exp(-a*s)*Ei(-a*s), 0, True)
+    assert (LT(1/sqrt(t+a), t, s) ==
+            (sqrt(pi)*sqrt(1/s)*exp(a*s)*erfc(sqrt(a)*sqrt(s)), 0, True))
+    assert (LT(sqrt(t)/(t+a), t, s) ==
+            (-pi*sqrt(a)*exp(a*s)*erfc(sqrt(a)*sqrt(s)) + sqrt(pi)*sqrt(1/s),
+             0, True))
+    assert (LT((t+a)**(-S(3)/2), t, s) ==
+            (-2*sqrt(pi)*sqrt(s)*exp(a*s)*erfc(sqrt(a)*sqrt(s)) + 2/sqrt(a),
+             0, True))
+    assert (LT(t**(S(1)/2)*(t+a)**(-1), t, s) ==
+            (-pi*sqrt(a)*exp(a*s)*erfc(sqrt(a)*sqrt(s)) + sqrt(pi)*sqrt(1/s),
+             0, True))
+    assert (LT(1/(a*sqrt(t) + t**(3/2)), t, s) ==
+            (pi*sqrt(a)*exp(a*s)*erfc(sqrt(a)*sqrt(s)), 0, True))
+    assert (LT((t+a)**b, t, s) ==
+            (s**(-b - 1)*exp(-a*s)*uppergamma(b + 1, a*s), 0, True))
+    assert LT(t**5/(t+a), t, s) == (120*a**5*uppergamma(-5, a*s), 0, True)
+    assert LT(exp(t), t, s) == (1/(s - 1), 1, True)
+    assert LT(exp(2*t), t, s) == (1/(s - 2), 2, True)
+    assert LT(exp(a*t), t, s) == (1/(s - a), a, True)
+    assert LT(exp(a*(t-b)), t, s) == (exp(-a*b)/(-a + s), a, True)
+    assert LT(t*exp(-a*(t)), t, s) == ((a + s)**(-2), -a, True)
+    assert LT(t*exp(-a*(t-b)), t, s) == (exp(a*b)/(a + s)**2, -a, True)
+    assert LT(b*t*exp(-a*t), t, s) == (b/(a + s)**2, -a, True)
+    assert LT(exp(-a*exp(-t)), t, s) == (lowergamma(s, a)/a**s, 0, True)
+    assert LT(exp(-a*exp(t)), t, s) == (a**s*uppergamma(-s, a), 0, True)
+    assert (LT(t**(S(7)/4)*exp(-8*t)/gamma(S(11)/4), t, s) ==
+            ((s + 8)**(-S(11)/4), -8, True))
+    assert (LT(t**(S(3)/2)*exp(-8*t), t, s) ==
+            (3*sqrt(pi)/(4*(s + 8)**(S(5)/2)), -8, True))
+    assert LT(t**a*exp(-a*t), t, s) == ((a+s)**(-a-1)*gamma(a+1), -a, True)
+    assert (LT(b*exp(-a*t**2), t, s) ==
+            (sqrt(pi)*b*exp(s**2/(4*a))*erfc(s/(2*sqrt(a)))/(2*sqrt(a)),
+             0, True))
+    assert (LT(exp(-2*t**2), t, s) ==
+            (sqrt(2)*sqrt(pi)*exp(s**2/8)*erfc(sqrt(2)*s/4)/4, 0, True))
+    assert (LT(b*exp(2*t**2), t, s) ==
+            (b*LaplaceTransform(exp(2*t**2), t, s), -oo, True))
+    assert (LT(t*exp(-a*t**2), t, s) ==
+            (1/(2*a) - s*erfc(s/(2*sqrt(a)))/(4*sqrt(pi)*a**(S(3)/2)),
+             0, True))
+    assert (LT(exp(-a/t), t, s) ==
+            (2*sqrt(a)*sqrt(1/s)*besselk(1, 2*sqrt(a)*sqrt(s)), 0, True))
+    assert LT(sqrt(t)*exp(-a/t), t, s, simplify=True) == (
+        sqrt(pi)*(sqrt(a)*sqrt(s) + 1/S(2))*sqrt(s**(-3)) *
+        exp(-2*sqrt(a)*sqrt(s)), 0, True)
+    assert (LT(exp(-a/t)/sqrt(t), t, s) ==
+            (sqrt(pi)*sqrt(1/s)*exp(-2*sqrt(a)*sqrt(s)), 0, True))
+    assert (LT(exp(-a/t)/(t*sqrt(t)), t, s) ==
+            (sqrt(pi)*sqrt(1/a)*exp(-2*sqrt(a)*sqrt(s)), 0, True))
+    assert (
+        LT(exp(-2*sqrt(a*t)), t, s) ==
+        (1/s - sqrt(pi)*sqrt(a) * exp(a/s)*erfc(sqrt(a)*sqrt(1/s)) /
+         s**(S(3)/2), 0, True))
+    assert LT(exp(-2*sqrt(a*t))/sqrt(t), t, s) == (
+        exp(a/s)*erfc(sqrt(a) * sqrt(1/s))*(sqrt(pi)*sqrt(1/s)), 0, True)
+    assert (LT(t**4*exp(-2/t), t, s) ==
+            (8*sqrt(2)*(1/s)**(S(5)/2)*besselk(5, 2*sqrt(2)*sqrt(s)),
+             0, True))
+    assert LT(sinh(a*t), t, s) == (a/(-a**2 + s**2), a, True)
+    assert (LT(b*sinh(a*t)**2, t, s) ==
+            (2*a**2*b/(-4*a**2*s + s**3), 2*a, True))
+    assert (LT(b*sinh(a*t)**2, t, s, simplify=True) ==
+            (2*a**2*b/(s*(-4*a**2 + s**2)), 2*a, True))
+    # The following line confirms that issue #21202 is solved
+    assert LT(cosh(2*t), t, s) == (s/(-4 + s**2), 2, True)
+    assert LT(cosh(a*t), t, s) == (s/(-a**2 + s**2), a, True)
+    assert (LT(cosh(a*t)**2, t, s, simplify=True) ==
+            ((2*a**2 - s**2)/(s*(4*a**2 - s**2)), 2*a, True))
+    assert (LT(sinh(x+3), x, s, simplify=True) ==
+            ((s*sinh(3) + cosh(3))/(s**2 - 1), 1, True))
+    L, _, _ = LT(42*sin(w*t+x)**2, t, s)
+    assert (
+        L -
+        21*(s**2 + s*(-s*cos(2*x) + 2*w*sin(2*x)) +
+            4*w**2)/(s*(s**2 + 4*w**2))).simplify() == 0
+    # The following line replaces the old test test_issue_7173()
+    assert LT(sinh(a*t)*cosh(a*t), t, s, simplify=True) == (a/(-4*a**2 + s**2),
+                                                            2*a, True)
+    assert LT(sinh(a*t)/t, t, s) == (log((a + s)/(-a + s))/2, a, True)
+    assert (LT(t**(-S(3)/2)*sinh(a*t), t, s) ==
+            (-sqrt(pi)*(sqrt(-a + s) - sqrt(a + s)), a, True))
+    assert (LT(sinh(2*sqrt(a*t)), t, s) ==
+            (sqrt(pi)*sqrt(a)*exp(a/s)/s**(S(3)/2), 0, True))
+    assert (LT(sqrt(t)*sinh(2*sqrt(a*t)), t, s, simplify=True) ==
+            ((-sqrt(a)*s**(S(5)/2) + sqrt(pi)*s**2*(2*a + s)*exp(a/s) *
+              erf(sqrt(a)*sqrt(1/s))/2)/s**(S(9)/2), 0, True))
+    assert (LT(sinh(2*sqrt(a*t))/sqrt(t), t, s) ==
+            (sqrt(pi)*exp(a/s)*erf(sqrt(a)*sqrt(1/s))/sqrt(s), 0, True))
+    assert (LT(sinh(sqrt(a*t))**2/sqrt(t), t, s) ==
+            (sqrt(pi)*(exp(a/s) - 1)/(2*sqrt(s)), 0, True))
+    assert (LT(t**(S(3)/7)*cosh(a*t), t, s) ==
+            (((a + s)**(-S(10)/7) + (-a+s)**(-S(10)/7))*gamma(S(10)/7)/2,
+             a, True))
+    assert (LT(cosh(2*sqrt(a*t)), t, s) ==
+            (sqrt(pi)*sqrt(a)*exp(a/s)*erf(sqrt(a)*sqrt(1/s))/s**(S(3)/2) +
+             1/s, 0, True))
+    assert (LT(sqrt(t)*cosh(2*sqrt(a*t)), t, s) ==
+            (sqrt(pi)*(a + s/2)*exp(a/s)/s**(S(5)/2), 0, True))
+    assert (LT(cosh(2*sqrt(a*t))/sqrt(t), t, s) ==
+            (sqrt(pi)*exp(a/s)/sqrt(s), 0, True))
+    assert (LT(cosh(sqrt(a*t))**2/sqrt(t), t, s) ==
+            (sqrt(pi)*(exp(a/s) + 1)/(2*sqrt(s)), 0, True))
+    assert LT(log(t), t, s, simplify=True) == (
+        (-log(s) - EulerGamma)/s, 0, True)
+    assert (LT(-log(t/a), t, s, simplify=True) ==
+            ((log(a) + log(s) + EulerGamma)/s, 0, True))
+    assert LT(log(1+a*t), t, s) == (-exp(s/a)*Ei(-s/a)/s, 0, True)
+    assert (LT(log(t+a), t, s, simplify=True) ==
+            ((s*log(a) - exp(s/a)*Ei(-s/a))/s**2, 0, True))
+    assert (LT(log(t)/sqrt(t), t, s, simplify=True) ==
+            (sqrt(pi)*(-log(s) - log(4) - EulerGamma)/sqrt(s), 0, True))
+    assert (LT(t**(S(5)/2)*log(t), t, s, simplify=True) ==
+            (sqrt(pi)*(-15*log(s) - log(1073741824) - 15*EulerGamma + 46) /
+             (8*s**(S(7)/2)), 0, True))
+    assert (LT(t**3*log(t), t, s, noconds=True, simplify=True) -
+            6*(-log(s) - S.EulerGamma + S(11)/6)/s**4).simplify() == S.Zero
+    assert (LT(log(t)**2, t, s, simplify=True) ==
+            (((log(s) + EulerGamma)**2 + pi**2/6)/s, 0, True))
+    assert (LT(exp(-a*t)*log(t), t, s, simplify=True) ==
+            ((-log(a + s) - EulerGamma)/(a + s), -a, True))
+    assert LT(sin(a*t), t, s) == (a/(a**2 + s**2), 0, True)
+    assert (LT(Abs(sin(a*t)), t, s) ==
+            (a*coth(pi*s/(2*a))/(a**2 + s**2), 0, True))
+    assert LT(sin(a*t)/t, t, s) == (atan(a/s), 0, True)
+    assert LT(sin(a*t)**2/t, t, s) == (log(4*a**2/s**2 + 1)/4, 0, True)
+    assert (LT(sin(a*t)**2/t**2, t, s) ==
+            (a*atan(2*a/s) - s*log(4*a**2/s**2 + 1)/4, 0, True))
+    assert (LT(sin(2*sqrt(a*t)), t, s) ==
+            (sqrt(pi)*sqrt(a)*exp(-a/s)/s**(S(3)/2), 0, True))
+    assert LT(sin(2*sqrt(a*t))/t, t, s) == (pi*erf(sqrt(a)*sqrt(1/s)), 0, True)
+    assert LT(cos(a*t), t, s) == (s/(a**2 + s**2), 0, True)
+    assert (LT(cos(a*t)**2, t, s) ==
+            ((2*a**2 + s**2)/(s*(4*a**2 + s**2)), 0, True))
+    assert (LT(sqrt(t)*cos(2*sqrt(a*t)), t, s, simplify=True) ==
+            (sqrt(pi)*(-a + s/2)*exp(-a/s)/s**(S(5)/2), 0, True))
+    assert (LT(cos(2*sqrt(a*t))/sqrt(t), t, s) ==
+            (sqrt(pi)*sqrt(1/s)*exp(-a/s), 0, True))
+    assert (LT(sin(a*t)*sin(b*t), t, s) ==
+            (2*a*b*s/((s**2 + (a - b)**2)*(s**2 + (a + b)**2)), 0, True))
+    assert (LT(cos(a*t)*sin(b*t), t, s) ==
+            (b*(-a**2 + b**2 + s**2)/((s**2 + (a - b)**2)*(s**2 + (a + b)**2)),
+             0, True))
+    assert (LT(cos(a*t)*cos(b*t), t, s) ==
+            (s*(a**2 + b**2 + s**2)/((s**2 + (a - b)**2)*(s**2 + (a + b)**2)),
+             0, True))
+    assert (LT(-a*t*cos(a*t) + sin(a*t), t, s, simplify=True) ==
+            (2*a**3/(a**4 + 2*a**2*s**2 + s**4), 0, True))
+    assert LT(c*exp(-b*t)*sin(a*t), t, s) == (a *
+                                              c/(a**2 + (b + s)**2), -b, True)
+    assert LT(c*exp(-b*t)*cos(a*t), t, s) == (c*(b + s)/(a**2 + (b + s)**2),
+                                              -b, True)
+    L, plane, cond = LT(cos(x + 3), x, s, simplify=True)
+    assert plane == 0
+    assert L - (s*cos(3) - sin(3))/(s**2 + 1) == 0
+    # Error functions (laplace7.pdf)
+    assert LT(erf(a*t), t, s) == (exp(s**2/(4*a**2))*erfc(s/(2*a))/s, 0, True)
+    assert LT(erf(sqrt(a*t)), t, s) == (sqrt(a)/(s*sqrt(a + s)), 0, True)
+    assert (LT(exp(a*t)*erf(sqrt(a*t)), t, s, simplify=True) ==
+            (-sqrt(a)/(sqrt(s)*(a - s)), a, True))
+    assert (LT(erf(sqrt(a/t)/2), t, s, simplify=True) ==
+            (1/s - exp(-sqrt(a)*sqrt(s))/s, 0, True))
+    assert (LT(erfc(sqrt(a*t)), t, s, simplify=True) ==
+            (-sqrt(a)/(s*sqrt(a + s)) + 1/s, -a, True))
+    assert (LT(exp(a*t)*erfc(sqrt(a*t)), t, s) ==
+            (1/(sqrt(a)*sqrt(s) + s), 0, True))
+    assert LT(erfc(sqrt(a/t)/2), t, s) == (exp(-sqrt(a)*sqrt(s))/s, 0, True)
+    # Bessel functions (laplace8.pdf)
+    assert LT(besselj(0, a*t), t, s) == (1/sqrt(a**2 + s**2), 0, True)
+    assert (LT(besselj(1, a*t), t, s, simplify=True) ==
+            (a/(a**2 + s**2 + s*sqrt(a**2 + s**2)), 0, True))
+    assert (LT(besselj(2, a*t), t, s, simplify=True) ==
+            (a**2/(sqrt(a**2 + s**2)*(s + sqrt(a**2 + s**2))**2), 0, True))
+    assert (LT(t*besselj(0, a*t), t, s) ==
+            (s/(a**2 + s**2)**(S(3)/2), 0, True))
+    assert (LT(t*besselj(1, a*t), t, s) ==
+            (a/(a**2 + s**2)**(S(3)/2), 0, True))
+    assert (LT(t**2*besselj(2, a*t), t, s) ==
+            (3*a**2/(a**2 + s**2)**(S(5)/2), 0, True))
+    assert LT(besselj(0, 2*sqrt(a*t)), t, s) == (exp(-a/s)/s, 0, True)
+    assert (LT(t**(S(3)/2)*besselj(3, 2*sqrt(a*t)), t, s) ==
+            (a**(S(3)/2)*exp(-a/s)/s**4, 0, True))
+    assert (LT(besselj(0, a*sqrt(t**2+b*t)), t, s, simplify=True) ==
+            (exp(b*(s - sqrt(a**2 + s**2)))/sqrt(a**2 + s**2), 0, True))
+    assert LT(besseli(0, a*t), t, s) == (1/sqrt(-a**2 + s**2), a, True)
+    assert (LT(besseli(1, a*t), t, s, simplify=True) ==
+            (a/(-a**2 + s**2 + s*sqrt(-a**2 + s**2)), a, True))
+    assert (LT(besseli(2, a*t), t, s, simplify=True) ==
+            (a**2/(sqrt(-a**2 + s**2)*(s + sqrt(-a**2 + s**2))**2), a, True))
+    assert LT(t*besseli(0, a*t), t, s) == (s/(-a**2 + s**2)**(S(3)/2), a, True)
+    assert LT(t*besseli(1, a*t), t, s) == (a/(-a**2 + s**2)**(S(3)/2), a, True)
+    assert (LT(t**2*besseli(2, a*t), t, s) ==
+            (3*a**2/(-a**2 + s**2)**(S(5)/2), a, True))
+    assert (LT(t**(S(3)/2)*besseli(3, 2*sqrt(a*t)), t, s) ==
+            (a**(S(3)/2)*exp(a/s)/s**4, 0, True))
+    assert (LT(bessely(0, a*t), t, s) ==
+            (-2*asinh(s/a)/(pi*sqrt(a**2 + s**2)), 0, True))
+    assert (LT(besselk(0, a*t), t, s) ==
+            (log((s + sqrt(-a**2 + s**2))/a)/sqrt(-a**2 + s**2), -a, True))
+    assert (LT(sin(a*t)**4, t, s, simplify=True) ==
+            (24*a**4/(s*(64*a**4 + 20*a**2*s**2 + s**4)), 0, True))
+    # Test general rules and unevaluated forms
+    # These all also test whether issue #7219 is solved.
+    assert LT(Heaviside(t-1)*cos(t-1), t, s) == (s*exp(-s)/(s**2 + 1), 0, True)
+    assert LT(a*f(t), t, w) == (a*LaplaceTransform(f(t), t, w), -oo, True)
+    assert (LT(a*Heaviside(t+1)*f(t+1), t, s) ==
+            (a*LaplaceTransform(f(t + 1), t, s), -oo, True))
+    assert (LT(a*Heaviside(t-1)*f(t-1), t, s) ==
+            (a*LaplaceTransform(f(t), t, s)*exp(-s), -oo, True))
+    assert (LT(b*f(t/a), t, s) ==
+            (a*b*LaplaceTransform(f(t), t, a*s), -oo, True))
+    assert LT(exp(-f(x)*t), t, s) == (1/(s + f(x)), -re(f(x)), True)
+    assert (LT(exp(-a*t)*f(t), t, s) ==
+            (LaplaceTransform(f(t), t, a + s), -oo, True))
+    assert (LT(exp(-a*t)*erfc(sqrt(b/t)/2), t, s) ==
+            (exp(-sqrt(b)*sqrt(a + s))/(a + s), -a, True))
+    assert (LT(sinh(a*t)*f(t), t, s) ==
+            (LaplaceTransform(f(t), t, -a + s)/2 -
+             LaplaceTransform(f(t), t, a + s)/2, -oo, True))
+    assert (LT(sinh(a*t)*t, t, s, simplify=True) ==
+            (2*a*s/(a**4 - 2*a**2*s**2 + s**4), a, True))
+    assert (LT(cosh(a*t)*f(t), t, s) ==
+            (LaplaceTransform(f(t), t, -a + s)/2 +
+             LaplaceTransform(f(t), t, a + s)/2, -oo, True))
+    assert (LT(cosh(a*t)*t, t, s, simplify=True) ==
+            (1/(2*(a + s)**2) + 1/(2*(a - s)**2), a, True))
+    assert (LT(sin(a*t)*f(t), t, s, simplify=True) ==
+            (I*(-LaplaceTransform(f(t), t, -I*a + s) +
+                LaplaceTransform(f(t), t, I*a + s))/2, -oo, True))
+    assert (LT(sin(f(t)), t, s) ==
+            (LaplaceTransform(sin(f(t)), t, s), -oo, True))
+    assert (LT(sin(a*t)*t, t, s, simplify=True) ==
+            (2*a*s/(a**4 + 2*a**2*s**2 + s**4), 0, True))
+    assert (LT(cos(a*t)*f(t), t, s) ==
+            (LaplaceTransform(f(t), t, -I*a + s)/2 +
+             LaplaceTransform(f(t), t, I*a + s)/2, -oo, True))
+    assert (LT(cos(a*t)*t, t, s, simplify=True) ==
+            ((-a**2 + s**2)/(a**4 + 2*a**2*s**2 + s**4), 0, True))
+    L, plane, _ = LT(sin(a*t+b)**2*f(t), t, s)
+    assert plane == -oo
+    assert (
+        -L + (
+            LaplaceTransform(f(t), t, s)/2 -
+            LaplaceTransform(f(t), t, -2*I*a + s)*exp(2*I*b)/4 -
+            LaplaceTransform(f(t), t, 2*I*a + s)*exp(-2*I*b)/4)) == 0
+    L = LT(sin(a*t+b)**2*f(t), t, s, noconds=True)
+    assert (
+        laplace_correspondence(L, {f: F}) ==
+        F(s)/2 - F(-2*I*a + s)*exp(2*I*b)/4 -
+        F(2*I*a + s)*exp(-2*I*b)/4)
+    L, plane, _ = LT(sin(a*t)**3*cosh(b*t), t, s)
+    assert plane == b
+    assert (
+        -L - 3*a/(8*(9*a**2 + b**2 + 2*b*s + s**2)) -
+        3*a/(8*(9*a**2 + b**2 - 2*b*s + s**2)) +
+        3*a/(8*(a**2 + b**2 + 2*b*s + s**2)) +
+        3*a/(8*(a**2 + b**2 - 2*b*s + s**2))).simplify() == 0
+    assert (LT(t**2*exp(-t**2), t, s) ==
+            (sqrt(pi)*s**2*exp(s**2/4)*erfc(s/2)/8 - s/4 +
+             sqrt(pi)*exp(s**2/4)*erfc(s/2)/4, 0, True))
+    assert (LT((a*t**2 + b*t + c)*f(t), t, s) ==
+            (a*Derivative(LaplaceTransform(f(t), t, s), (s, 2)) -
+             b*Derivative(LaplaceTransform(f(t), t, s), s) +
+            c*LaplaceTransform(f(t), t, s), -oo, True))
+    assert (LT(t**np*g(t), t, s) ==
+            ((-1)**np*Derivative(LaplaceTransform(g(t), t, s), (s, np)),
+             -oo, True))
+    # The following tests check whether _piecewise_to_heaviside works:
+    x1 = Piecewise((0, t <= 0), (1, t <= 1), (0, True))
+    X1 = LT(x1, t, s)[0]
+    assert X1 == 1/s - exp(-s)/s
+    y1 = ILT(X1, s, t)
+    assert y1 == Heaviside(t) - Heaviside(t - 1)
+    x1 = Piecewise((0, t <= 0), (t, t <= 1), (2-t, t <= 2), (0, True))
+    X1 = LT(x1, t, s)[0].simplify()
+    assert X1 == (exp(2*s) - 2*exp(s) + 1)*exp(-2*s)/s**2
+    y1 = ILT(X1, s, t)
+    assert (
+        -y1 + t*Heaviside(t) + (t - 2)*Heaviside(t - 2) -
+        2*(t - 1)*Heaviside(t - 1)).simplify() == 0
+    x1 = Piecewise((exp(t), t <= 0), (1, t <= 1), (exp(-(t)), True))
+    X1 = LT(x1, t, s)[0]
+    assert X1 == exp(-1)*exp(-s)/(s + 1) + 1/s - exp(-s)/s
+    y1 = ILT(X1, s, t)
+    assert y1 == (
+        exp(-1)*exp(1 - t)*Heaviside(t - 1) + Heaviside(t) - Heaviside(t - 1))
+    x1 = Piecewise((0, x <= 0), (1, x <= 1), (0, True))
+    X1 = LT(x1, t, s)[0]
+    assert X1 == Piecewise((0, x <= 0), (1, x <= 1), (0, True))/s
+    x1 = [
+        a*Piecewise((1, And(t > 1, t <= 3)), (2, True)),
+        a*Piecewise((1, And(t >= 1, t <= 3)), (2, True)),
+        a*Piecewise((1, And(t >= 1, t < 3)), (2, True)),
+        a*Piecewise((1, And(t > 1, t < 3)), (2, True))]
+    for x2 in x1:
+        assert LT(x2, t, s)[0].expand() == 2*a/s - a*exp(-s)/s + a*exp(-3*s)/s
+    assert (
+        LT(Piecewise((1, Eq(t, 1)), (2, True)), t, s)[0] ==
+        LaplaceTransform(Piecewise((1, Eq(t, 1)), (2, True)), t, s))
+    # The following lines test whether _laplace_transform successfully
+    # removes Heaviside(1) before processing espressions. It fails if
+    # Heaviside(t) remains because then meijerg functions will appear.
+    X1 = 1/sqrt(a*s**2-b)
+    x1 = ILT(X1, s, t)
+    Y1 = LT(x1, t, s)[0]
+    Z1 = (Y1**2/X1**2).simplify()
+    assert Z1 == 1
+    # The following two lines test whether issues #5813 and #7176 are solved.
+    assert (LT(diff(f(t), (t, 1)), t, s, noconds=True) ==
+            s*LaplaceTransform(f(t), t, s) - f(0))
+    assert (LT(diff(f(t), (t, 3)), t, s, noconds=True) ==
+            s**3*LaplaceTransform(f(t), t, s) - s**2*f(0) -
+            s*Subs(Derivative(f(t), t), t, 0) -
+            Subs(Derivative(f(t), (t, 2)), t, 0))
+    # Issue #7219
+    assert (LT(diff(f(x, t, w), t, 2), t, s) ==
+            (s**2*LaplaceTransform(f(x, t, w), t, s) - s*f(x, 0, w) -
+             Subs(Derivative(f(x, t, w), t), t, 0), -oo, True))
+    # Issue #23307
+    assert (LT(10*diff(f(t), (t, 1)), t, s, noconds=True) ==
+            10*s*LaplaceTransform(f(t), t, s) - 10*f(0))
+    assert (LT(a*f(b*t)+g(c*t), t, s, noconds=True) ==
+            a*LaplaceTransform(f(t), t, s/b)/b +
+            LaplaceTransform(g(t), t, s/c)/c)
+    assert inverse_laplace_transform(
+        f(w), w, t, plane=0) == InverseLaplaceTransform(f(w), w, t, 0)
+    assert (LT(f(t)*g(t), t, s, noconds=True) ==
+            LaplaceTransform(f(t)*g(t), t, s))
+    # Issue #24294
+    assert (LT(b*f(a*t), t, s, noconds=True) ==
+            b*LaplaceTransform(f(t), t, s/a)/a)
+    assert LT(3*exp(t)*Heaviside(t), t, s) == (3/(s - 1), 1, True)
+    assert (LT(2*sin(t)*Heaviside(t), t, s, simplify=True) ==
+            (2/(s**2 + 1), 0, True))
+    # Issue #25293
+    assert (
+        LT((1/(t-1))*sin(4*pi*(t-1))*DiracDelta(t-1) *
+           (Heaviside(t-1/4) - Heaviside(t-2)), t, s)[0] == 4*pi*exp(-s))
+    # additional basic tests from wikipedia
+    assert (LT((t - a)**b*exp(-c*(t - a))*Heaviside(t - a), t, s) ==
+            ((c + s)**(-b - 1)*exp(-a*s)*gamma(b + 1), -c, True))
+    assert (
+        LT((exp(2*t)-1)*exp(-b-t)*Heaviside(t)/2, t, s, noconds=True,
+           simplify=True) ==
+        exp(-b)/(s**2 - 1))
+    # DiracDelta function: standard cases
+    assert LT(DiracDelta(t), t, s) == (1, -oo, True)
+    assert LT(DiracDelta(a*t), t, s) == (1/a, -oo, True)
+    assert LT(DiracDelta(t/42), t, s) == (42, -oo, True)
+    assert LT(DiracDelta(t+42), t, s) == (0, -oo, True)
+    assert (LT(DiracDelta(t)+DiracDelta(t-42), t, s) ==
+            (1 + exp(-42*s), -oo, True))
+    assert (LT(DiracDelta(t)-a*exp(-a*t), t, s, simplify=True) ==
+            (s/(a + s), -a, True))
+    assert (
+        LT(exp(-t)*(DiracDelta(t)+DiracDelta(t-42)), t, s, simplify=True) ==
+        (exp(-42*s - 42) + 1, -oo, True))
+    assert LT(f(t)*DiracDelta(t-42), t, s) == (f(42)*exp(-42*s), -oo, True)
+    assert LT(f(t)*DiracDelta(b*t-a), t, s) == (f(a/b)*exp(-a*s/b)/b,
+                                                -oo, True)
+    assert LT(f(t)*DiracDelta(b*t+a), t, s) == (0, -oo, True)
+    # SingularityFunction
+    assert LT(SingularityFunction(t, a, -1), t, s)[0] == exp(-a*s)
+    assert LT(SingularityFunction(t, a, 1), t, s)[0] == exp(-a*s)/s**2
+    assert LT(SingularityFunction(t, a, x), t, s)[0] == (
+        LaplaceTransform(SingularityFunction(t, a, x), t, s))
+    # Collection of cases that cannot be fully evaluated and/or would catch
+    # some common implementation errors
+    assert (LT(DiracDelta(t**2), t, s, noconds=True) ==
+            LaplaceTransform(DiracDelta(t**2), t, s))
+    assert LT(DiracDelta(t**2 - 1), t, s) == (exp(-s)/2, -oo, True)
+    assert LT(DiracDelta(t*(1 - t)), t, s) == (1 - exp(-s), -oo, True)
+    assert (LT((DiracDelta(t) + 1)*(DiracDelta(t - 1) + 1), t, s) ==
+            (LaplaceTransform(DiracDelta(t)*DiracDelta(t - 1), t, s) +
+             1 + exp(-s) + 1/s, 0, True))
+    assert LT(DiracDelta(2*t-2*exp(a)), t, s) == (exp(-s*exp(a))/2, -oo, True)
+    assert LT(DiracDelta(-2*t+2*exp(a)), t, s) == (exp(-s*exp(a))/2, -oo, True)
+    # Heaviside tests
+    assert LT(Heaviside(t), t, s) == (1/s, 0, True)
+    assert LT(Heaviside(t - a), t, s) == (exp(-a*s)/s, 0, True)
+    assert LT(Heaviside(t-1), t, s) == (exp(-s)/s, 0, True)
+    assert LT(Heaviside(2*t-4), t, s) == (exp(-2*s)/s, 0, True)
+    assert LT(Heaviside(2*t+4), t, s) == (1/s, 0, True)
+    assert (LT(Heaviside(-2*t+4), t, s, simplify=True) ==
+            (1/s - exp(-2*s)/s, 0, True))
+    assert (LT(g(t)*Heaviside(t - w), t, s) ==
+            (LaplaceTransform(g(t)*Heaviside(t - w), t, s), -oo, True))
+    assert (
+        LT(Heaviside(t-a)*g(t), t, s) ==
+        (LaplaceTransform(g(a + t), t, s)*exp(-a*s), -oo, True))
+    assert (
+        LT(Heaviside(t+a)*g(t), t, s) ==
+        (LaplaceTransform(g(t), t, s), -oo, True))
+    assert (
+        LT(Heaviside(-t+a)*g(t), t, s) ==
+        (LaplaceTransform(g(t), t, s) -
+         LaplaceTransform(g(a + t), t, s)*exp(-a*s), -oo, True))
+    assert (
+        LT(Heaviside(-t-a)*g(t), t, s) == (0, 0, True))
+    # Fresnel functions
+    assert (laplace_transform(fresnels(t), t, s, simplify=True) ==
+            ((-sin(s**2/(2*pi))*fresnels(s/pi) +
+              sqrt(2)*sin(s**2/(2*pi) + pi/4)/2 -
+              cos(s**2/(2*pi))*fresnelc(s/pi))/s, 0, True))
+    assert (laplace_transform(fresnelc(t), t, s, simplify=True) ==
+            ((sin(s**2/(2*pi))*fresnelc(s/pi) -
+              cos(s**2/(2*pi))*fresnels(s/pi) +
+              sqrt(2)*cos(s**2/(2*pi) + pi/4)/2)/s, 0, True))
+    # Matrix tests
+    Mt = Matrix([[exp(t), t*exp(-t)], [t*exp(-t), exp(t)]])
+    Ms = Matrix([[1/(s - 1), (s + 1)**(-2)],
+                 [(s + 1)**(-2),     1/(s - 1)]])
+    # The default behaviour for Laplace transform of a Matrix returns a Matrix
+    # of Tuples and is deprecated:
+    with warns_deprecated_sympy():
+        Ms_conds = Matrix(
+            [[(1/(s - 1), 1, True), ((s + 1)**(-2), -1, True)],
+             [((s + 1)**(-2), -1, True), (1/(s - 1), 1, True)]])
+    with warns_deprecated_sympy():
+        assert LT(Mt, t, s) == Ms_conds
+    # The new behavior is to return a tuple of a Matrix and the convergence
+    # conditions for the matrix as a whole:
+    assert LT(Mt, t, s, legacy_matrix=False) == (Ms, 1, True)
+    # With noconds=True the transformed matrix is returned without conditions
+    # either way:
+    assert LT(Mt, t, s, noconds=True) == Ms
+    assert LT(Mt, t, s, legacy_matrix=False, noconds=True) == Ms
+
+
+@slow
+def test_inverse_laplace_transform():
+    s = symbols('s')
+    k, n, t = symbols('k, n, t', real=True)
+    a, b, c, d = symbols('a, b, c, d', positive=True)
+    f = Function('f')
+    F = Function('F')
+
+    def ILT(g):
+        return inverse_laplace_transform(g, s, t)
+
+    def ILTS(g):
+        return inverse_laplace_transform(g, s, t, simplify=True)
+
+    def ILTF(g):
+        return laplace_correspondence(
+            inverse_laplace_transform(g, s, t), {f: F})
+
+    # Tests for the rules in Bateman54.
+
+    # Section 4.1: Some of the Laplace transform rules can also be used well
+    #     in the inverse transform.
+    assert ILTF(exp(-a*s)*F(s)) == f(-a + t)
+    assert ILTF(k*F(s-a)) == k*f(t)*exp(-a*t)
+    assert ILTF(diff(F(s), s, 3)) == -t**3*f(t)
+    assert ILTF(diff(F(s), s, 4)) == t**4*f(t)
+
+    # Section 5.1: Most rules are impractical for a computer algebra system.
+
+    # Section 5.2: Rational functions
+    assert ILT(2) == 2*DiracDelta(t)
+    assert ILT(1/s) == Heaviside(t)
+    assert ILT(1/s**2) == t*Heaviside(t)
+    assert ILT(1/s**5) == t**4*Heaviside(t)/24
+    assert ILT(1/s**n) == t**(n - 1)*Heaviside(t)/gamma(n)
+    assert ILT(a/(a + s)) == a*exp(-a*t)*Heaviside(t)
+    assert ILT(s/(a + s)) == -a*exp(-a*t)*Heaviside(t) + DiracDelta(t)
+    assert (ILT(b*s/(s+a)**2) ==
+            b*(-a*t*exp(-a*t)*Heaviside(t) + exp(-a*t)*Heaviside(t)))
+    assert (ILTS(c/((s+a)*(s+b))) ==
+            c*(exp(a*t) - exp(b*t))*exp(-t*(a + b))*Heaviside(t)/(a - b))
+    assert (ILTS(c*s/((s+a)*(s+b))) ==
+            c*(a*exp(b*t) - b*exp(a*t))*exp(-t*(a + b))*Heaviside(t)/(a - b))
+    assert ILTS(s/(a + s)**3) == t*(-a*t + 2)*exp(-a*t)*Heaviside(t)/2
+    assert ILTS(1/(s*(a + s)**3)) == (
+        -a**2*t**2 - 2*a*t + 2*exp(a*t) - 2)*exp(-a*t)*Heaviside(t)/(2*a**3)
+    assert ILT(1/(s*(a + s)**n)) == (
+        Heaviside(t)*lowergamma(n, a*t)/(a**n*gamma(n)))
+    assert ILT((s-a)**(-b)) == t**(b - 1)*exp(a*t)*Heaviside(t)/gamma(b)
+    assert ILT((a + s)**(-2)) == t*exp(-a*t)*Heaviside(t)
+    assert ILT((a + s)**(-5)) == t**4*exp(-a*t)*Heaviside(t)/24
+    assert ILT(s**2/(s**2 + 1)) == -sin(t)*Heaviside(t) + DiracDelta(t)
+    assert ILT(1 - 1/(s**2 + 1)) == -sin(t)*Heaviside(t) + DiracDelta(t)
+    assert ILT(a/(a**2 + s**2)) == sin(a*t)*Heaviside(t)
+    assert ILT(s/(s**2 + a**2)) == cos(a*t)*Heaviside(t)
+    assert ILT(b/(b**2 + (a + s)**2)) == exp(-a*t)*sin(b*t)*Heaviside(t)
+    assert (ILT(b*s/(b**2 + (a + s)**2)) ==
+            b*(-a*exp(-a*t)*sin(b*t)/b + exp(-a*t)*cos(b*t))*Heaviside(t))
+    assert ILT(1/(s**2*(s**2 + 1))) == t*Heaviside(t) - sin(t)*Heaviside(t)
+    assert (ILTS(c*s/(d**2*(s+a)**2+b**2)) ==
+            c*(-a*d*sin(b*t/d) + b*cos(b*t/d))*exp(-a*t)*Heaviside(t)/(b*d**2))
+    assert ILTS((b*s**2 + d)/(a**2 + s**2)**2) == (
+        2*a**2*b*sin(a*t) + (a**2*b - d)*(a*t*cos(a*t) -
+                                          sin(a*t)))*Heaviside(t)/(2*a**3)
+    assert ILTS(b/(s**2-a**2)) == b*sinh(a*t)*Heaviside(t)/a
+    assert (ILT(b/(s**2-a**2)) ==
+            b*(exp(a*t)*Heaviside(t)/(2*a) - exp(-a*t)*Heaviside(t)/(2*a)))
+    assert ILTS(b*s/(s**2-a**2)) == b*cosh(a*t)*Heaviside(t)
+    assert (ILT(b/(s*(s+a))) ==
+            b*(Heaviside(t)/a - exp(-a*t)*Heaviside(t)/a))
+    # Issue #24424
+    assert (ILTS((s + 8)/((s + 2)*(s**2 + 2*s + 10))) ==
+            ((8*sin(3*t) - 9*cos(3*t))*exp(t) + 9)*exp(-2*t)*Heaviside(t)/15)
+    # Issue #8514; this is not important anymore, since this function
+    # is not solved by integration anymore
+    assert (ILT(1/(a*s**2+b*s+c)) ==
+            2*exp(-b*t/(2*a))*sin(t*sqrt(4*a*c - b**2)/(2*a)) *
+            Heaviside(t)/sqrt(4*a*c - b**2))
+
+    # Section 5.3: Irrational algebraic functions
+    assert (  # (1)
+        ILT(1/sqrt(s)/(b*s-a)) ==
+        exp(a*t/b)*Heaviside(t)*erf(sqrt(a)*sqrt(t)/sqrt(b))/(sqrt(a)*sqrt(b)))
+    assert (  # (2)
+        ILT(1/sqrt(k*s)/(c*s-a)/s) ==
+        (-2*c*sqrt(t)/(sqrt(pi)*a) +
+         c**(S(3)/2)*exp(a*t/c)*erf(sqrt(a)*sqrt(t)/sqrt(c))/a**(S(3)/2)) *
+        Heaviside(t)/(c*sqrt(k)))
+    assert (  # (4)
+        ILT(1/(sqrt(c*s)+a)) == (-a*exp(a**2*t/c)*erfc(a*sqrt(t)/sqrt(c))/c +
+                                 1/(sqrt(pi)*sqrt(c)*sqrt(t)))*Heaviside(t))
+    assert (  # (5)
+        ILT(a/s/(b*sqrt(s)+a)) ==
+        (-exp(a**2*t/b**2)*erfc(a*sqrt(t)/b) + 1)*Heaviside(t))
+    assert (  # (6)
+            ILT((a-b)*sqrt(s)/(sqrt(s)+sqrt(a))/(s-b)) ==
+            (sqrt(a)*sqrt(b)*exp(b*t)*erfc(sqrt(b)*sqrt(t)) +
+             a*exp(a*t)*erfc(sqrt(a)*sqrt(t)) - b*exp(b*t))*Heaviside(t))
+    assert (  # (7)
+            ILT(1/sqrt(s)/(sqrt(b*s)+a)) ==
+            exp(a**2*t/b)*Heaviside(t)*erfc(a*sqrt(t)/sqrt(b))/sqrt(b))
+    assert (  # (8)
+            ILT(a**2/(sqrt(s)+a)/s**(S(3)/2)) ==
+            (2*a*sqrt(t)/sqrt(pi) + exp(a**2*t)*erfc(a*sqrt(t)) - 1) *
+            Heaviside(t))
+    assert (  # (9)
+            ILT((a-b)*sqrt(b)/(s-b)/sqrt(s)/(sqrt(s)+sqrt(a))) ==
+            (sqrt(a)*exp(b*t)*erf(sqrt(b)*sqrt(t)) +
+             sqrt(b)*exp(a*t)*erfc(sqrt(a)*sqrt(t)) -
+             sqrt(b)*exp(b*t))*Heaviside(t))
+    assert (  # (10)
+            ILT(1/(sqrt(s)+sqrt(a))**2) ==
+            (-2*sqrt(a)*sqrt(t)/sqrt(pi) +
+             (-2*a*t + 1)*(erf(sqrt(a)*sqrt(t)) -
+                           1)*exp(a*t) + 1)*Heaviside(t))
+    assert (  # (11)
+            ILT(1/(sqrt(s)+sqrt(a))**2/s) ==
+            ((2*t - 1/a)*exp(a*t)*erfc(sqrt(a)*sqrt(t)) + 1/a -
+             2*sqrt(t)/(sqrt(pi)*sqrt(a)))*Heaviside(t))
+    assert (  # (12)
+            ILT(1/(sqrt(s)+a)**2/sqrt(s)) ==
+            (-2*a*t*exp(a**2*t)*erfc(a*sqrt(t)) +
+             2*sqrt(t)/sqrt(pi))*Heaviside(t))
+    assert (  # (13)
+            ILT(1/(sqrt(s)+a)**3) ==
+            (-a*t*(2*a**2*t + 3)*exp(a**2*t)*erfc(a*sqrt(t)) +
+             2*sqrt(t)*(a**2*t + 1)/sqrt(pi))*Heaviside(t))
+    x = (
+        - ILT(sqrt(s)/(sqrt(s)+a)**3) +
+        2*(sqrt(pi)*a**2*t*(-2*sqrt(pi)*erfc(a*sqrt(t)) +
+                            2*exp(-a**2*t)/(a*sqrt(t))) *
+           (-a**4*t**2 - 5*a**2*t/2 - S.Half) * exp(a**2*t)/2 +
+           sqrt(pi)*a*sqrt(t)*(a**2*t + 1)/2) *
+        Heaviside(t)/(pi*a**2*t)).simplify()
+    assert (  # (14)
+            x == 0)
+    x = (
+        - ILT(1/sqrt(s)/(sqrt(s)+a)**3) +
+        Heaviside(t)*(sqrt(t)*((2*a**2*t + 1) *
+                               (sqrt(pi)*a*sqrt(t)*exp(a**2*t) *
+                                erfc(a*sqrt(t)) - 1) + 1) /
+                      (sqrt(pi)*a))).simplify()
+    assert (  # (15)
+            x == 0)
+    assert (  # (16)
+            factor_terms(ILT(3/(sqrt(s)+a)**4)) ==
+            3*(-2*a**3*t**(S(5)/2)*(2*a**2*t + 5)/(3*sqrt(pi)) +
+               t*(4*a**4*t**2 + 12*a**2*t + 3)*exp(a**2*t) *
+               erfc(a*sqrt(t))/3)*Heaviside(t))
+    assert (  # (17)
+            ILT((sqrt(s)-a)/(s*(sqrt(s)+a))) ==
+            (2*exp(a**2*t)*erfc(a*sqrt(t))-1)*Heaviside(t))
+    assert (  # (18)
+            ILT((sqrt(s)-a)**2/(s*(sqrt(s)+a)**2)) == (
+                1 + 8*a**2*t*exp(a**2*t)*erfc(a*sqrt(t)) -
+                8/sqrt(pi)*a*sqrt(t))*Heaviside(t))
+    assert (  # (19)
+            ILT((sqrt(s)-a)**3/(s*(sqrt(s)+a)**3)) == Heaviside(t)*(
+                2*(8*a**4*t**2+8*a**2*t+1)*exp(a**2*t) *
+                erfc(a*sqrt(t))-8/sqrt(pi)*a*sqrt(t)*(2*a**2*t+1)-1))
+    assert (  # (22)
+            ILT(sqrt(s+a)/(s+b)) == Heaviside(t)*(
+                exp(-a*t)/sqrt(t)/sqrt(pi) +
+                sqrt(a-b)*exp(-b*t)*erf(sqrt(a-b)*sqrt(t))))
+    assert (  # (23)
+            ILT(1/sqrt(s+b)/(s+a)) == Heaviside(t)*(
+                1/sqrt(b-a)*exp(-a*t)*erf(sqrt(b-a)*sqrt(t))))
+    assert (  # (35)
+            ILT(1/sqrt(s**2+a**2)) == Heaviside(t)*(
+                besselj(0, a*t)))
+    assert (  # (44)
+            ILT(1/sqrt(s**2-a**2)) == Heaviside(t)*(
+                besseli(0, a*t)))
+
+    # Miscellaneous tests
+    # Can _inverse_laplace_time_shift deal with positive exponents?
+    assert (
+        - ILT((s**2*exp(2*s) + 4*exp(s) - 4)*exp(-2*s)/(s*(s**2 + 1))) +
+        cos(t)*Heaviside(t) + 4*cos(t - 2)*Heaviside(t - 2) -
+        4*cos(t - 1)*Heaviside(t - 1) - 4*Heaviside(t - 2) +
+        4*Heaviside(t - 1)).simplify() == 0
+
+
+@slow
+def test_inverse_laplace_transform_old():
+    from sympy.functions.special.delta_functions import DiracDelta
+    ILT = inverse_laplace_transform
+    a, b, c, d = symbols('a b c d', positive=True)
+    n, r = symbols('n, r', real=True)
+    t, z = symbols('t z')
+    f = Function('f')
+    F = Function('F')
+
+    def simp_hyp(expr):
+        return factor_terms(expand_mul(expr)).rewrite(sin)
+
+    L = ILT(F(s), s, t)
+    assert laplace_correspondence(L, {f: F}) == f(t)
+    assert ILT(exp(-a*s)/s, s, t) == Heaviside(-a + t)
+    assert ILT(exp(-a*s)/(b + s), s, t) == exp(-b*(-a + t))*Heaviside(-a + t)
+    assert (ILT((b + s)/(a**2 + (b + s)**2), s, t) ==
+            exp(-b*t)*cos(a*t)*Heaviside(t))
+    assert (ILT(exp(-a*s)/s**b, s, t) ==
+            (-a + t)**(b - 1)*Heaviside(-a + t)/gamma(b))
+    assert (ILT(exp(-a*s)/sqrt(s**2 + 1), s, t) ==
+            Heaviside(-a + t)*besselj(0, a - t))
+    assert ILT(1/(s*sqrt(s + 1)), s, t) == Heaviside(t)*erf(sqrt(t))
+    # TODO sinh/cosh shifted come out a mess. also delayed trig is a mess
+    # TODO should this simplify further?
+    assert (ILT(exp(-a*s)/s**b, s, t) ==
+            (t - a)**(b - 1)*Heaviside(t - a)/gamma(b))
+    assert (ILT(exp(-a*s)/sqrt(1 + s**2), s, t) ==
+            Heaviside(t - a)*besselj(0, a - t))  # note: besselj(0, x) is even
+    # XXX ILT turns these branch factor into trig functions ...
+    assert (
+        simplify(ILT(a**b*(s + sqrt(s**2 - a**2))**(-b)/sqrt(s**2 - a**2),
+                     s, t).rewrite(exp)) ==
+        Heaviside(t)*besseli(b, a*t))
+    assert (
+        ILT(a**b*(s + sqrt(s**2 + a**2))**(-b)/sqrt(s**2 + a**2),
+            s, t, simplify=True).rewrite(exp) ==
+        Heaviside(t)*besselj(b, a*t))
+    assert ILT(1/(s*sqrt(s + 1)), s, t) == Heaviside(t)*erf(sqrt(t))
+    # TODO can we make erf(t) work?
+    assert (ILT((s * eye(2) - Matrix([[1, 0], [0, 2]])).inv(), s, t) ==
+            Matrix([[exp(t)*Heaviside(t), 0], [0, exp(2*t)*Heaviside(t)]]))
+    # Test time_diff rule
+    assert (ILT(s**42*f(s), s, t) ==
+            Derivative(InverseLaplaceTransform(f(s), s, t, None), (t, 42)))
+    assert ILT(cos(s), s, t) == InverseLaplaceTransform(cos(s), s, t, None)
+    # Rules for testing different DiracDelta cases
+    assert (ILT(2*exp(3*s) - 5*exp(-7*s), s, t) ==
+            2*InverseLaplaceTransform(exp(3*s), s, t, None) -
+            5*DiracDelta(t - 7))
+    a = cos(sin(7)/2)
+    assert ILT(a*exp(-3*s), s, t) == a*DiracDelta(t - 3)
+    assert ILT(exp(2*s), s, t) == InverseLaplaceTransform(exp(2*s), s, t, None)
+    r = Symbol('r', real=True)
+    assert ILT(exp(r*s), s, t) == InverseLaplaceTransform(exp(r*s), s, t, None)
+    # Rules for testing whether Heaviside(t) is treated properly in diff rule
+    assert ILT(s**2/(a**2 + s**2), s, t) == (
+        -a*sin(a*t)*Heaviside(t) + DiracDelta(t))
+    assert ILT(s**2*(f(s) + 1/(a**2 + s**2)), s, t) == (
+        -a*sin(a*t)*Heaviside(t) + DiracDelta(t) +
+        Derivative(InverseLaplaceTransform(f(s), s, t, None), (t, 2)))
+    # Rules from the previous test_inverse_laplace_transform_delta_cond():
+    assert (ILT(exp(r*s), s, t, noconds=False) ==
+            (InverseLaplaceTransform(exp(r*s), s, t, None), True))
+    # inversion does not exist: verify it doesn't evaluate to DiracDelta
+    for z in (Symbol('z', extended_real=False),
+              Symbol('z', imaginary=True, zero=False)):
+        f = ILT(exp(z*s), s, t, noconds=False)
+        f = f[0] if isinstance(f, tuple) else f
+        assert f.func != DiracDelta
+
+
+@slow
+def test_expint():
+    x = Symbol('x')
+    a = Symbol('a')
+    u = Symbol('u', polar=True)
+
+    # TODO LT of Si, Shi, Chi is a mess ...
+    assert laplace_transform(Ci(x), x, s) == (-log(1 + s**2)/2/s, 0, True)
+    assert (laplace_transform(expint(a, x), x, s, simplify=True) ==
+            (lerchphi(s*exp_polar(I*pi), 1, a), 0, re(a) > S.Zero))
+    assert (laplace_transform(expint(1, x), x, s, simplify=True) ==
+            (log(s + 1)/s, 0, True))
+    assert (laplace_transform(expint(2, x), x, s, simplify=True) ==
+            ((s - log(s + 1))/s**2, 0, True))
+    assert (inverse_laplace_transform(-log(1 + s**2)/2/s, s, u).expand() ==
+            Heaviside(u)*Ci(u))
+    assert (
+        inverse_laplace_transform(log(s + 1)/s, s, x,
+                                  simplify=True).rewrite(expint) ==
+        Heaviside(x)*E1(x))
+    assert (
+        inverse_laplace_transform(
+            (s - log(s + 1))/s**2, s, x,
+            simplify=True).rewrite(expint).expand() ==
+        (expint(2, x)*Heaviside(x)).rewrite(Ei).rewrite(expint).expand())

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_lineintegrals.py

@@ -0,0 +1,13 @@
+from sympy.core.numbers import E
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry.curve import Curve
+from sympy.integrals.integrals import line_integrate
+
+s, t, x, y, z = symbols('s,t,x,y,z')
+
+
+def test_lineintegral():
+    c = Curve([E**t + 1, E**t - 1], (t, 0, log(2)))
+    assert line_integrate(x + y, c, [x, y]) == 3*sqrt(2)

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_risch.py

@@ -0,0 +1,763 @@
+"""Most of these tests come from the examples in Bronstein's book."""
+from sympy.core.function import (Function, Lambda, diff, expand_log)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Ne
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (atan, sin, tan)
+from sympy.polys.polytools import (Poly, cancel, factor)
+from sympy.integrals.risch import (gcdex_diophantine, frac_in, as_poly_1t,
+    derivation, splitfactor, splitfactor_sqf, canonical_representation,
+    hermite_reduce, polynomial_reduce, residue_reduce, residue_reduce_to_basic,
+    integrate_primitive, integrate_hyperexponential_polynomial,
+    integrate_hyperexponential, integrate_hypertangent_polynomial,
+    integrate_nonlinear_no_specials, integer_powers, DifferentialExtension,
+    risch_integrate, DecrementLevel, NonElementaryIntegral, recognize_log_derivative,
+    recognize_derivative, laurent_series)
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, t, nu, z, a, y
+t0, t1, t2 = symbols('t:3')
+i = Symbol('i')
+
+def test_gcdex_diophantine():
+    assert gcdex_diophantine(Poly(x**4 - 2*x**3 - 6*x**2 + 12*x + 15),
+    Poly(x**3 + x**2 - 4*x - 4), Poly(x**2 - 1)) == \
+        (Poly((-x**2 + 4*x - 3)/5), Poly((x**3 - 7*x**2 + 16*x - 10)/5))
+    assert gcdex_diophantine(Poly(x**3 + 6*x + 7), Poly(x**2 + 3*x + 2), Poly(x + 1)) == \
+        (Poly(1/13, x, domain='QQ'), Poly(-1/13*x + 3/13, x, domain='QQ'))
+
+
+def test_frac_in():
+    assert frac_in(Poly((x + 1)/x*t, t), x) == \
+        (Poly(t*x + t, x), Poly(x, x))
+    assert frac_in((x + 1)/x*t, x) == \
+        (Poly(t*x + t, x), Poly(x, x))
+    assert frac_in((Poly((x + 1)/x*t, t), Poly(t + 1, t)), x) == \
+        (Poly(t*x + t, x), Poly((1 + t)*x, x))
+    raises(ValueError, lambda: frac_in((x + 1)/log(x)*t, x))
+    assert frac_in(Poly((2 + 2*x + x*(1 + x))/(1 + x)**2, t), x, cancel=True) == \
+        (Poly(x + 2, x), Poly(x + 1, x))
+
+
+def test_as_poly_1t():
+    assert as_poly_1t(2/t + t, t, z) in [
+        Poly(t + 2*z, t, z), Poly(t + 2*z, z, t)]
+    assert as_poly_1t(2/t + 3/t**2, t, z) in [
+        Poly(2*z + 3*z**2, t, z), Poly(2*z + 3*z**2, z, t)]
+    assert as_poly_1t(2/((exp(2) + 1)*t), t, z) in [
+        Poly(2/(exp(2) + 1)*z, t, z), Poly(2/(exp(2) + 1)*z, z, t)]
+    assert as_poly_1t(2/((exp(2) + 1)*t) + t, t, z) in [
+        Poly(t + 2/(exp(2) + 1)*z, t, z), Poly(t + 2/(exp(2) + 1)*z, z, t)]
+    assert as_poly_1t(S.Zero, t, z) == Poly(0, t, z)
+
+
+def test_derivation():
+    p = Poly(4*x**4*t**5 + (-4*x**3 - 4*x**4)*t**4 + (-3*x**2 + 2*x**3)*t**3 +
+        (2*x + 7*x**2 + 2*x**3)*t**2 + (1 - 4*x - 4*x**2)*t - 1 + 2*x, t)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-t**2 - 3/(2*x)*t + 1/(2*x), t)]})
+    assert derivation(p, DE) == Poly(-20*x**4*t**6 + (2*x**3 + 16*x**4)*t**5 +
+        (21*x**2 + 12*x**3)*t**4 + (x*Rational(7, 2) - 25*x**2 - 12*x**3)*t**3 +
+        (-5 - x*Rational(15, 2) + 7*x**2)*t**2 - (3 - 8*x - 10*x**2 - 4*x**3)/(2*x)*t +
+        (1 - 4*x**2)/(2*x), t)
+    assert derivation(Poly(1, t), DE) == Poly(0, t)
+    assert derivation(Poly(t, t), DE) == DE.d
+    assert derivation(Poly(t**2 + 1/x*t + (1 - 2*x)/(4*x**2), t), DE) == \
+        Poly(-2*t**3 - 4/x*t**2 - (5 - 2*x)/(2*x**2)*t - (1 - 2*x)/(2*x**3), t, domain='ZZ(x)')
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t1), Poly(t, t)]})
+    assert derivation(Poly(x*t*t1, t), DE) == Poly(t*t1 + x*t*t1 + t, t)
+    assert derivation(Poly(x*t*t1, t), DE, coefficientD=True) == \
+        Poly((1 + t1)*t, t)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x)]})
+    assert derivation(Poly(x, x), DE) == Poly(1, x)
+    # Test basic option
+    assert derivation((x + 1)/(x - 1), DE, basic=True) == -2/(1 - 2*x + x**2)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]})
+    assert derivation((t + 1)/(t - 1), DE, basic=True) == -2*t/(1 - 2*t + t**2)
+    assert derivation(t + 1, DE, basic=True) == t
+
+
+def test_splitfactor():
+    p = Poly(4*x**4*t**5 + (-4*x**3 - 4*x**4)*t**4 + (-3*x**2 + 2*x**3)*t**3 +
+        (2*x + 7*x**2 + 2*x**3)*t**2 + (1 - 4*x - 4*x**2)*t - 1 + 2*x, t, field=True)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-t**2 - 3/(2*x)*t + 1/(2*x), t)]})
+    assert splitfactor(p, DE) == (Poly(4*x**4*t**3 + (-8*x**3 - 4*x**4)*t**2 +
+        (4*x**2 + 8*x**3)*t - 4*x**2, t, domain='ZZ(x)'),
+        Poly(t**2 + 1/x*t + (1 - 2*x)/(4*x**2), t, domain='ZZ(x)'))
+    assert splitfactor(Poly(x, t), DE) == (Poly(x, t), Poly(1, t))
+    r = Poly(-4*x**4*z**2 + 4*x**6*z**2 - z*x**3 - 4*x**5*z**3 + 4*x**3*z**3 + x**4 + z*x**5 - x**6, t)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)]})
+    assert splitfactor(r, DE, coefficientD=True) == \
+        (Poly(x*z - x**2 - z*x**3 + x**4, t), Poly(-x**2 + 4*x**2*z**2, t))
+    assert splitfactor_sqf(r, DE, coefficientD=True) == \
+        (((Poly(x*z - x**2 - z*x**3 + x**4, t), 1),), ((Poly(-x**2 + 4*x**2*z**2, t), 1),))
+    assert splitfactor(Poly(0, t), DE) == (Poly(0, t), Poly(1, t))
+    assert splitfactor_sqf(Poly(0, t), DE) == (((Poly(0, t), 1),), ())
+
+
+def test_canonical_representation():
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1 + t**2, t)]})
+    assert canonical_representation(Poly(x - t, t), Poly(t**2, t), DE) == \
+        (Poly(0, t, domain='ZZ[x]'), (Poly(0, t, domain='QQ[x]'),
+        Poly(1, t, domain='ZZ')), (Poly(-t + x, t, domain='QQ[x]'),
+        Poly(t**2, t)))
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t**2 + 1, t)]})
+    assert canonical_representation(Poly(t**5 + t**3 + x**2*t + 1, t),
+    Poly((t**2 + 1)**3, t), DE) == \
+        (Poly(0, t, domain='ZZ[x]'), (Poly(t**5 + t**3 + x**2*t + 1, t, domain='QQ[x]'),
+         Poly(t**6 + 3*t**4 + 3*t**2 + 1, t, domain='QQ')),
+        (Poly(0, t, domain='QQ[x]'), Poly(1, t, domain='QQ')))
+
+
+def test_hermite_reduce():
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t**2 + 1, t)]})
+
+    assert hermite_reduce(Poly(x - t, t), Poly(t**2, t), DE) == \
+        ((Poly(-x, t, domain='QQ[x]'), Poly(t, t, domain='QQ[x]')),
+         (Poly(0, t, domain='QQ[x]'), Poly(1, t, domain='QQ[x]')),
+         (Poly(-x, t, domain='QQ[x]'), Poly(1, t, domain='QQ[x]')))
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-t**2 - t/x - (1 - nu**2/x**2), t)]})
+
+    assert hermite_reduce(
+            Poly(x**2*t**5 + x*t**4 - nu**2*t**3 - x*(x**2 + 1)*t**2 - (x**2 - nu**2)*t - x**5/4, t),
+            Poly(x**2*t**4 + x**2*(x**2 + 2)*t**2 + x**2 + x**4 + x**6/4, t), DE) == \
+        ((Poly(-x**2 - 4, t, domain='ZZ(x,nu)'), Poly(4*t**2 + 2*x**2 + 4, t, domain='ZZ(x,nu)')),
+         (Poly((-2*nu**2 - x**4)*t - (2*x**3 + 2*x), t, domain='ZZ(x,nu)'),
+          Poly(2*x**2*t**2 + x**4 + 2*x**2, t, domain='ZZ(x,nu)')),
+         (Poly(x*t + 1, t, domain='ZZ(x,nu)'), Poly(x, t, domain='ZZ(x,nu)')))
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)]})
+
+    a = Poly((-2 + 3*x)*t**3 + (-1 + x)*t**2 + (-4*x + 2*x**2)*t + x**2, t)
+    d = Poly(x*t**6 - 4*x**2*t**5 + 6*x**3*t**4 - 4*x**4*t**3 + x**5*t**2, t)
+
+    assert hermite_reduce(a, d, DE) == \
+        ((Poly(3*t**2 + t + 3*x, t, domain='ZZ(x)'),
+          Poly(3*t**4 - 9*x*t**3 + 9*x**2*t**2 - 3*x**3*t, t, domain='ZZ(x)')),
+         (Poly(0, t, domain='ZZ(x)'), Poly(1, t, domain='ZZ(x)')),
+         (Poly(0, t, domain='ZZ(x)'), Poly(1, t, domain='ZZ(x)')))
+
+    assert hermite_reduce(
+            Poly(-t**2 + 2*t + 2, t, domain='ZZ(x)'),
+            Poly(-x*t**2 + 2*x*t - x, t, domain='ZZ(x)'), DE) == \
+        ((Poly(3, t, domain='ZZ(x)'), Poly(t - 1, t, domain='ZZ(x)')),
+         (Poly(0, t, domain='ZZ(x)'), Poly(1, t, domain='ZZ(x)')),
+         (Poly(1, t, domain='ZZ(x)'), Poly(x, t, domain='ZZ(x)')))
+
+    assert hermite_reduce(
+            Poly(-x**2*t**6 + (-1 - 2*x**3 + x**4)*t**3 + (-3 - 3*x**4)*t**2 -
+                2*x*t - x - 3*x**2, t, domain='ZZ(x)'),
+            Poly(x**4*t**6 - 2*x**2*t**3 + 1, t, domain='ZZ(x)'), DE) == \
+        ((Poly(x**3*t + x**4 + 1, t, domain='ZZ(x)'), Poly(x**3*t**3 - x, t, domain='ZZ(x)')),
+         (Poly(0, t, domain='ZZ(x)'), Poly(1, t, domain='ZZ(x)')),
+         (Poly(-1, t, domain='ZZ(x)'), Poly(x**2, t, domain='ZZ(x)')))
+
+    assert hermite_reduce(
+            Poly((-2 + 3*x)*t**3 + (-1 + x)*t**2 + (-4*x + 2*x**2)*t + x**2, t),
+            Poly(x*t**6 - 4*x**2*t**5 + 6*x**3*t**4 - 4*x**4*t**3 + x**5*t**2, t), DE) == \
+        ((Poly(3*t**2 + t + 3*x, t, domain='ZZ(x)'),
+          Poly(3*t**4 - 9*x*t**3 + 9*x**2*t**2 - 3*x**3*t, t, domain='ZZ(x)')),
+         (Poly(0, t, domain='ZZ(x)'), Poly(1, t, domain='ZZ(x)')),
+         (Poly(0, t, domain='ZZ(x)'), Poly(1, t, domain='ZZ(x)')))
+
+
+def test_polynomial_reduce():
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1 + t**2, t)]})
+    assert polynomial_reduce(Poly(1 + x*t + t**2, t), DE) == \
+        (Poly(t, t), Poly(x*t, t))
+    assert polynomial_reduce(Poly(0, t), DE) == \
+        (Poly(0, t), Poly(0, t))
+
+
+def test_laurent_series():
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1, t)]})
+    a = Poly(36, t)
+    d = Poly((t - 2)*(t**2 - 1)**2, t)
+    F = Poly(t**2 - 1, t)
+    n = 2
+    assert laurent_series(a, d, F, n, DE) == \
+        (Poly(-3*t**3 + 3*t**2 - 6*t - 8, t), Poly(t**5 + t**4 - 2*t**3 - 2*t**2 + t + 1, t),
+        [Poly(-3*t**3 - 6*t**2, t, domain='QQ'), Poly(2*t**6 + 6*t**5 - 8*t**3, t, domain='QQ')])
+
+
+def test_recognize_derivative():
+    DE = DifferentialExtension(extension={'D': [Poly(1, t)]})
+    a = Poly(36, t)
+    d = Poly((t - 2)*(t**2 - 1)**2, t)
+    assert recognize_derivative(a, d, DE) == False
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)]})
+    a = Poly(2, t)
+    d = Poly(t**2 - 1, t)
+    assert recognize_derivative(a, d, DE) == False
+    assert recognize_derivative(Poly(x*t, t), Poly(1, t), DE) == True
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t**2 + 1, t)]})
+    assert recognize_derivative(Poly(t, t), Poly(1, t), DE) == True
+
+
+def test_recognize_log_derivative():
+
+    a = Poly(2*x**2 + 4*x*t - 2*t - x**2*t, t)
+    d = Poly((2*x + t)*(t + x**2), t)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]})
+    assert recognize_log_derivative(a, d, DE, z) == True
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)]})
+    assert recognize_log_derivative(Poly(t + 1, t), Poly(t + x, t), DE) == True
+    assert recognize_log_derivative(Poly(2, t), Poly(t**2 - 1, t), DE) == True
+    DE = DifferentialExtension(extension={'D': [Poly(1, x)]})
+    assert recognize_log_derivative(Poly(1, x), Poly(x**2 - 2, x), DE) == False
+    assert recognize_log_derivative(Poly(1, x), Poly(x**2 + x, x), DE) == True
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t**2 + 1, t)]})
+    assert recognize_log_derivative(Poly(1, t), Poly(t**2 - 2, t), DE) == False
+    assert recognize_log_derivative(Poly(1, t), Poly(t**2 + t, t), DE) == False
+
+
+def test_residue_reduce():
+    a = Poly(2*t**2 - t - x**2, t)
+    d = Poly(t**3 - x**2*t, t)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)], 'Tfuncs': [log]})
+    assert residue_reduce(a, d, DE, z, invert=False) == \
+        ([(Poly(z**2 - Rational(1, 4), z, domain='ZZ(x)'),
+          Poly((1 + 3*x*z - 6*z**2 - 2*x**2 + 4*x**2*z**2)*t - x*z + x**2 +
+              2*x**2*z**2 - 2*z*x**3, t, domain='ZZ(z, x)'))], False)
+    assert residue_reduce(a, d, DE, z, invert=True) == \
+        ([(Poly(z**2 - Rational(1, 4), z, domain='ZZ(x)'), Poly(t + 2*x*z, t))], False)
+    assert residue_reduce(Poly(-2/x, t), Poly(t**2 - 1, t,), DE, z, invert=False) == \
+        ([(Poly(z**2 - 1, z, domain='QQ'), Poly(-2*z*t/x - 2/x, t, domain='ZZ(z,x)'))], True)
+    ans = residue_reduce(Poly(-2/x, t), Poly(t**2 - 1, t), DE, z, invert=True)
+    assert ans == ([(Poly(z**2 - 1, z, domain='QQ'), Poly(t + z, t))], True)
+    assert residue_reduce_to_basic(ans[0], DE, z) == -log(-1 + log(x)) + log(1 + log(x))
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-t**2 - t/x - (1 - nu**2/x**2), t)]})
+    # TODO: Skip or make faster
+    assert residue_reduce(Poly((-2*nu**2 - x**4)/(2*x**2)*t - (1 + x**2)/x, t),
+    Poly(t**2 + 1 + x**2/2, t), DE, z) == \
+        ([(Poly(z + S.Half, z, domain='QQ'), Poly(t**2 + 1 + x**2/2, t,
+            domain='ZZ(x,nu)'))], True)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1 + t**2, t)]})
+    assert residue_reduce(Poly(-2*x*t + 1 - x**2, t),
+    Poly(t**2 + 2*x*t + 1 + x**2, t), DE, z) == \
+        ([(Poly(z**2 + Rational(1, 4), z), Poly(t + x + 2*z, t))], True)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]})
+    assert residue_reduce(Poly(t, t), Poly(t + sqrt(2), t), DE, z) == \
+        ([(Poly(z - 1, z, domain='QQ'), Poly(t + sqrt(2), t))], True)
+
+
+def test_integrate_hyperexponential():
+    # TODO: Add tests for integrate_hyperexponential() from the book
+    a = Poly((1 + 2*t1 + t1**2 + 2*t1**3)*t**2 + (1 + t1**2)*t + 1 + t1**2, t)
+    d = Poly(1, t)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1 + t1**2, t1),
+        Poly(t*(1 + t1**2), t)], 'Tfuncs': [tan, Lambda(i, exp(tan(i)))]})
+    assert integrate_hyperexponential(a, d, DE) == \
+        (exp(2*tan(x))*tan(x) + exp(tan(x)), 1 + t1**2, True)
+    a = Poly((t1**3 + (x + 1)*t1**2 + t1 + x + 2)*t, t)
+    assert integrate_hyperexponential(a, d, DE) == \
+        ((x + tan(x))*exp(tan(x)), 0, True)
+
+    a = Poly(t, t)
+    d = Poly(1, t)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(2*x*t, t)],
+        'Tfuncs': [Lambda(i, exp(x**2))]})
+
+    assert integrate_hyperexponential(a, d, DE) == \
+        (0, NonElementaryIntegral(exp(x**2), x), False)
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)], 'Tfuncs': [exp]})
+    assert integrate_hyperexponential(a, d, DE) == (exp(x), 0, True)
+
+    a = Poly(25*t**6 - 10*t**5 + 7*t**4 - 8*t**3 + 13*t**2 + 2*t - 1, t)
+    d = Poly(25*t**6 + 35*t**4 + 11*t**2 + 1, t)
+    assert integrate_hyperexponential(a, d, DE) == \
+        (-(11 - 10*exp(x))/(5 + 25*exp(2*x)) + log(1 + exp(2*x)), -1, True)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t0, t0), Poly(t0*t, t)],
+        'Tfuncs': [exp, Lambda(i, exp(exp(i)))]})
+    assert integrate_hyperexponential(Poly(2*t0*t**2, t), Poly(1, t), DE) == (exp(2*exp(x)), 0, True)
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t0, t0), Poly(-t0*t, t)],
+        'Tfuncs': [exp, Lambda(i, exp(-exp(i)))]})
+    assert integrate_hyperexponential(Poly(-27*exp(9) - 162*t0*exp(9) +
+    27*x*t0*exp(9), t), Poly((36*exp(18) + x**2*exp(18) - 12*x*exp(18))*t, t), DE) == \
+        (27*exp(exp(x))/(-6*exp(9) + x*exp(9)), 0, True)
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)], 'Tfuncs': [exp]})
+    assert integrate_hyperexponential(Poly(x**2/2*t, t), Poly(1, t), DE) == \
+        ((2 - 2*x + x**2)*exp(x)/2, 0, True)
+    assert integrate_hyperexponential(Poly(1 + t, t), Poly(t, t), DE) == \
+        (-exp(-x), 1, True)  # x - exp(-x)
+    assert integrate_hyperexponential(Poly(x, t), Poly(t + 1, t), DE) == \
+        (0, NonElementaryIntegral(x/(1 + exp(x)), x), False)
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t0), Poly(2*x*t1, t1)],
+        'Tfuncs': [log, Lambda(i, exp(i**2))]})
+
+    elem, nonelem, b = integrate_hyperexponential(Poly((8*x**7 - 12*x**5 + 6*x**3 - x)*t1**4 +
+        (8*t0*x**7 - 8*t0*x**6 - 4*t0*x**5 + 2*t0*x**3 + 2*t0*x**2 - t0*x +
+        24*x**8 - 36*x**6 - 4*x**5 + 22*x**4 + 4*x**3 - 7*x**2 - x + 1)*t1**3
+        + (8*t0*x**8 - 4*t0*x**6 - 16*t0*x**5 - 2*t0*x**4 + 12*t0*x**3 +
+        t0*x**2 - 2*t0*x + 24*x**9 - 36*x**7 - 8*x**6 + 22*x**5 + 12*x**4 -
+        7*x**3 - 6*x**2 + x + 1)*t1**2 + (8*t0*x**8 - 8*t0*x**6 - 16*t0*x**5 +
+        6*t0*x**4 + 10*t0*x**3 - 2*t0*x**2 - t0*x + 8*x**10 - 12*x**8 - 4*x**7
+        + 2*x**6 + 12*x**5 + 3*x**4 - 9*x**3 - x**2 + 2*x)*t1 + 8*t0*x**7 -
+        12*t0*x**6 - 4*t0*x**5 + 8*t0*x**4 - t0*x**2 - 4*x**7 + 4*x**6 +
+        4*x**5 - 4*x**4 - x**3 + x**2, t1), Poly((8*x**7 - 12*x**5 + 6*x**3 -
+        x)*t1**4 + (24*x**8 + 8*x**7 - 36*x**6 - 12*x**5 + 18*x**4 + 6*x**3 -
+        3*x**2 - x)*t1**3 + (24*x**9 + 24*x**8 - 36*x**7 - 36*x**6 + 18*x**5 +
+        18*x**4 - 3*x**3 - 3*x**2)*t1**2 + (8*x**10 + 24*x**9 - 12*x**8 -
+        36*x**7 + 6*x**6 + 18*x**5 - x**4 - 3*x**3)*t1 + 8*x**10 - 12*x**8 +
+        6*x**6 - x**4, t1), DE)
+
+    assert factor(elem) == -((x - 1)*log(x)/((x + exp(x**2))*(2*x**2 - 1)))
+    assert (nonelem, b) == (NonElementaryIntegral(exp(x**2)/(exp(x**2) + 1), x), False)
+
+def test_integrate_hyperexponential_polynomial():
+    # Without proper cancellation within integrate_hyperexponential_polynomial(),
+    # this will take a long time to complete, and will return a complicated
+    # expression
+    p = Poly((-28*x**11*t0 - 6*x**8*t0 + 6*x**9*t0 - 15*x**8*t0**2 +
+        15*x**7*t0**2 + 84*x**10*t0**2 - 140*x**9*t0**3 - 20*x**6*t0**3 +
+        20*x**7*t0**3 - 15*x**6*t0**4 + 15*x**5*t0**4 + 140*x**8*t0**4 -
+        84*x**7*t0**5 - 6*x**4*t0**5 + 6*x**5*t0**5 + x**3*t0**6 - x**4*t0**6 +
+        28*x**6*t0**6 - 4*x**5*t0**7 + x**9 - x**10 + 4*x**12)/(-8*x**11*t0 +
+        28*x**10*t0**2 - 56*x**9*t0**3 + 70*x**8*t0**4 - 56*x**7*t0**5 +
+        28*x**6*t0**6 - 8*x**5*t0**7 + x**4*t0**8 + x**12)*t1**2 +
+        (-28*x**11*t0 - 12*x**8*t0 + 12*x**9*t0 - 30*x**8*t0**2 +
+        30*x**7*t0**2 + 84*x**10*t0**2 - 140*x**9*t0**3 - 40*x**6*t0**3 +
+        40*x**7*t0**3 - 30*x**6*t0**4 + 30*x**5*t0**4 + 140*x**8*t0**4 -
+        84*x**7*t0**5 - 12*x**4*t0**5 + 12*x**5*t0**5 - 2*x**4*t0**6 +
+        2*x**3*t0**6 + 28*x**6*t0**6 - 4*x**5*t0**7 + 2*x**9 - 2*x**10 +
+        4*x**12)/(-8*x**11*t0 + 28*x**10*t0**2 - 56*x**9*t0**3 +
+        70*x**8*t0**4 - 56*x**7*t0**5 + 28*x**6*t0**6 - 8*x**5*t0**7 +
+        x**4*t0**8 + x**12)*t1 + (-2*x**2*t0 + 2*x**3*t0 + x*t0**2 -
+        x**2*t0**2 + x**3 - x**4)/(-4*x**5*t0 + 6*x**4*t0**2 - 4*x**3*t0**3 +
+        x**2*t0**4 + x**6), t1, z, expand=False)
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t0), Poly(2*x*t1, t1)]})
+    assert integrate_hyperexponential_polynomial(p, DE, z) == (
+        Poly((x - t0)*t1**2 + (-2*t0 + 2*x)*t1, t1), Poly(-2*x*t0 + x**2 +
+        t0**2, t1), True)
+
+    DE = DifferentialExtension(extension={'D':[Poly(1, x), Poly(t0, t0)]})
+    assert integrate_hyperexponential_polynomial(Poly(0, t0), DE, z) == (
+        Poly(0, t0), Poly(1, t0), True)
+
+
+def test_integrate_hyperexponential_returns_piecewise():
+    a, b = symbols('a b')
+    DE = DifferentialExtension(a**x, x)
+    assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise(
+        (exp(x*log(a))/log(a), Ne(log(a), 0)), (x, True)), 0, True)
+    DE = DifferentialExtension(a**(b*x), x)
+    assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise(
+        (exp(b*x*log(a))/(b*log(a)), Ne(b*log(a), 0)), (x, True)), 0, True)
+    DE = DifferentialExtension(exp(a*x), x)
+    assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise(
+        (exp(a*x)/a, Ne(a, 0)), (x, True)), 0, True)
+    DE = DifferentialExtension(x*exp(a*x), x)
+    assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise(
+        ((a*x - 1)*exp(a*x)/a**2, Ne(a**2, 0)), (x**2/2, True)), 0, True)
+    DE = DifferentialExtension(x**2*exp(a*x), x)
+    assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise(
+        ((x**2*a**2 - 2*a*x + 2)*exp(a*x)/a**3, Ne(a**3, 0)),
+        (x**3/3, True)), 0, True)
+    DE = DifferentialExtension(x**y + z, y)
+    assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise(
+        (exp(log(x)*y)/log(x), Ne(log(x), 0)), (y, True)), z, True)
+    DE = DifferentialExtension(x**y + z + x**(2*y), y)
+    assert integrate_hyperexponential(DE.fa, DE.fd, DE) == (Piecewise(
+        ((exp(2*log(x)*y)*log(x) +
+            2*exp(log(x)*y)*log(x))/(2*log(x)**2), Ne(2*log(x)**2, 0)),
+            (2*y, True),
+        ), z, True)
+    # TODO: Add a test where two different parts of the extension use a
+    # Piecewise, like y**x + z**x.
+
+
+def test_issue_13947():
+    a, t, s = symbols('a t s')
+    assert risch_integrate(2**(-pi)/(2**t + 1), t) == \
+        2**(-pi)*t - 2**(-pi)*log(2**t + 1)/log(2)
+    assert risch_integrate(a**(t - s)/(a**t + 1), t) == \
+        exp(-s*log(a))*log(a**t + 1)/log(a)
+
+
+def test_integrate_primitive():
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t)],
+        'Tfuncs': [log]})
+    assert integrate_primitive(Poly(t, t), Poly(1, t), DE) == (x*log(x), -1, True)
+    assert integrate_primitive(Poly(x, t), Poly(t, t), DE) == (0, NonElementaryIntegral(x/log(x), x), False)
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t1), Poly(1/(x + 1), t2)],
+        'Tfuncs': [log, Lambda(i, log(i + 1))]})
+    assert integrate_primitive(Poly(t1, t2), Poly(t2, t2), DE) == \
+        (0, NonElementaryIntegral(log(x)/log(1 + x), x), False)
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t1), Poly(1/(x*t1), t2)],
+        'Tfuncs': [log, Lambda(i, log(log(i)))]})
+    assert integrate_primitive(Poly(t2, t2), Poly(t1, t2), DE) == \
+        (0, NonElementaryIntegral(log(log(x))/log(x), x), False)
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t0)],
+        'Tfuncs': [log]})
+    assert integrate_primitive(Poly(x**2*t0**3 + (3*x**2 + x)*t0**2 + (3*x**2
+    + 2*x)*t0 + x**2 + x, t0), Poly(x**2*t0**4 + 4*x**2*t0**3 + 6*x**2*t0**2 +
+    4*x**2*t0 + x**2, t0), DE) == \
+        (-1/(log(x) + 1), NonElementaryIntegral(1/(log(x) + 1), x), False)
+
+def test_integrate_hypertangent_polynomial():
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t**2 + 1, t)]})
+    assert integrate_hypertangent_polynomial(Poly(t**2 + x*t + 1, t), DE) == \
+        (Poly(t, t), Poly(x/2, t))
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(a*(t**2 + 1), t)]})
+    assert integrate_hypertangent_polynomial(Poly(t**5, t), DE) == \
+        (Poly(1/(4*a)*t**4 - 1/(2*a)*t**2, t), Poly(1/(2*a), t))
+
+
+def test_integrate_nonlinear_no_specials():
+    a, d, = Poly(x**2*t**5 + x*t**4 - nu**2*t**3 - x*(x**2 + 1)*t**2 - (x**2 -
+    nu**2)*t - x**5/4, t), Poly(x**2*t**4 + x**2*(x**2 + 2)*t**2 + x**2 + x**4 + x**6/4, t)
+    # f(x) == phi_nu(x), the logarithmic derivative of J_v, the Bessel function,
+    # which has no specials (see Chapter 5, note 4 of Bronstein's book).
+    f = Function('phi_nu')
+    DE = DifferentialExtension(extension={'D': [Poly(1, x),
+        Poly(-t**2 - t/x - (1 - nu**2/x**2), t)], 'Tfuncs': [f]})
+    assert integrate_nonlinear_no_specials(a, d, DE) == \
+        (-log(1 + f(x)**2 + x**2/2)/2 + (- 4 - x**2)/(4 + 2*x**2 + 4*f(x)**2), True)
+    assert integrate_nonlinear_no_specials(Poly(t, t), Poly(1, t), DE) == \
+        (0, False)
+
+
+def test_integer_powers():
+    assert integer_powers([x, x/2, x**2 + 1, x*Rational(2, 3)]) == [
+            (x/6, [(x, 6), (x/2, 3), (x*Rational(2, 3), 4)]),
+            (1 + x**2, [(1 + x**2, 1)])]
+
+
+def test_DifferentialExtension_exp():
+    assert DifferentialExtension(exp(x) + exp(x**2), x)._important_attrs == \
+        (Poly(t1 + t0, t1), Poly(1, t1), [Poly(1, x,), Poly(t0, t0),
+        Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)),
+        Lambda(i, exp(i**2))], [], [None, 'exp', 'exp'], [None, x, x**2])
+    assert DifferentialExtension(exp(x) + exp(2*x), x)._important_attrs == \
+        (Poly(t0**2 + t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0, t0)], [x, t0],
+        [Lambda(i, exp(i))], [], [None, 'exp'], [None, x])
+    assert DifferentialExtension(exp(x) + exp(x/2), x)._important_attrs == \
+        (Poly(t0**2 + t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)],
+        [x, t0], [Lambda(i, exp(i/2))], [], [None, 'exp'], [None, x/2])
+    assert DifferentialExtension(exp(x) + exp(x**2) + exp(x + x**2), x)._important_attrs == \
+        (Poly((1 + t0)*t1 + t0, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0),
+        Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)),
+        Lambda(i, exp(i**2))], [], [None, 'exp', 'exp'], [None, x, x**2])
+    assert DifferentialExtension(exp(x) + exp(x**2) + exp(x + x**2 + 1), x)._important_attrs == \
+        (Poly((1 + S.Exp1*t0)*t1 + t0, t1), Poly(1, t1), [Poly(1, x),
+        Poly(t0, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)),
+        Lambda(i, exp(i**2))], [], [None, 'exp', 'exp'], [None, x, x**2])
+    assert DifferentialExtension(exp(x) + exp(x**2) + exp(x/2 + x**2), x)._important_attrs == \
+        (Poly((t0 + 1)*t1 + t0**2, t1), Poly(1, t1), [Poly(1, x),
+        Poly(t0/2, t0), Poly(2*x*t1, t1)], [x, t0, t1],
+        [Lambda(i, exp(i/2)), Lambda(i, exp(i**2))],
+        [(exp(x/2), sqrt(exp(x)))], [None, 'exp', 'exp'], [None, x/2, x**2])
+    assert DifferentialExtension(exp(x) + exp(x**2) + exp(x/2 + x**2 + 3), x)._important_attrs == \
+        (Poly((t0*exp(3) + 1)*t1 + t0**2, t1), Poly(1, t1), [Poly(1, x),
+        Poly(t0/2, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i/2)),
+        Lambda(i, exp(i**2))], [(exp(x/2), sqrt(exp(x)))], [None, 'exp', 'exp'],
+        [None, x/2, x**2])
+    assert DifferentialExtension(sqrt(exp(x)), x)._important_attrs == \
+        (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0],
+        [Lambda(i, exp(i/2))], [(exp(x/2), sqrt(exp(x)))], [None, 'exp'], [None, x/2])
+
+    assert DifferentialExtension(exp(x/2), x)._important_attrs == \
+        (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0],
+        [Lambda(i, exp(i/2))], [], [None, 'exp'], [None, x/2])
+
+
+def test_DifferentialExtension_log():
+    assert DifferentialExtension(log(x)*log(x + 1)*log(2*x**2 + 2*x), x)._important_attrs == \
+        (Poly(t0*t1**2 + (t0*log(2) + t0**2)*t1, t1), Poly(1, t1),
+        [Poly(1, x), Poly(1/x, t0),
+        Poly(1/(x + 1), t1, expand=False)], [x, t0, t1],
+        [Lambda(i, log(i)), Lambda(i, log(i + 1))], [], [None, 'log', 'log'],
+        [None, x, x + 1])
+    assert DifferentialExtension(x**x*log(x), x)._important_attrs == \
+        (Poly(t0*t1, t1), Poly(1, t1), [Poly(1, x), Poly(1/x, t0),
+        Poly((1 + t0)*t1, t1)], [x, t0, t1], [Lambda(i, log(i)),
+        Lambda(i, exp(t0*i))], [(exp(x*log(x)), x**x)], [None, 'log', 'exp'],
+        [None, x, t0*x])
+
+
+def test_DifferentialExtension_symlog():
+    # See comment on test_risch_integrate below
+    assert DifferentialExtension(log(x**x), x)._important_attrs == \
+        (Poly(t0*x, t1), Poly(1, t1), [Poly(1, x), Poly(1/x, t0), Poly((t0 +
+            1)*t1, t1)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, exp(i*t0))],
+            [(exp(x*log(x)), x**x)], [None, 'log', 'exp'], [None, x, t0*x])
+    assert DifferentialExtension(log(x**y), x)._important_attrs == \
+        (Poly(y*t0, t0), Poly(1, t0), [Poly(1, x), Poly(1/x, t0)], [x, t0],
+        [Lambda(i, log(i))], [(y*log(x), log(x**y))], [None, 'log'],
+        [None, x])
+    assert DifferentialExtension(log(sqrt(x)), x)._important_attrs == \
+        (Poly(t0, t0), Poly(2, t0), [Poly(1, x), Poly(1/x, t0)], [x, t0],
+        [Lambda(i, log(i))], [(log(x)/2, log(sqrt(x)))], [None, 'log'],
+        [None, x])
+
+
+def test_DifferentialExtension_handle_first():
+    assert DifferentialExtension(exp(x)*log(x), x, handle_first='log')._important_attrs == \
+        (Poly(t0*t1, t1), Poly(1, t1), [Poly(1, x), Poly(1/x, t0),
+        Poly(t1, t1)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, exp(i))],
+        [], [None, 'log', 'exp'], [None, x, x])
+    assert DifferentialExtension(exp(x)*log(x), x, handle_first='exp')._important_attrs == \
+        (Poly(t0*t1, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0),
+        Poly(1/x, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, log(i))],
+        [], [None, 'exp', 'log'], [None, x, x])
+
+    # This one must have the log first, regardless of what we set it to
+    # (because the log is inside of the exponential: x**x == exp(x*log(x)))
+    assert DifferentialExtension(-x**x*log(x)**2 + x**x - x**x/x, x,
+    handle_first='exp')._important_attrs == \
+        DifferentialExtension(-x**x*log(x)**2 + x**x - x**x/x, x,
+        handle_first='log')._important_attrs == \
+        (Poly((-1 + x - x*t0**2)*t1, t1), Poly(x, t1),
+            [Poly(1, x), Poly(1/x, t0), Poly((1 + t0)*t1, t1)], [x, t0, t1],
+            [Lambda(i, log(i)), Lambda(i, exp(t0*i))], [(exp(x*log(x)), x**x)],
+            [None, 'log', 'exp'], [None, x, t0*x])
+
+
+def test_DifferentialExtension_all_attrs():
+    # Test 'unimportant' attributes
+    DE = DifferentialExtension(exp(x)*log(x), x, handle_first='exp')
+    assert DE.f == exp(x)*log(x)
+    assert DE.newf == t0*t1
+    assert DE.x == x
+    assert DE.cases == ['base', 'exp', 'primitive']
+    assert DE.case == 'primitive'
+
+    assert DE.level == -1
+    assert DE.t == t1 == DE.T[DE.level]
+    assert DE.d == Poly(1/x, t1) == DE.D[DE.level]
+    raises(ValueError, lambda: DE.increment_level())
+    DE.decrement_level()
+    assert DE.level == -2
+    assert DE.t == t0 == DE.T[DE.level]
+    assert DE.d == Poly(t0, t0) == DE.D[DE.level]
+    assert DE.case == 'exp'
+    DE.decrement_level()
+    assert DE.level == -3
+    assert DE.t == x == DE.T[DE.level] == DE.x
+    assert DE.d == Poly(1, x) == DE.D[DE.level]
+    assert DE.case == 'base'
+    raises(ValueError, lambda: DE.decrement_level())
+    DE.increment_level()
+    DE.increment_level()
+    assert DE.level == -1
+    assert DE.t == t1 == DE.T[DE.level]
+    assert DE.d == Poly(1/x, t1) == DE.D[DE.level]
+    assert DE.case == 'primitive'
+
+    # Test methods
+    assert DE.indices('log') == [2]
+    assert DE.indices('exp') == [1]
+
+
+def test_DifferentialExtension_extension_flag():
+    raises(ValueError, lambda: DifferentialExtension(extension={'T': [x, t]}))
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]})
+    assert DE._important_attrs == (None, None, [Poly(1, x), Poly(t, t)], [x, t],
+        None, None, None, None)
+    assert DE.d == Poly(t, t)
+    assert DE.t == t
+    assert DE.level == -1
+    assert DE.cases == ['base', 'exp']
+    assert DE.x == x
+    assert DE.case == 'exp'
+
+    DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)],
+        'exts': [None, 'exp'], 'extargs': [None, x]})
+    assert DE._important_attrs == (None, None, [Poly(1, x), Poly(t, t)], [x, t],
+        None, None, [None, 'exp'], [None, x])
+    raises(ValueError, lambda: DifferentialExtension())
+
+
+def test_DifferentialExtension_misc():
+    # Odd ends
+    assert DifferentialExtension(sin(y)*exp(x), x)._important_attrs == \
+        (Poly(sin(y)*t0, t0, domain='ZZ[sin(y)]'), Poly(1, t0, domain='ZZ'),
+        [Poly(1, x, domain='ZZ'), Poly(t0, t0, domain='ZZ')], [x, t0],
+        [Lambda(i, exp(i))], [], [None, 'exp'], [None, x])
+    raises(NotImplementedError, lambda: DifferentialExtension(sin(x), x))
+    assert DifferentialExtension(10**x, x)._important_attrs == \
+        (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(log(10)*t0, t0)], [x, t0],
+        [Lambda(i, exp(i*log(10)))], [(exp(x*log(10)), 10**x)], [None, 'exp'],
+        [None, x*log(10)])
+    assert DifferentialExtension(log(x) + log(x**2), x)._important_attrs in [
+        (Poly(3*t0, t0), Poly(2, t0), [Poly(1, x), Poly(2/x, t0)], [x, t0],
+        [Lambda(i, log(i**2))], [], [None, ], [], [1], [x**2]),
+        (Poly(3*t0, t0), Poly(1, t0), [Poly(1, x), Poly(1/x, t0)], [x, t0],
+        [Lambda(i, log(i))], [], [None, 'log'], [None, x])]
+    assert DifferentialExtension(S.Zero, x)._important_attrs == \
+        (Poly(0, x), Poly(1, x), [Poly(1, x)], [x], [], [], [None], [None])
+    assert DifferentialExtension(tan(atan(x).rewrite(log)), x)._important_attrs == \
+        (Poly(x, x), Poly(1, x), [Poly(1, x)], [x], [], [], [None], [None])
+
+
+def test_DifferentialExtension_Rothstein():
+    # Rothstein's integral
+    f = (2581284541*exp(x) + 1757211400)/(39916800*exp(3*x) +
+    119750400*exp(x)**2 + 119750400*exp(x) + 39916800)*exp(1/(exp(x) + 1) - 10*x)
+    assert DifferentialExtension(f, x)._important_attrs == \
+        (Poly((1757211400 + 2581284541*t0)*t1, t1), Poly(39916800 +
+        119750400*t0 + 119750400*t0**2 + 39916800*t0**3, t1),
+        [Poly(1, x), Poly(t0, t0), Poly(-(10 + 21*t0 + 10*t0**2)/(1 + 2*t0 +
+        t0**2)*t1, t1, domain='ZZ(t0)')], [x, t0, t1],
+        [Lambda(i, exp(i)), Lambda(i, exp(1/(t0 + 1) - 10*i))], [],
+        [None, 'exp', 'exp'], [None, x, 1/(t0 + 1) - 10*x])
+
+
+class _TestingException(Exception):
+    """Dummy Exception class for testing."""
+    pass
+
+
+def test_DecrementLevel():
+    DE = DifferentialExtension(x*log(exp(x) + 1), x)
+    assert DE.level == -1
+    assert DE.t == t1
+    assert DE.d == Poly(t0/(t0 + 1), t1)
+    assert DE.case == 'primitive'
+
+    with DecrementLevel(DE):
+        assert DE.level == -2
+        assert DE.t == t0
+        assert DE.d == Poly(t0, t0)
+        assert DE.case == 'exp'
+
+        with DecrementLevel(DE):
+            assert DE.level == -3
+            assert DE.t == x
+            assert DE.d == Poly(1, x)
+            assert DE.case == 'base'
+
+        assert DE.level == -2
+        assert DE.t == t0
+        assert DE.d == Poly(t0, t0)
+        assert DE.case == 'exp'
+
+    assert DE.level == -1
+    assert DE.t == t1
+    assert DE.d == Poly(t0/(t0 + 1), t1)
+    assert DE.case == 'primitive'
+
+    # Test that __exit__ is called after an exception correctly
+    try:
+        with DecrementLevel(DE):
+            raise _TestingException
+    except _TestingException:
+        pass
+    else:
+        raise AssertionError("Did not raise.")
+
+    assert DE.level == -1
+    assert DE.t == t1
+    assert DE.d == Poly(t0/(t0 + 1), t1)
+    assert DE.case == 'primitive'
+
+
+def test_risch_integrate():
+    assert risch_integrate(t0*exp(x), x) == t0*exp(x)
+    assert risch_integrate(sin(x), x, rewrite_complex=True) == -exp(I*x)/2 - exp(-I*x)/2
+
+    # From my GSoC writeup
+    assert risch_integrate((1 + 2*x**2 + x**4 + 2*x**3*exp(2*x**2))/
+    (x**4*exp(x**2) + 2*x**2*exp(x**2) + exp(x**2)), x) == \
+        NonElementaryIntegral(exp(-x**2), x) + exp(x**2)/(1 + x**2)
+
+
+    assert risch_integrate(0, x) == 0
+
+    # also tests prde_cancel()
+    e1 = log(x/exp(x) + 1)
+    ans1 = risch_integrate(e1, x)
+    assert ans1 == (x*log(x*exp(-x) + 1) + NonElementaryIntegral((x**2 - x)/(x + exp(x)), x))
+    assert cancel(diff(ans1, x) - e1) == 0
+
+    # also tests issue #10798
+    e2 = (log(-1/y)/2 - log(1/y)/2)/y - (log(1 - 1/y)/2 - log(1 + 1/y)/2)/y
+    ans2 = risch_integrate(e2, y)
+    assert ans2 == log(1/y)*log(1 - 1/y)/2 - log(1/y)*log(1 + 1/y)/2 + \
+            NonElementaryIntegral((I*pi*y**2 - 2*y*log(1/y) - I*pi)/(2*y**3 - 2*y), y)
+    assert expand_log(cancel(diff(ans2, y) - e2), force=True) == 0
+
+    # These are tested here in addition to in test_DifferentialExtension above
+    # (symlogs) to test that backsubs works correctly.  The integrals should be
+    # written in terms of the original logarithms in the integrands.
+
+    # XXX: Unfortunately, making backsubs work on this one is a little
+    # trickier, because x**x is converted to exp(x*log(x)), and so log(x**x)
+    # is converted to x*log(x). (x**2*log(x)).subs(x*log(x), log(x**x)) is
+    # smart enough, the issue is that these splits happen at different places
+    # in the algorithm.  Maybe a heuristic is in order
+    assert risch_integrate(log(x**x), x) == x**2*log(x)/2 - x**2/4
+
+    assert risch_integrate(log(x**y), x) == x*log(x**y) - x*y
+    assert risch_integrate(log(sqrt(x)), x) == x*log(sqrt(x)) - x/2
+
+
+def test_risch_integrate_float():
+    assert risch_integrate((-60*exp(x) - 19.2*exp(4*x))*exp(4*x), x) == -2.4*exp(8*x) - 12.0*exp(5*x)
+
+
+def test_NonElementaryIntegral():
+    assert isinstance(risch_integrate(exp(x**2), x), NonElementaryIntegral)
+    assert isinstance(risch_integrate(x**x*log(x), x), NonElementaryIntegral)
+    # Make sure methods of Integral still give back a NonElementaryIntegral
+    assert isinstance(NonElementaryIntegral(x**x*t0, x).subs(t0, log(x)), NonElementaryIntegral)
+
+
+def test_xtothex():
+    a = risch_integrate(x**x, x)
+    assert a == NonElementaryIntegral(x**x, x)
+    assert isinstance(a, NonElementaryIntegral)
+
+
+def test_DifferentialExtension_equality():
+    DE1 = DE2 = DifferentialExtension(log(x), x)
+    assert DE1 == DE2
+
+
+def test_DifferentialExtension_printing():
+    DE = DifferentialExtension(exp(2*x**2) + log(exp(x**2) + 1), x)
+    assert repr(DE) == ("DifferentialExtension(dict([('f', exp(2*x**2) + log(exp(x**2) + 1)), "
+        "('x', x), ('T', [x, t0, t1]), ('D', [Poly(1, x, domain='ZZ'), Poly(2*x*t0, t0, domain='ZZ[x]'), "
+        "Poly(2*t0*x/(t0 + 1), t1, domain='ZZ(x,t0)')]), ('fa', Poly(t1 + t0**2, t1, domain='ZZ[t0]')), "
+        "('fd', Poly(1, t1, domain='ZZ')), ('Tfuncs', [Lambda(i, exp(i**2)), Lambda(i, log(t0 + 1))]), "
+        "('backsubs', []), ('exts', [None, 'exp', 'log']), ('extargs', [None, x**2, t0 + 1]), "
+        "('cases', ['base', 'exp', 'primitive']), ('case', 'primitive'), ('t', t1), "
+        "('d', Poly(2*t0*x/(t0 + 1), t1, domain='ZZ(x,t0)')), ('newf', t0**2 + t1), ('level', -1), "
+        "('dummy', False)]))")
+
+    assert str(DE) == ("DifferentialExtension({fa=Poly(t1 + t0**2, t1, domain='ZZ[t0]'), "
+        "fd=Poly(1, t1, domain='ZZ'), D=[Poly(1, x, domain='ZZ'), Poly(2*x*t0, t0, domain='ZZ[x]'), "
+        "Poly(2*t0*x/(t0 + 1), t1, domain='ZZ(x,t0)')]})")
+
+
+def test_issue_23948():
+    f = (
+        ( (-2*x**5 + 28*x**4 - 144*x**3 + 324*x**2 - 270*x)*log(x)**2
+         +(-4*x**6 + 56*x**5 - 288*x**4 + 648*x**3 - 540*x**2)*log(x)
+         +(2*x**5 - 28*x**4 + 144*x**3 - 324*x**2 + 270*x)*exp(x)
+         +(2*x**5 - 28*x**4 + 144*x**3 - 324*x**2 + 270*x)*log(5)
+         -2*x**7 + 26*x**6 - 116*x**5 + 180*x**4 + 54*x**3 - 270*x**2
+        )*log(-log(x)**2 - 2*x*log(x) + exp(x) + log(5) - x**2 - x)**2
+       +( (4*x**5 - 44*x**4 + 168*x**3 - 216*x**2 - 108*x + 324)*log(x)
+         +(-2*x**5 + 24*x**4 - 108*x**3 + 216*x**2 - 162*x)*exp(x)
+         +4*x**6 - 42*x**5 + 144*x**4 - 108*x**3 - 324*x**2 + 486*x
+        )*log(-log(x)**2 - 2*x*log(x) + exp(x) + log(5) - x**2 - x)
+    )/(x*exp(x)**2*log(x)**2 + 2*x**2*exp(x)**2*log(x) - x*exp(x)**3
+       +(-x*log(5) + x**3 + x**2)*exp(x)**2)
+
+    F = ((x**4 - 12*x**3 + 54*x**2 - 108*x + 81)*exp(-2*x)
+        *log(-x**2 - 2*x*log(x) - x + exp(x) - log(x)**2 + log(5))**2)
+
+    assert risch_integrate(f, x) == F

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_singularityfunctions.py

@@ -0,0 +1,22 @@
+from sympy.integrals.singularityfunctions import singularityintegrate
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.functions.special.singularity_functions import SingularityFunction
+
+x, a, n, y = symbols('x a n y')
+f = Function('f')
+
+
+def test_singularityintegrate():
+    assert singularityintegrate(x, x) is None
+    assert singularityintegrate(x + SingularityFunction(x, 9, 1), x) is None
+
+    assert 4*singularityintegrate(SingularityFunction(x, a, 3), x) == 4*SingularityFunction(x, a, 4)/4
+    assert singularityintegrate(5*SingularityFunction(x, 5, -2), x) == 5*SingularityFunction(x, 5, -1)
+    assert singularityintegrate(6*SingularityFunction(x, 5, -1), x) == 6*SingularityFunction(x, 5, 0)
+    assert singularityintegrate(x*SingularityFunction(x, 0, -1), x) == 0
+    assert singularityintegrate((x - 5)*SingularityFunction(x, 5, -1), x) == 0
+    assert singularityintegrate(SingularityFunction(x, 0, -1) * f(x), x) == f(0) * SingularityFunction(x, 0, 0)
+    assert singularityintegrate(SingularityFunction(x, 1, -1) * f(x), x) == f(1) * SingularityFunction(x, 1, 0)
+    assert singularityintegrate(y*SingularityFunction(x, 0, -1)**2, x) == \
+        y*SingularityFunction(0, 0, -1)*SingularityFunction(x, 0, 0)

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_transforms.py

@@ -0,0 +1,636 @@
+from sympy.integrals.transforms import (
+    mellin_transform, inverse_mellin_transform,
+    fourier_transform, inverse_fourier_transform,
+    sine_transform, inverse_sine_transform,
+    cosine_transform, inverse_cosine_transform,
+    hankel_transform, inverse_hankel_transform,
+    FourierTransform, SineTransform, CosineTransform, InverseFourierTransform,
+    InverseSineTransform, InverseCosineTransform, IntegralTransformError)
+from sympy.integrals.laplace import (
+    laplace_transform, inverse_laplace_transform)
+from sympy.core.function import Function, expand_mul
+from sympy.core import EulerGamma
+from sympy.core.numbers import I, Rational, oo, pi
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import re, unpolarify
+from sympy.functions.elementary.exponential import exp, exp_polar, log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import atan, cos, sin, tan
+from sympy.functions.special.bessel import besseli, besselj, besselk, bessely
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.functions.special.error_functions import erf, expint
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import meijerg
+from sympy.simplify.gammasimp import gammasimp
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.simplify.trigsimp import trigsimp
+from sympy.testing.pytest import XFAIL, slow, skip, raises
+from sympy.abc import x, s, a, b, c, d
+
+
+nu, beta, rho = symbols('nu beta rho')
+
+
+def test_undefined_function():
+    from sympy.integrals.transforms import MellinTransform
+    f = Function('f')
+    assert mellin_transform(f(x), x, s) == MellinTransform(f(x), x, s)
+    assert mellin_transform(f(x) + exp(-x), x, s) == \
+        (MellinTransform(f(x), x, s) + gamma(s + 1)/s, (0, oo), True)
+
+
+def test_free_symbols():
+    f = Function('f')
+    assert mellin_transform(f(x), x, s).free_symbols == {s}
+    assert mellin_transform(f(x)*a, x, s).free_symbols == {s, a}
+
+
+def test_as_integral():
+    from sympy.integrals.integrals import Integral
+    f = Function('f')
+    assert mellin_transform(f(x), x, s).rewrite('Integral') == \
+        Integral(x**(s - 1)*f(x), (x, 0, oo))
+    assert fourier_transform(f(x), x, s).rewrite('Integral') == \
+        Integral(f(x)*exp(-2*I*pi*s*x), (x, -oo, oo))
+    assert laplace_transform(f(x), x, s, noconds=True).rewrite('Integral') == \
+        Integral(f(x)*exp(-s*x), (x, 0, oo))
+    assert str(2*pi*I*inverse_mellin_transform(f(s), s, x, (a, b)).rewrite('Integral')) \
+        == "Integral(f(s)/x**s, (s, _c - oo*I, _c + oo*I))"
+    assert str(2*pi*I*inverse_laplace_transform(f(s), s, x).rewrite('Integral')) == \
+        "Integral(f(s)*exp(s*x), (s, _c - oo*I, _c + oo*I))"
+    assert inverse_fourier_transform(f(s), s, x).rewrite('Integral') == \
+        Integral(f(s)*exp(2*I*pi*s*x), (s, -oo, oo))
+
+# NOTE this is stuck in risch because meijerint cannot handle it
+
+
+@slow
+@XFAIL
+def test_mellin_transform_fail():
+    skip("Risch takes forever.")
+
+    MT = mellin_transform
+
+    bpos = symbols('b', positive=True)
+    # bneg = symbols('b', negative=True)
+
+    expr = (sqrt(x + b**2) + b)**a/sqrt(x + b**2)
+    # TODO does not work with bneg, argument wrong. Needs changes to matching.
+    assert MT(expr.subs(b, -bpos), x, s) == \
+        ((-1)**(a + 1)*2**(a + 2*s)*bpos**(a + 2*s - 1)*gamma(a + s)
+         *gamma(1 - a - 2*s)/gamma(1 - s),
+            (-re(a), -re(a)/2 + S.Half), True)
+
+    expr = (sqrt(x + b**2) + b)**a
+    assert MT(expr.subs(b, -bpos), x, s) == \
+        (
+            2**(a + 2*s)*a*bpos**(a + 2*s)*gamma(-a - 2*
+                   s)*gamma(a + s)/gamma(-s + 1),
+            (-re(a), -re(a)/2), True)
+
+    # Test exponent 1:
+    assert MT(expr.subs({b: -bpos, a: 1}), x, s) == \
+        (-bpos**(2*s + 1)*gamma(s)*gamma(-s - S.Half)/(2*sqrt(pi)),
+            (-1, Rational(-1, 2)), True)
+
+
+def test_mellin_transform():
+    from sympy.functions.elementary.miscellaneous import (Max, Min)
+    MT = mellin_transform
+
+    bpos = symbols('b', positive=True)
+
+    # 8.4.2
+    assert MT(x**nu*Heaviside(x - 1), x, s) == \
+        (-1/(nu + s), (-oo, -re(nu)), True)
+    assert MT(x**nu*Heaviside(1 - x), x, s) == \
+        (1/(nu + s), (-re(nu), oo), True)
+
+    assert MT((1 - x)**(beta - 1)*Heaviside(1 - x), x, s) == \
+        (gamma(beta)*gamma(s)/gamma(beta + s), (0, oo), re(beta) > 0)
+    assert MT((x - 1)**(beta - 1)*Heaviside(x - 1), x, s) == \
+        (gamma(beta)*gamma(1 - beta - s)/gamma(1 - s),
+            (-oo, 1 - re(beta)), re(beta) > 0)
+
+    assert MT((1 + x)**(-rho), x, s) == \
+        (gamma(s)*gamma(rho - s)/gamma(rho), (0, re(rho)), True)
+
+    assert MT(abs(1 - x)**(-rho), x, s) == (
+        2*sin(pi*rho/2)*gamma(1 - rho)*
+        cos(pi*(s - rho/2))*gamma(s)*gamma(rho-s)/pi,
+        (0, re(rho)), re(rho) < 1)
+    mt = MT((1 - x)**(beta - 1)*Heaviside(1 - x)
+            + a*(x - 1)**(beta - 1)*Heaviside(x - 1), x, s)
+    assert mt[1], mt[2] == ((0, -re(beta) + 1), re(beta) > 0)
+
+    assert MT((x**a - b**a)/(x - b), x, s)[0] == \
+        pi*b**(a + s - 1)*sin(pi*a)/(sin(pi*s)*sin(pi*(a + s)))
+    assert MT((x**a - bpos**a)/(x - bpos), x, s) == \
+        (pi*bpos**(a + s - 1)*sin(pi*a)/(sin(pi*s)*sin(pi*(a + s))),
+            (Max(0, -re(a)), Min(1, 1 - re(a))), True)
+
+    expr = (sqrt(x + b**2) + b)**a
+    assert MT(expr.subs(b, bpos), x, s) == \
+        (-a*(2*bpos)**(a + 2*s)*gamma(s)*gamma(-a - 2*s)/gamma(-a - s + 1),
+            (0, -re(a)/2), True)
+
+    expr = (sqrt(x + b**2) + b)**a/sqrt(x + b**2)
+    assert MT(expr.subs(b, bpos), x, s) == \
+        (2**(a + 2*s)*bpos**(a + 2*s - 1)*gamma(s)
+                                         *gamma(1 - a - 2*s)/gamma(1 - a - s),
+            (0, -re(a)/2 + S.Half), True)
+
+    # 8.4.2
+    assert MT(exp(-x), x, s) == (gamma(s), (0, oo), True)
+    assert MT(exp(-1/x), x, s) == (gamma(-s), (-oo, 0), True)
+
+    # 8.4.5
+    assert MT(log(x)**4*Heaviside(1 - x), x, s) == (24/s**5, (0, oo), True)
+    assert MT(log(x)**3*Heaviside(x - 1), x, s) == (6/s**4, (-oo, 0), True)
+    assert MT(log(x + 1), x, s) == (pi/(s*sin(pi*s)), (-1, 0), True)
+    assert MT(log(1/x + 1), x, s) == (pi/(s*sin(pi*s)), (0, 1), True)
+    assert MT(log(abs(1 - x)), x, s) == (pi/(s*tan(pi*s)), (-1, 0), True)
+    assert MT(log(abs(1 - 1/x)), x, s) == (pi/(s*tan(pi*s)), (0, 1), True)
+
+    # 8.4.14
+    assert MT(erf(sqrt(x)), x, s) == \
+        (-gamma(s + S.Half)/(sqrt(pi)*s), (Rational(-1, 2), 0), True)
+
+
+def test_mellin_transform2():
+    MT = mellin_transform
+    # TODO we cannot currently do these (needs summation of 3F2(-1))
+    #      this also implies that they cannot be written as a single g-function
+    #      (although this is possible)
+    mt = MT(log(x)/(x + 1), x, s)
+    assert mt[1:] == ((0, 1), True)
+    assert not hyperexpand(mt[0], allow_hyper=True).has(meijerg)
+    mt = MT(log(x)**2/(x + 1), x, s)
+    assert mt[1:] == ((0, 1), True)
+    assert not hyperexpand(mt[0], allow_hyper=True).has(meijerg)
+    mt = MT(log(x)/(x + 1)**2, x, s)
+    assert mt[1:] == ((0, 2), True)
+    assert not hyperexpand(mt[0], allow_hyper=True).has(meijerg)
+
+
+@slow
+def test_mellin_transform_bessel():
+    from sympy.functions.elementary.miscellaneous import Max
+    MT = mellin_transform
+
+    # 8.4.19
+    assert MT(besselj(a, 2*sqrt(x)), x, s) == \
+        (gamma(a/2 + s)/gamma(a/2 - s + 1), (-re(a)/2, Rational(3, 4)), True)
+    assert MT(sin(sqrt(x))*besselj(a, sqrt(x)), x, s) == \
+        (2**a*gamma(-2*s + S.Half)*gamma(a/2 + s + S.Half)/(
+        gamma(-a/2 - s + 1)*gamma(a - 2*s + 1)), (
+        -re(a)/2 - S.Half, Rational(1, 4)), True)
+    assert MT(cos(sqrt(x))*besselj(a, sqrt(x)), x, s) == \
+        (2**a*gamma(a/2 + s)*gamma(-2*s + S.Half)/(
+        gamma(-a/2 - s + S.Half)*gamma(a - 2*s + 1)), (
+        -re(a)/2, Rational(1, 4)), True)
+    assert MT(besselj(a, sqrt(x))**2, x, s) == \
+        (gamma(a + s)*gamma(S.Half - s)
+         / (sqrt(pi)*gamma(1 - s)*gamma(1 + a - s)),
+            (-re(a), S.Half), True)
+    assert MT(besselj(a, sqrt(x))*besselj(-a, sqrt(x)), x, s) == \
+        (gamma(s)*gamma(S.Half - s)
+         / (sqrt(pi)*gamma(1 - a - s)*gamma(1 + a - s)),
+            (0, S.Half), True)
+    # NOTE: prudnikov gives the strip below as (1/2 - re(a), 1). As far as
+    #       I can see this is wrong (since besselj(z) ~ 1/sqrt(z) for z large)
+    assert MT(besselj(a - 1, sqrt(x))*besselj(a, sqrt(x)), x, s) == \
+        (gamma(1 - s)*gamma(a + s - S.Half)
+         / (sqrt(pi)*gamma(Rational(3, 2) - s)*gamma(a - s + S.Half)),
+            (S.Half - re(a), S.Half), True)
+    assert MT(besselj(a, sqrt(x))*besselj(b, sqrt(x)), x, s) == \
+        (4**s*gamma(1 - 2*s)*gamma((a + b)/2 + s)
+         / (gamma(1 - s + (b - a)/2)*gamma(1 - s + (a - b)/2)
+            *gamma( 1 - s + (a + b)/2)),
+            (-(re(a) + re(b))/2, S.Half), True)
+    assert MT(besselj(a, sqrt(x))**2 + besselj(-a, sqrt(x))**2, x, s)[1:] == \
+        ((Max(re(a), -re(a)), S.Half), True)
+
+    # Section 8.4.20
+    assert MT(bessely(a, 2*sqrt(x)), x, s) == \
+        (-cos(pi*(a/2 - s))*gamma(s - a/2)*gamma(s + a/2)/pi,
+            (Max(-re(a)/2, re(a)/2), Rational(3, 4)), True)
+    assert MT(sin(sqrt(x))*bessely(a, sqrt(x)), x, s) == \
+        (-4**s*sin(pi*(a/2 - s))*gamma(S.Half - 2*s)
+         * gamma((1 - a)/2 + s)*gamma((1 + a)/2 + s)
+         / (sqrt(pi)*gamma(1 - s - a/2)*gamma(1 - s + a/2)),
+            (Max(-(re(a) + 1)/2, (re(a) - 1)/2), Rational(1, 4)), True)
+    assert MT(cos(sqrt(x))*bessely(a, sqrt(x)), x, s) == \
+        (-4**s*cos(pi*(a/2 - s))*gamma(s - a/2)*gamma(s + a/2)*gamma(S.Half - 2*s)
+         / (sqrt(pi)*gamma(S.Half - s - a/2)*gamma(S.Half - s + a/2)),
+            (Max(-re(a)/2, re(a)/2), Rational(1, 4)), True)
+    assert MT(besselj(a, sqrt(x))*bessely(a, sqrt(x)), x, s) == \
+        (-cos(pi*s)*gamma(s)*gamma(a + s)*gamma(S.Half - s)
+         / (pi**S('3/2')*gamma(1 + a - s)),
+            (Max(-re(a), 0), S.Half), True)
+    assert MT(besselj(a, sqrt(x))*bessely(b, sqrt(x)), x, s) == \
+        (-4**s*cos(pi*(a/2 - b/2 + s))*gamma(1 - 2*s)
+         * gamma(a/2 - b/2 + s)*gamma(a/2 + b/2 + s)
+         / (pi*gamma(a/2 - b/2 - s + 1)*gamma(a/2 + b/2 - s + 1)),
+            (Max((-re(a) + re(b))/2, (-re(a) - re(b))/2), S.Half), True)
+    # NOTE bessely(a, sqrt(x))**2 and bessely(a, sqrt(x))*bessely(b, sqrt(x))
+    # are a mess (no matter what way you look at it ...)
+    assert MT(bessely(a, sqrt(x))**2, x, s)[1:] == \
+             ((Max(-re(a), 0, re(a)), S.Half), True)
+
+    # Section 8.4.22
+    # TODO we can't do any of these (delicate cancellation)
+
+    # Section 8.4.23
+    assert MT(besselk(a, 2*sqrt(x)), x, s) == \
+        (gamma(
+         s - a/2)*gamma(s + a/2)/2, (Max(-re(a)/2, re(a)/2), oo), True)
+    assert MT(besselj(a, 2*sqrt(2*sqrt(x)))*besselk(
+        a, 2*sqrt(2*sqrt(x))), x, s) == (4**(-s)*gamma(2*s)*
+        gamma(a/2 + s)/(2*gamma(a/2 - s + 1)), (Max(0, -re(a)/2), oo), True)
+    # TODO bessely(a, x)*besselk(a, x) is a mess
+    assert MT(besseli(a, sqrt(x))*besselk(a, sqrt(x)), x, s) == \
+        (gamma(s)*gamma(
+        a + s)*gamma(-s + S.Half)/(2*sqrt(pi)*gamma(a - s + 1)),
+        (Max(-re(a), 0), S.Half), True)
+    assert MT(besseli(b, sqrt(x))*besselk(a, sqrt(x)), x, s) == \
+        (2**(2*s - 1)*gamma(-2*s + 1)*gamma(-a/2 + b/2 + s)* \
+        gamma(a/2 + b/2 + s)/(gamma(-a/2 + b/2 - s + 1)* \
+        gamma(a/2 + b/2 - s + 1)), (Max(-re(a)/2 - re(b)/2, \
+        re(a)/2 - re(b)/2), S.Half), True)
+
+    # TODO products of besselk are a mess
+
+    mt = MT(exp(-x/2)*besselk(a, x/2), x, s)
+    mt0 = gammasimp(trigsimp(gammasimp(mt[0].expand(func=True))))
+    assert mt0 == 2*pi**Rational(3, 2)*cos(pi*s)*gamma(S.Half - s)/(
+        (cos(2*pi*a) - cos(2*pi*s))*gamma(-a - s + 1)*gamma(a - s + 1))
+    assert mt[1:] == ((Max(-re(a), re(a)), oo), True)
+    # TODO exp(x/2)*besselk(a, x/2) [etc] cannot currently be done
+    # TODO various strange products of special orders
+
+
+@slow
+def test_expint():
+    from sympy.functions.elementary.miscellaneous import Max
+    from sympy.functions.special.error_functions import Ci, E1, Si
+    from sympy.simplify.simplify import simplify
+
+    aneg = Symbol('a', negative=True)
+    u = Symbol('u', polar=True)
+
+    assert mellin_transform(E1(x), x, s) == (gamma(s)/s, (0, oo), True)
+    assert inverse_mellin_transform(gamma(s)/s, s, x,
+              (0, oo)).rewrite(expint).expand() == E1(x)
+    assert mellin_transform(expint(a, x), x, s) == \
+        (gamma(s)/(a + s - 1), (Max(1 - re(a), 0), oo), True)
+    # XXX IMT has hickups with complicated strips ...
+    assert simplify(unpolarify(
+                    inverse_mellin_transform(gamma(s)/(aneg + s - 1), s, x,
+                  (1 - aneg, oo)).rewrite(expint).expand(func=True))) == \
+        expint(aneg, x)
+
+    assert mellin_transform(Si(x), x, s) == \
+        (-2**s*sqrt(pi)*gamma(s/2 + S.Half)/(
+        2*s*gamma(-s/2 + 1)), (-1, 0), True)
+    assert inverse_mellin_transform(-2**s*sqrt(pi)*gamma((s + 1)/2)
+                                    /(2*s*gamma(-s/2 + 1)), s, x, (-1, 0)) \
+        == Si(x)
+
+    assert mellin_transform(Ci(sqrt(x)), x, s) == \
+        (-2**(2*s - 1)*sqrt(pi)*gamma(s)/(s*gamma(-s + S.Half)), (0, 1), True)
+    assert inverse_mellin_transform(
+        -4**s*sqrt(pi)*gamma(s)/(2*s*gamma(-s + S.Half)),
+        s, u, (0, 1)).expand() == Ci(sqrt(u))
+
+
+@slow
+def test_inverse_mellin_transform():
+    from sympy.core.function import expand
+    from sympy.functions.elementary.miscellaneous import (Max, Min)
+    from sympy.functions.elementary.trigonometric import cot
+    from sympy.simplify.powsimp import powsimp
+    from sympy.simplify.simplify import simplify
+    IMT = inverse_mellin_transform
+
+    assert IMT(gamma(s), s, x, (0, oo)) == exp(-x)
+    assert IMT(gamma(-s), s, x, (-oo, 0)) == exp(-1/x)
+    assert simplify(IMT(s/(2*s**2 - 2), s, x, (2, oo))) == \
+        (x**2 + 1)*Heaviside(1 - x)/(4*x)
+
+    # test passing "None"
+    assert IMT(1/(s**2 - 1), s, x, (-1, None)) == \
+        -x*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x)
+    assert IMT(1/(s**2 - 1), s, x, (None, 1)) == \
+        -x*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x)
+
+    # test expansion of sums
+    assert IMT(gamma(s) + gamma(s - 1), s, x, (1, oo)) == (x + 1)*exp(-x)/x
+
+    # test factorisation of polys
+    r = symbols('r', real=True)
+    assert IMT(1/(s**2 + 1), s, exp(-x), (None, oo)
+              ).subs(x, r).rewrite(sin).simplify() \
+        == sin(r)*Heaviside(1 - exp(-r))
+
+    # test multiplicative substitution
+    _a, _b = symbols('a b', positive=True)
+    assert IMT(_b**(-s/_a)*factorial(s/_a)/s, s, x, (0, oo)) == exp(-_b*x**_a)
+    assert IMT(factorial(_a/_b + s/_b)/(_a + s), s, x, (-_a, oo)) == x**_a*exp(-x**_b)
+
+    def simp_pows(expr):
+        return simplify(powsimp(expand_mul(expr, deep=False), force=True)).replace(exp_polar, exp)
+
+    # Now test the inverses of all direct transforms tested above
+
+    # Section 8.4.2
+    nu = symbols('nu', real=True)
+    assert IMT(-1/(nu + s), s, x, (-oo, None)) == x**nu*Heaviside(x - 1)
+    assert IMT(1/(nu + s), s, x, (None, oo)) == x**nu*Heaviside(1 - x)
+    assert simp_pows(IMT(gamma(beta)*gamma(s)/gamma(s + beta), s, x, (0, oo))) \
+        == (1 - x)**(beta - 1)*Heaviside(1 - x)
+    assert simp_pows(IMT(gamma(beta)*gamma(1 - beta - s)/gamma(1 - s),
+                         s, x, (-oo, None))) \
+        == (x - 1)**(beta - 1)*Heaviside(x - 1)
+    assert simp_pows(IMT(gamma(s)*gamma(rho - s)/gamma(rho), s, x, (0, None))) \
+        == (1/(x + 1))**rho
+    assert simp_pows(IMT(d**c*d**(s - 1)*sin(pi*c)
+                         *gamma(s)*gamma(s + c)*gamma(1 - s)*gamma(1 - s - c)/pi,
+                         s, x, (Max(-re(c), 0), Min(1 - re(c), 1)))) \
+        == (x**c - d**c)/(x - d)
+
+    assert simplify(IMT(1/sqrt(pi)*(-c/2)*gamma(s)*gamma((1 - c)/2 - s)
+                        *gamma(-c/2 - s)/gamma(1 - c - s),
+                        s, x, (0, -re(c)/2))) == \
+        (1 + sqrt(x + 1))**c
+    assert simplify(IMT(2**(a + 2*s)*b**(a + 2*s - 1)*gamma(s)*gamma(1 - a - 2*s)
+                        /gamma(1 - a - s), s, x, (0, (-re(a) + 1)/2))) == \
+        b**(a - 1)*(b**2*(sqrt(1 + x/b**2) + 1)**a + x*(sqrt(1 + x/b**2) + 1
+        )**(a - 1))/(b**2 + x)
+    assert simplify(IMT(-2**(c + 2*s)*c*b**(c + 2*s)*gamma(s)*gamma(-c - 2*s)
+                        / gamma(-c - s + 1), s, x, (0, -re(c)/2))) == \
+        b**c*(sqrt(1 + x/b**2) + 1)**c
+
+    # Section 8.4.5
+    assert IMT(24/s**5, s, x, (0, oo)) == log(x)**4*Heaviside(1 - x)
+    assert expand(IMT(6/s**4, s, x, (-oo, 0)), force=True) == \
+        log(x)**3*Heaviside(x - 1)
+    assert IMT(pi/(s*sin(pi*s)), s, x, (-1, 0)) == log(x + 1)
+    assert IMT(pi/(s*sin(pi*s/2)), s, x, (-2, 0)) == log(x**2 + 1)
+    assert IMT(pi/(s*sin(2*pi*s)), s, x, (Rational(-1, 2), 0)) == log(sqrt(x) + 1)
+    assert IMT(pi/(s*sin(pi*s)), s, x, (0, 1)) == log(1 + 1/x)
+
+    # TODO
+    def mysimp(expr):
+        from sympy.core.function import expand
+        from sympy.simplify.powsimp import powsimp
+        from sympy.simplify.simplify import logcombine
+        return expand(
+            powsimp(logcombine(expr, force=True), force=True, deep=True),
+            force=True).replace(exp_polar, exp)
+
+    assert mysimp(mysimp(IMT(pi/(s*tan(pi*s)), s, x, (-1, 0)))) in [
+        log(1 - x)*Heaviside(1 - x) + log(x - 1)*Heaviside(x - 1),
+        log(x)*Heaviside(x - 1) + log(1 - 1/x)*Heaviside(x - 1) + log(-x +
+        1)*Heaviside(-x + 1)]
+    # test passing cot
+    assert mysimp(IMT(pi*cot(pi*s)/s, s, x, (0, 1))) in [
+        log(1/x - 1)*Heaviside(1 - x) + log(1 - 1/x)*Heaviside(x - 1),
+        -log(x)*Heaviside(-x + 1) + log(1 - 1/x)*Heaviside(x - 1) + log(-x +
+        1)*Heaviside(-x + 1), ]
+
+    # 8.4.14
+    assert IMT(-gamma(s + S.Half)/(sqrt(pi)*s), s, x, (Rational(-1, 2), 0)) == \
+        erf(sqrt(x))
+
+    # 8.4.19
+    assert simplify(IMT(gamma(a/2 + s)/gamma(a/2 - s + 1), s, x, (-re(a)/2, Rational(3, 4)))) \
+        == besselj(a, 2*sqrt(x))
+    assert simplify(IMT(2**a*gamma(S.Half - 2*s)*gamma(s + (a + 1)/2)
+                      / (gamma(1 - s - a/2)*gamma(1 - 2*s + a)),
+                      s, x, (-(re(a) + 1)/2, Rational(1, 4)))) == \
+        sin(sqrt(x))*besselj(a, sqrt(x))
+    assert simplify(IMT(2**a*gamma(a/2 + s)*gamma(S.Half - 2*s)
+                      / (gamma(S.Half - s - a/2)*gamma(1 - 2*s + a)),
+                      s, x, (-re(a)/2, Rational(1, 4)))) == \
+        cos(sqrt(x))*besselj(a, sqrt(x))
+    # TODO this comes out as an amazing mess, but simplifies nicely
+    assert simplify(IMT(gamma(a + s)*gamma(S.Half - s)
+                      / (sqrt(pi)*gamma(1 - s)*gamma(1 + a - s)),
+                      s, x, (-re(a), S.Half))) == \
+        besselj(a, sqrt(x))**2
+    assert simplify(IMT(gamma(s)*gamma(S.Half - s)
+                      / (sqrt(pi)*gamma(1 - s - a)*gamma(1 + a - s)),
+                      s, x, (0, S.Half))) == \
+        besselj(-a, sqrt(x))*besselj(a, sqrt(x))
+    assert simplify(IMT(4**s*gamma(-2*s + 1)*gamma(a/2 + b/2 + s)
+                      / (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1)
+                         *gamma(a/2 + b/2 - s + 1)),
+                      s, x, (-(re(a) + re(b))/2, S.Half))) == \
+        besselj(a, sqrt(x))*besselj(b, sqrt(x))
+
+    # Section 8.4.20
+    # TODO this can be further simplified!
+    assert simplify(IMT(-2**(2*s)*cos(pi*a/2 - pi*b/2 + pi*s)*gamma(-2*s + 1) *
+                    gamma(a/2 - b/2 + s)*gamma(a/2 + b/2 + s) /
+                    (pi*gamma(a/2 - b/2 - s + 1)*gamma(a/2 + b/2 - s + 1)),
+                    s, x,
+                    (Max(-re(a)/2 - re(b)/2, -re(a)/2 + re(b)/2), S.Half))) == \
+                    besselj(a, sqrt(x))*-(besselj(-b, sqrt(x)) -
+                    besselj(b, sqrt(x))*cos(pi*b))/sin(pi*b)
+    # TODO more
+
+    # for coverage
+
+    assert IMT(pi/cos(pi*s), s, x, (0, S.Half)) == sqrt(x)/(x + 1)
+
+
+def test_fourier_transform():
+    from sympy.core.function import (expand, expand_complex, expand_trig)
+    from sympy.polys.polytools import factor
+    from sympy.simplify.simplify import simplify
+    FT = fourier_transform
+    IFT = inverse_fourier_transform
+
+    def simp(x):
+        return simplify(expand_trig(expand_complex(expand(x))))
+
+    def sinc(x):
+        return sin(pi*x)/(pi*x)
+    k = symbols('k', real=True)
+    f = Function("f")
+
+    # TODO for this to work with real a, need to expand abs(a*x) to abs(a)*abs(x)
+    a = symbols('a', positive=True)
+    b = symbols('b', positive=True)
+
+    posk = symbols('posk', positive=True)
+
+    # Test unevaluated form
+    assert fourier_transform(f(x), x, k) == FourierTransform(f(x), x, k)
+    assert inverse_fourier_transform(
+        f(k), k, x) == InverseFourierTransform(f(k), k, x)
+
+    # basic examples from wikipedia
+    assert simp(FT(Heaviside(1 - abs(2*a*x)), x, k)) == sinc(k/a)/a
+    # TODO IFT is a *mess*
+    assert simp(FT(Heaviside(1 - abs(a*x))*(1 - abs(a*x)), x, k)) == sinc(k/a)**2/a
+    # TODO IFT
+
+    assert factor(FT(exp(-a*x)*Heaviside(x), x, k), extension=I) == \
+        1/(a + 2*pi*I*k)
+    # NOTE: the ift comes out in pieces
+    assert IFT(1/(a + 2*pi*I*x), x, posk,
+            noconds=False) == (exp(-a*posk), True)
+    assert IFT(1/(a + 2*pi*I*x), x, -posk,
+            noconds=False) == (0, True)
+    assert IFT(1/(a + 2*pi*I*x), x, symbols('k', negative=True),
+            noconds=False) == (0, True)
+    # TODO IFT without factoring comes out as meijer g
+
+    assert factor(FT(x*exp(-a*x)*Heaviside(x), x, k), extension=I) == \
+        1/(a + 2*pi*I*k)**2
+    assert FT(exp(-a*x)*sin(b*x)*Heaviside(x), x, k) == \
+        b/(b**2 + (a + 2*I*pi*k)**2)
+
+    assert FT(exp(-a*x**2), x, k) == sqrt(pi)*exp(-pi**2*k**2/a)/sqrt(a)
+    assert IFT(sqrt(pi/a)*exp(-(pi*k)**2/a), k, x) == exp(-a*x**2)
+    assert FT(exp(-a*abs(x)), x, k) == 2*a/(a**2 + 4*pi**2*k**2)
+    # TODO IFT (comes out as meijer G)
+
+    # TODO besselj(n, x), n an integer > 0 actually can be done...
+
+    # TODO are there other common transforms (no distributions!)?
+
+
+def test_sine_transform():
+    t = symbols("t")
+    w = symbols("w")
+    a = symbols("a")
+    f = Function("f")
+
+    # Test unevaluated form
+    assert sine_transform(f(t), t, w) == SineTransform(f(t), t, w)
+    assert inverse_sine_transform(
+        f(w), w, t) == InverseSineTransform(f(w), w, t)
+
+    assert sine_transform(1/sqrt(t), t, w) == 1/sqrt(w)
+    assert inverse_sine_transform(1/sqrt(w), w, t) == 1/sqrt(t)
+
+    assert sine_transform((1/sqrt(t))**3, t, w) == 2*sqrt(w)
+
+    assert sine_transform(t**(-a), t, w) == 2**(
+        -a + S.Half)*w**(a - 1)*gamma(-a/2 + 1)/gamma((a + 1)/2)
+    assert inverse_sine_transform(2**(-a + S(
+        1)/2)*w**(a - 1)*gamma(-a/2 + 1)/gamma(a/2 + S.Half), w, t) == t**(-a)
+
+    assert sine_transform(
+        exp(-a*t), t, w) == sqrt(2)*w/(sqrt(pi)*(a**2 + w**2))
+    assert inverse_sine_transform(
+        sqrt(2)*w/(sqrt(pi)*(a**2 + w**2)), w, t) == exp(-a*t)
+
+    assert sine_transform(
+        log(t)/t, t, w) == sqrt(2)*sqrt(pi)*-(log(w**2) + 2*EulerGamma)/4
+
+    assert sine_transform(
+        t*exp(-a*t**2), t, w) == sqrt(2)*w*exp(-w**2/(4*a))/(4*a**Rational(3, 2))
+    assert inverse_sine_transform(
+        sqrt(2)*w*exp(-w**2/(4*a))/(4*a**Rational(3, 2)), w, t) == t*exp(-a*t**2)
+
+
+def test_cosine_transform():
+    from sympy.functions.special.error_functions import (Ci, Si)
+
+    t = symbols("t")
+    w = symbols("w")
+    a = symbols("a")
+    f = Function("f")
+
+    # Test unevaluated form
+    assert cosine_transform(f(t), t, w) == CosineTransform(f(t), t, w)
+    assert inverse_cosine_transform(
+        f(w), w, t) == InverseCosineTransform(f(w), w, t)
+
+    assert cosine_transform(1/sqrt(t), t, w) == 1/sqrt(w)
+    assert inverse_cosine_transform(1/sqrt(w), w, t) == 1/sqrt(t)
+
+    assert cosine_transform(1/(
+        a**2 + t**2), t, w) == sqrt(2)*sqrt(pi)*exp(-a*w)/(2*a)
+
+    assert cosine_transform(t**(
+        -a), t, w) == 2**(-a + S.Half)*w**(a - 1)*gamma((-a + 1)/2)/gamma(a/2)
+    assert inverse_cosine_transform(2**(-a + S(
+        1)/2)*w**(a - 1)*gamma(-a/2 + S.Half)/gamma(a/2), w, t) == t**(-a)
+
+    assert cosine_transform(
+        exp(-a*t), t, w) == sqrt(2)*a/(sqrt(pi)*(a**2 + w**2))
+    assert inverse_cosine_transform(
+        sqrt(2)*a/(sqrt(pi)*(a**2 + w**2)), w, t) == exp(-a*t)
+
+    assert cosine_transform(exp(-a*sqrt(t))*cos(a*sqrt(
+        t)), t, w) == a*exp(-a**2/(2*w))/(2*w**Rational(3, 2))
+
+    assert cosine_transform(1/(a + t), t, w) == sqrt(2)*(
+        (-2*Si(a*w) + pi)*sin(a*w)/2 - cos(a*w)*Ci(a*w))/sqrt(pi)
+    assert inverse_cosine_transform(sqrt(2)*meijerg(((S.Half, 0), ()), (
+        (S.Half, 0, 0), (S.Half,)), a**2*w**2/4)/(2*pi), w, t) == 1/(a + t)
+
+    assert cosine_transform(1/sqrt(a**2 + t**2), t, w) == sqrt(2)*meijerg(
+        ((S.Half,), ()), ((0, 0), (S.Half,)), a**2*w**2/4)/(2*sqrt(pi))
+    assert inverse_cosine_transform(sqrt(2)*meijerg(((S.Half,), ()), ((0, 0), (S.Half,)), a**2*w**2/4)/(2*sqrt(pi)), w, t) == 1/(t*sqrt(a**2/t**2 + 1))
+
+
+def test_hankel_transform():
+    r = Symbol("r")
+    k = Symbol("k")
+    nu = Symbol("nu")
+    m = Symbol("m")
+    a = symbols("a")
+
+    assert hankel_transform(1/r, r, k, 0) == 1/k
+    assert inverse_hankel_transform(1/k, k, r, 0) == 1/r
+
+    assert hankel_transform(
+        1/r**m, r, k, 0) == 2**(-m + 1)*k**(m - 2)*gamma(-m/2 + 1)/gamma(m/2)
+    assert inverse_hankel_transform(
+        2**(-m + 1)*k**(m - 2)*gamma(-m/2 + 1)/gamma(m/2), k, r, 0) == r**(-m)
+
+    assert hankel_transform(1/r**m, r, k, nu) == (
+        2*2**(-m)*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/gamma(m/2 + nu/2))
+    assert inverse_hankel_transform(2**(-m + 1)*k**(
+        m - 2)*gamma(-m/2 + nu/2 + 1)/gamma(m/2 + nu/2), k, r, nu) == r**(-m)
+
+    assert hankel_transform(r**nu*exp(-a*r), r, k, nu) == \
+        2**(nu + 1)*a*k**(-nu - 3)*(a**2/k**2 + 1)**(-nu - S(
+                                                     3)/2)*gamma(nu + Rational(3, 2))/sqrt(pi)
+    assert inverse_hankel_transform(
+        2**(nu + 1)*a*k**(-nu - 3)*(a**2/k**2 + 1)**(-nu - Rational(3, 2))*gamma(
+        nu + Rational(3, 2))/sqrt(pi), k, r, nu) == r**nu*exp(-a*r)
+
+
+def test_issue_7181():
+    assert mellin_transform(1/(1 - x), x, s) != None
+
+
+def test_issue_8882():
+    # This is the original test.
+    # from sympy import diff, Integral, integrate
+    # r = Symbol('r')
+    # psi = 1/r*sin(r)*exp(-(a0*r))
+    # h = -1/2*diff(psi, r, r) - 1/r*psi
+    # f = 4*pi*psi*h*r**2
+    # assert integrate(f, (r, -oo, 3), meijerg=True).has(Integral) == True
+
+    # To save time, only the critical part is included.
+    F = -a**(-s + 1)*(4 + 1/a**2)**(-s/2)*sqrt(1/a**2)*exp(-s*I*pi)* \
+        sin(s*atan(sqrt(1/a**2)/2))*gamma(s)
+    raises(IntegralTransformError, lambda:
+        inverse_mellin_transform(F, s, x, (-1, oo),
+        **{'as_meijerg': True, 'needeval': True}))
+
+
+def test_issue_12591():
+    x, y = symbols("x y", real=True)
+    assert fourier_transform(exp(x), x, y) == FourierTransform(exp(x), x, y)

parrot/lib/python3.10/site-packages/sympy/integrals/tests/test_trigonometry.py

@@ -0,0 +1,98 @@
+from sympy.core import Ne, Rational, Symbol
+from sympy.functions import sin, cos, tan, csc, sec, cot, log, Piecewise
+from sympy.integrals.trigonometry import trigintegrate
+
+x = Symbol('x')
+
+
+def test_trigintegrate_odd():
+    assert trigintegrate(Rational(1), x) == x
+    assert trigintegrate(x, x) is None
+    assert trigintegrate(x**2, x) is None
+
+    assert trigintegrate(sin(x), x) == -cos(x)
+    assert trigintegrate(cos(x), x) == sin(x)
+
+    assert trigintegrate(sin(3*x), x) == -cos(3*x)/3
+    assert trigintegrate(cos(3*x), x) == sin(3*x)/3
+
+    y = Symbol('y')
+    assert trigintegrate(sin(y*x), x) == Piecewise(
+        (-cos(y*x)/y, Ne(y, 0)), (0, True))
+    assert trigintegrate(cos(y*x), x) == Piecewise(
+        (sin(y*x)/y, Ne(y, 0)), (x, True))
+    assert trigintegrate(sin(y*x)**2, x) == Piecewise(
+        ((x*y/2 - sin(x*y)*cos(x*y)/2)/y, Ne(y, 0)), (0, True))
+    assert trigintegrate(sin(y*x)*cos(y*x), x) == Piecewise(
+        (sin(x*y)**2/(2*y), Ne(y, 0)), (0, True))
+    assert trigintegrate(cos(y*x)**2, x) == Piecewise(
+        ((x*y/2 + sin(x*y)*cos(x*y)/2)/y, Ne(y, 0)), (x, True))
+
+    y = Symbol('y', positive=True)
+    # TODO: remove conds='none' below. For this to work we would have to rule
+    #       out (e.g. by trying solve) the condition y = 0, incompatible with
+    #       y.is_positive being True.
+    assert trigintegrate(sin(y*x), x, conds='none') == -cos(y*x)/y
+    assert trigintegrate(cos(y*x), x, conds='none') == sin(y*x)/y
+
+    assert trigintegrate(sin(x)*cos(x), x) == sin(x)**2/2
+    assert trigintegrate(sin(x)*cos(x)**2, x) == -cos(x)**3/3
+    assert trigintegrate(sin(x)**2*cos(x), x) == sin(x)**3/3
+
+    # check if it selects right function to substitute,
+    # so the result is kept simple
+    assert trigintegrate(sin(x)**7 * cos(x), x) == sin(x)**8/8
+    assert trigintegrate(sin(x) * cos(x)**7, x) == -cos(x)**8/8
+
+    assert trigintegrate(sin(x)**7 * cos(x)**3, x) == \
+        -sin(x)**10/10 + sin(x)**8/8
+    assert trigintegrate(sin(x)**3 * cos(x)**7, x) == \
+        cos(x)**10/10 - cos(x)**8/8
+
+    # both n, m are odd and -ve, and not necessarily equal
+    assert trigintegrate(sin(x)**-1*cos(x)**-1, x) == \
+        -log(sin(x)**2 - 1)/2 + log(sin(x))
+
+
+def test_trigintegrate_even():
+    assert trigintegrate(sin(x)**2, x) == x/2 - cos(x)*sin(x)/2
+    assert trigintegrate(cos(x)**2, x) == x/2 + cos(x)*sin(x)/2
+
+    assert trigintegrate(sin(3*x)**2, x) == x/2 - cos(3*x)*sin(3*x)/6
+    assert trigintegrate(cos(3*x)**2, x) == x/2 + cos(3*x)*sin(3*x)/6
+    assert trigintegrate(sin(x)**2 * cos(x)**2, x) == \
+        x/8 - sin(2*x)*cos(2*x)/16
+
+    assert trigintegrate(sin(x)**4 * cos(x)**2, x) == \
+        x/16 - sin(x) *cos(x)/16 - sin(x)**3*cos(x)/24 + \
+        sin(x)**5*cos(x)/6
+
+    assert trigintegrate(sin(x)**2 * cos(x)**4, x) == \
+        x/16 + cos(x) *sin(x)/16 + cos(x)**3*sin(x)/24 - \
+        cos(x)**5*sin(x)/6
+
+    assert trigintegrate(sin(x)**(-4), x) == -2*cos(x)/(3*sin(x)) \
+        - cos(x)/(3*sin(x)**3)
+
+    assert trigintegrate(cos(x)**(-6), x) == sin(x)/(5*cos(x)**5) \
+        + 4*sin(x)/(15*cos(x)**3) + 8*sin(x)/(15*cos(x))
+
+
+def test_trigintegrate_mixed():
+    assert trigintegrate(sin(x)*sec(x), x) == -log(cos(x))
+    assert trigintegrate(sin(x)*csc(x), x) == x
+    assert trigintegrate(sin(x)*cot(x), x) == sin(x)
+
+    assert trigintegrate(cos(x)*sec(x), x) == x
+    assert trigintegrate(cos(x)*csc(x), x) == log(sin(x))
+    assert trigintegrate(cos(x)*tan(x), x) == -cos(x)
+    assert trigintegrate(cos(x)*cot(x), x) == log(cos(x) - 1)/2 \
+        - log(cos(x) + 1)/2 + cos(x)
+    assert trigintegrate(cot(x)*cos(x)**2, x) == log(sin(x)) - sin(x)**2/2
+
+
+def test_trigintegrate_symbolic():
+    n = Symbol('n', integer=True)
+    assert trigintegrate(cos(x)**n, x) is None
+    assert trigintegrate(sin(x)**n, x) is None
+    assert trigintegrate(cot(x)**n, x) is None

parrot/lib/python3.10/site-packages/sympy/integrals/transforms.py

@@ -0,0 +1,1590 @@
+""" Integral Transforms """
+from functools import reduce, wraps
+from itertools import repeat
+from sympy.core import S, pi
+from sympy.core.add import Add
+from sympy.core.function import (
+    AppliedUndef, count_ops, expand, expand_mul, Function)
+from sympy.core.mul import Mul
+from sympy.core.intfunc import igcd, ilcm
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy
+from sympy.core.traversal import postorder_traversal
+from sympy.functions.combinatorial.factorials import factorial, rf
+from sympy.functions.elementary.complexes import re, arg, Abs
+from sympy.functions.elementary.exponential import exp, exp_polar
+from sympy.functions.elementary.hyperbolic import cosh, coth, sinh, tanh
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.miscellaneous import Max, Min, sqrt
+from sympy.functions.elementary.piecewise import piecewise_fold
+from sympy.functions.elementary.trigonometric import cos, cot, sin, tan
+from sympy.functions.special.bessel import besselj
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import meijerg
+from sympy.integrals import integrate, Integral
+from sympy.integrals.meijerint import _dummy
+from sympy.logic.boolalg import to_cnf, conjuncts, disjuncts, Or, And
+from sympy.polys.polyroots import roots
+from sympy.polys.polytools import factor, Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import debug
+
+
+##########################################################################
+# Helpers / Utilities
+##########################################################################
+
+
+class IntegralTransformError(NotImplementedError):
+    """
+    Exception raised in relation to problems computing transforms.
+
+    Explanation
+    ===========
+
+    This class is mostly used internally; if integrals cannot be computed
+    objects representing unevaluated transforms are usually returned.
+
+    The hint ``needeval=True`` can be used to disable returning transform
+    objects, and instead raise this exception if an integral cannot be
+    computed.
+    """
+    def __init__(self, transform, function, msg):
+        super().__init__(
+            "%s Transform could not be computed: %s." % (transform, msg))
+        self.function = function
+
+
+class IntegralTransform(Function):
+    """
+    Base class for integral transforms.
+
+    Explanation
+    ===========
+
+    This class represents unevaluated transforms.
+
+    To implement a concrete transform, derive from this class and implement
+    the ``_compute_transform(f, x, s, **hints)`` and ``_as_integral(f, x, s)``
+    functions. If the transform cannot be computed, raise :obj:`IntegralTransformError`.
+
+    Also set ``cls._name``. For instance,
+
+    >>> from sympy import LaplaceTransform
+    >>> LaplaceTransform._name
+    'Laplace'
+
+    Implement ``self._collapse_extra`` if your function returns more than just a
+    number and possibly a convergence condition.
+    """
+
+    @property
+    def function(self):
+        """ The function to be transformed. """
+        return self.args[0]
+
+    @property
+    def function_variable(self):
+        """ The dependent variable of the function to be transformed. """
+        return self.args[1]
+
+    @property
+    def transform_variable(self):
+        """ The independent transform variable. """
+        return self.args[2]
+
+    @property
+    def free_symbols(self):
+        """
+        This method returns the symbols that will exist when the transform
+        is evaluated.
+        """
+        return self.function.free_symbols.union({self.transform_variable}) \
+            - {self.function_variable}
+
+    def _compute_transform(self, f, x, s, **hints):
+        raise NotImplementedError
+
+    def _as_integral(self, f, x, s):
+        raise NotImplementedError
+
+    def _collapse_extra(self, extra):
+        cond = And(*extra)
+        if cond == False:
+            raise IntegralTransformError(self.__class__.name, None, '')
+        return cond
+
+    def _try_directly(self, **hints):
+        T = None
+        try_directly = not any(func.has(self.function_variable)
+                               for func in self.function.atoms(AppliedUndef))
+        if try_directly:
+            try:
+                T = self._compute_transform(self.function,
+                    self.function_variable, self.transform_variable, **hints)
+            except IntegralTransformError:
+                debug('[IT _try ] Caught IntegralTransformError, returns None')
+                T = None
+
+        fn = self.function
+        if not fn.is_Add:
+            fn = expand_mul(fn)
+        return fn, T
+
+    def doit(self, **hints):
+        """
+        Try to evaluate the transform in closed form.
+
+        Explanation
+        ===========
+
+        This general function handles linearity, but apart from that leaves
+        pretty much everything to _compute_transform.
+
+        Standard hints are the following:
+
+        - ``simplify``: whether or not to simplify the result
+        - ``noconds``: if True, do not return convergence conditions
+        - ``needeval``: if True, raise IntegralTransformError instead of
+                        returning IntegralTransform objects
+
+        The default values of these hints depend on the concrete transform,
+        usually the default is
+        ``(simplify, noconds, needeval) = (True, False, False)``.
+        """
+        needeval = hints.pop('needeval', False)
+        simplify = hints.pop('simplify', True)
+        hints['simplify'] = simplify
+
+        fn, T = self._try_directly(**hints)
+
+        if T is not None:
+            return T
+
+        if fn.is_Add:
+            hints['needeval'] = needeval
+            res = [self.__class__(*([x] + list(self.args[1:]))).doit(**hints)
+                   for x in fn.args]
+            extra = []
+            ress = []
+            for x in res:
+                if not isinstance(x, tuple):
+                    x = [x]
+                ress.append(x[0])
+                if len(x) == 2:
+                    # only a condition
+                    extra.append(x[1])
+                elif len(x) > 2:
+                    # some region parameters and a condition (Mellin, Laplace)
+                    extra += [x[1:]]
+            if simplify==True:
+                res = Add(*ress).simplify()
+            else:
+                res = Add(*ress)
+            if not extra:
+                return res
+            try:
+                extra = self._collapse_extra(extra)
+                if iterable(extra):
+                    return (res,) + tuple(extra)
+                else:
+                    return (res, extra)
+            except IntegralTransformError:
+                pass
+
+        if needeval:
+            raise IntegralTransformError(
+                self.__class__._name, self.function, 'needeval')
+
+        # TODO handle derivatives etc
+
+        # pull out constant coefficients
+        coeff, rest = fn.as_coeff_mul(self.function_variable)
+        return coeff*self.__class__(*([Mul(*rest)] + list(self.args[1:])))
+
+    @property
+    def as_integral(self):
+        return self._as_integral(self.function, self.function_variable,
+                                 self.transform_variable)
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        return self.as_integral
+
+
+def _simplify(expr, doit):
+    if doit:
+        from sympy.simplify import simplify
+        from sympy.simplify.powsimp import powdenest
+        return simplify(powdenest(piecewise_fold(expr), polar=True))
+    return expr
+
+
+def _noconds_(default):
+    """
+    This is a decorator generator for dropping convergence conditions.
+
+    Explanation
+    ===========
+
+    Suppose you define a function ``transform(*args)`` which returns a tuple of
+    the form ``(result, cond1, cond2, ...)``.
+
+    Decorating it ``@_noconds_(default)`` will add a new keyword argument
+    ``noconds`` to it. If ``noconds=True``, the return value will be altered to
+    be only ``result``, whereas if ``noconds=False`` the return value will not
+    be altered.
+
+    The default value of the ``noconds`` keyword will be ``default`` (i.e. the
+    argument of this function).
+    """
+    def make_wrapper(func):
+        @wraps(func)
+        def wrapper(*args, noconds=default, **kwargs):
+            res = func(*args, **kwargs)
+            if noconds:
+                return res[0]
+            return res
+        return wrapper
+    return make_wrapper
+_noconds = _noconds_(False)
+
+
+##########################################################################
+# Mellin Transform
+##########################################################################
+
+def _default_integrator(f, x):
+    return integrate(f, (x, S.Zero, S.Infinity))
+
+
+@_noconds
+def _mellin_transform(f, x, s_, integrator=_default_integrator, simplify=True):
+    """ Backend function to compute Mellin transforms. """
+    # We use a fresh dummy, because assumptions on s might drop conditions on
+    # convergence of the integral.
+    s = _dummy('s', 'mellin-transform', f)
+    F = integrator(x**(s - 1) * f, x)
+
+    if not F.has(Integral):
+        return _simplify(F.subs(s, s_), simplify), (S.NegativeInfinity, S.Infinity), S.true
+
+    if not F.is_Piecewise:  # XXX can this work if integration gives continuous result now?
+        raise IntegralTransformError('Mellin', f, 'could not compute integral')
+
+    F, cond = F.args[0]
+    if F.has(Integral):
+        raise IntegralTransformError(
+            'Mellin', f, 'integral in unexpected form')
+
+    def process_conds(cond):
+        """
+        Turn ``cond`` into a strip (a, b), and auxiliary conditions.
+        """
+        from sympy.solvers.inequalities import _solve_inequality
+        a = S.NegativeInfinity
+        b = S.Infinity
+        aux = S.true
+        conds = conjuncts(to_cnf(cond))
+        t = Dummy('t', real=True)
+        for c in conds:
+            a_ = S.Infinity
+            b_ = S.NegativeInfinity
+            aux_ = []
+            for d in disjuncts(c):
+                d_ = d.replace(
+                    re, lambda x: x.as_real_imag()[0]).subs(re(s), t)
+                if not d.is_Relational or \
+                    d.rel_op in ('==', '!=') \
+                        or d_.has(s) or not d_.has(t):
+                    aux_ += [d]
+                    continue
+                soln = _solve_inequality(d_, t)
+                if not soln.is_Relational or \
+                        soln.rel_op in ('==', '!='):
+                    aux_ += [d]
+                    continue
+                if soln.lts == t:
+                    b_ = Max(soln.gts, b_)
+                else:
+                    a_ = Min(soln.lts, a_)
+            if a_ is not S.Infinity and a_ != b:
+                a = Max(a_, a)
+            elif b_ is not S.NegativeInfinity and b_ != a:
+                b = Min(b_, b)
+            else:
+                aux = And(aux, Or(*aux_))
+        return a, b, aux
+
+    conds = [process_conds(c) for c in disjuncts(cond)]
+    conds = [x for x in conds if x[2] != False]
+    conds.sort(key=lambda x: (x[0] - x[1], count_ops(x[2])))
+
+    if not conds:
+        raise IntegralTransformError('Mellin', f, 'no convergence found')
+
+    a, b, aux = conds[0]
+    return _simplify(F.subs(s, s_), simplify), (a, b), aux
+
+
+class MellinTransform(IntegralTransform):
+    """
+    Class representing unevaluated Mellin transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute Mellin transforms, see the :func:`mellin_transform`
+    docstring.
+    """
+
+    _name = 'Mellin'
+
+    def _compute_transform(self, f, x, s, **hints):
+        return _mellin_transform(f, x, s, **hints)
+
+    def _as_integral(self, f, x, s):
+        return Integral(f*x**(s - 1), (x, S.Zero, S.Infinity))
+
+    def _collapse_extra(self, extra):
+        a = []
+        b = []
+        cond = []
+        for (sa, sb), c in extra:
+            a += [sa]
+            b += [sb]
+            cond += [c]
+        res = (Max(*a), Min(*b)), And(*cond)
+        if (res[0][0] >= res[0][1]) == True or res[1] == False:
+            raise IntegralTransformError(
+                'Mellin', None, 'no combined convergence.')
+        return res
+
+
+def mellin_transform(f, x, s, **hints):
+    r"""
+    Compute the Mellin transform `F(s)` of `f(x)`,
+
+    .. math :: F(s) = \int_0^\infty x^{s-1} f(x) \mathrm{d}x.
+
+    For all "sensible" functions, this converges absolutely in a strip
+      `a < \operatorname{Re}(s) < b`.
+
+    Explanation
+    ===========
+
+    The Mellin transform is related via change of variables to the Fourier
+    transform, and also to the (bilateral) Laplace transform.
+
+    This function returns ``(F, (a, b), cond)``
+    where ``F`` is the Mellin transform of ``f``, ``(a, b)`` is the fundamental strip
+    (as above), and ``cond`` are auxiliary convergence conditions.
+
+    If the integral cannot be computed in closed form, this function returns
+    an unevaluated :class:`MellinTransform` object.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`. If ``noconds=False``,
+    then only `F` will be returned (i.e. not ``cond``, and also not the strip
+    ``(a, b)``).
+
+    Examples
+    ========
+
+    >>> from sympy import mellin_transform, exp
+    >>> from sympy.abc import x, s
+    >>> mellin_transform(exp(-x), x, s)
+    (gamma(s), (0, oo), True)
+
+    See Also
+    ========
+
+    inverse_mellin_transform, laplace_transform, fourier_transform
+    hankel_transform, inverse_hankel_transform
+    """
+    return MellinTransform(f, x, s).doit(**hints)
+
+
+def _rewrite_sin(m_n, s, a, b):
+    """
+    Re-write the sine function ``sin(m*s + n)`` as gamma functions, compatible
+    with the strip (a, b).
+
+    Return ``(gamma1, gamma2, fac)`` so that ``f == fac/(gamma1 * gamma2)``.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.transforms import _rewrite_sin
+    >>> from sympy import pi, S
+    >>> from sympy.abc import s
+    >>> _rewrite_sin((pi, 0), s, 0, 1)
+    (gamma(s), gamma(1 - s), pi)
+    >>> _rewrite_sin((pi, 0), s, 1, 0)
+    (gamma(s - 1), gamma(2 - s), -pi)
+    >>> _rewrite_sin((pi, 0), s, -1, 0)
+    (gamma(s + 1), gamma(-s), -pi)
+    >>> _rewrite_sin((pi, pi/2), s, S(1)/2, S(3)/2)
+    (gamma(s - 1/2), gamma(3/2 - s), -pi)
+    >>> _rewrite_sin((pi, pi), s, 0, 1)
+    (gamma(s), gamma(1 - s), -pi)
+    >>> _rewrite_sin((2*pi, 0), s, 0, S(1)/2)
+    (gamma(2*s), gamma(1 - 2*s), pi)
+    >>> _rewrite_sin((2*pi, 0), s, S(1)/2, 1)
+    (gamma(2*s - 1), gamma(2 - 2*s), -pi)
+    """
+    # (This is a separate function because it is moderately complicated,
+    #  and I want to doctest it.)
+    # We want to use pi/sin(pi*x) = gamma(x)*gamma(1-x).
+    # But there is one comlication: the gamma functions determine the
+    # inegration contour in the definition of the G-function. Usually
+    # it would not matter if this is slightly shifted, unless this way
+    # we create an undefined function!
+    # So we try to write this in such a way that the gammas are
+    # eminently on the right side of the strip.
+    m, n = m_n
+
+    m = expand_mul(m/pi)
+    n = expand_mul(n/pi)
+    r = ceiling(-m*a - n.as_real_imag()[0])  # Don't use re(n), does not expand
+    return gamma(m*s + n + r), gamma(1 - n - r - m*s), (-1)**r*pi
+
+
+class MellinTransformStripError(ValueError):
+    """
+    Exception raised by _rewrite_gamma. Mainly for internal use.
+    """
+    pass
+
+
+def _rewrite_gamma(f, s, a, b):
+    """
+    Try to rewrite the product f(s) as a product of gamma functions,
+    so that the inverse Mellin transform of f can be expressed as a meijer
+    G function.
+
+    Explanation
+    ===========
+
+    Return (an, ap), (bm, bq), arg, exp, fac such that
+    G((an, ap), (bm, bq), arg/z**exp)*fac is the inverse Mellin transform of f(s).
+
+    Raises IntegralTransformError or MellinTransformStripError on failure.
+
+    It is asserted that f has no poles in the fundamental strip designated by
+    (a, b). One of a and b is allowed to be None. The fundamental strip is
+    important, because it determines the inversion contour.
+
+    This function can handle exponentials, linear factors, trigonometric
+    functions.
+
+    This is a helper function for inverse_mellin_transform that will not
+    attempt any transformations on f.
+
+    Examples
+    ========
+
+    >>> from sympy.integrals.transforms import _rewrite_gamma
+    >>> from sympy.abc import s
+    >>> from sympy import oo
+    >>> _rewrite_gamma(s*(s+3)*(s-1), s, -oo, oo)
+    (([], [-3, 0, 1]), ([-2, 1, 2], []), 1, 1, -1)
+    >>> _rewrite_gamma((s-1)**2, s, -oo, oo)
+    (([], [1, 1]), ([2, 2], []), 1, 1, 1)
+
+    Importance of the fundamental strip:
+
+    >>> _rewrite_gamma(1/s, s, 0, oo)
+    (([1], []), ([], [0]), 1, 1, 1)
+    >>> _rewrite_gamma(1/s, s, None, oo)
+    (([1], []), ([], [0]), 1, 1, 1)
+    >>> _rewrite_gamma(1/s, s, 0, None)
+    (([1], []), ([], [0]), 1, 1, 1)
+    >>> _rewrite_gamma(1/s, s, -oo, 0)
+    (([], [1]), ([0], []), 1, 1, -1)
+    >>> _rewrite_gamma(1/s, s, None, 0)
+    (([], [1]), ([0], []), 1, 1, -1)
+    >>> _rewrite_gamma(1/s, s, -oo, None)
+    (([], [1]), ([0], []), 1, 1, -1)
+
+    >>> _rewrite_gamma(2**(-s+3), s, -oo, oo)
+    (([], []), ([], []), 1/2, 1, 8)
+    """
+    # Our strategy will be as follows:
+    # 1) Guess a constant c such that the inversion integral should be
+    #    performed wrt s'=c*s (instead of plain s). Write s for s'.
+    # 2) Process all factors, rewrite them independently as gamma functions in
+    #    argument s, or exponentials of s.
+    # 3) Try to transform all gamma functions s.t. they have argument
+    #    a+s or a-s.
+    # 4) Check that the resulting G function parameters are valid.
+    # 5) Combine all the exponentials.
+
+    a_, b_ = S([a, b])
+
+    def left(c, is_numer):
+        """
+        Decide whether pole at c lies to the left of the fundamental strip.
+        """
+        # heuristically, this is the best chance for us to solve the inequalities
+        c = expand(re(c))
+        if a_ is None and b_ is S.Infinity:
+            return True
+        if a_ is None:
+            return c < b_
+        if b_ is None:
+            return c <= a_
+        if (c >= b_) == True:
+            return False
+        if (c <= a_) == True:
+            return True
+        if is_numer:
+            return None
+        if a_.free_symbols or b_.free_symbols or c.free_symbols:
+            return None  # XXX
+            #raise IntegralTransformError('Inverse Mellin', f,
+            #                     'Could not determine position of singularity %s'
+            #                     ' relative to fundamental strip' % c)
+        raise MellinTransformStripError('Pole inside critical strip?')
+
+    # 1)
+    s_multipliers = []
+    for g in f.atoms(gamma):
+        if not g.has(s):
+            continue
+        arg = g.args[0]
+        if arg.is_Add:
+            arg = arg.as_independent(s)[1]
+        coeff, _ = arg.as_coeff_mul(s)
+        s_multipliers += [coeff]
+    for g in f.atoms(sin, cos, tan, cot):
+        if not g.has(s):
+            continue
+        arg = g.args[0]
+        if arg.is_Add:
+            arg = arg.as_independent(s)[1]
+        coeff, _ = arg.as_coeff_mul(s)
+        s_multipliers += [coeff/pi]
+    s_multipliers = [Abs(x) if x.is_extended_real else x for x in s_multipliers]
+    common_coefficient = S.One
+    for x in s_multipliers:
+        if not x.is_Rational:
+            common_coefficient = x
+            break
+    s_multipliers = [x/common_coefficient for x in s_multipliers]
+    if not (all(x.is_Rational for x in s_multipliers) and
+            common_coefficient.is_extended_real):
+        raise IntegralTransformError("Gamma", None, "Nonrational multiplier")
+    s_multiplier = common_coefficient/reduce(ilcm, [S(x.q)
+                                             for x in s_multipliers], S.One)
+    if s_multiplier == common_coefficient:
+        if len(s_multipliers) == 0:
+            s_multiplier = common_coefficient
+        else:
+            s_multiplier = common_coefficient \
+                *reduce(igcd, [S(x.p) for x in s_multipliers])
+
+    f = f.subs(s, s/s_multiplier)
+    fac = S.One/s_multiplier
+    exponent = S.One/s_multiplier
+    if a_ is not None:
+        a_ *= s_multiplier
+    if b_ is not None:
+        b_ *= s_multiplier
+
+    # 2)
+    numer, denom = f.as_numer_denom()
+    numer = Mul.make_args(numer)
+    denom = Mul.make_args(denom)
+    args = list(zip(numer, repeat(True))) + list(zip(denom, repeat(False)))
+
+    facs = []
+    dfacs = []
+    # *_gammas will contain pairs (a, c) representing Gamma(a*s + c)
+    numer_gammas = []
+    denom_gammas = []
+    # exponentials will contain bases for exponentials of s
+    exponentials = []
+
+    def exception(fact):
+        return IntegralTransformError("Inverse Mellin", f, "Unrecognised form '%s'." % fact)
+    while args:
+        fact, is_numer = args.pop()
+        if is_numer:
+            ugammas, lgammas = numer_gammas, denom_gammas
+            ufacs = facs
+        else:
+            ugammas, lgammas = denom_gammas, numer_gammas
+            ufacs = dfacs
+
+        def linear_arg(arg):
+            """ Test if arg is of form a*s+b, raise exception if not. """
+            if not arg.is_polynomial(s):
+                raise exception(fact)
+            p = Poly(arg, s)
+            if p.degree() != 1:
+                raise exception(fact)
+            return p.all_coeffs()
+
+        # constants
+        if not fact.has(s):
+            ufacs += [fact]
+        # exponentials
+        elif fact.is_Pow or isinstance(fact, exp):
+            if fact.is_Pow:
+                base = fact.base
+                exp_ = fact.exp
+            else:
+                base = exp_polar(1)
+                exp_ = fact.exp
+            if exp_.is_Integer:
+                cond = is_numer
+                if exp_ < 0:
+                    cond = not cond
+                args += [(base, cond)]*Abs(exp_)
+                continue
+            elif not base.has(s):
+                a, b = linear_arg(exp_)
+                if not is_numer:
+                    base = 1/base
+                exponentials += [base**a]
+                facs += [base**b]
+            else:
+                raise exception(fact)
+        # linear factors
+        elif fact.is_polynomial(s):
+            p = Poly(fact, s)
+            if p.degree() != 1:
+                # We completely factor the poly. For this we need the roots.
+                # Now roots() only works in some cases (low degree), and CRootOf
+                # only works without parameters. So try both...
+                coeff = p.LT()[1]
+                rs = roots(p, s)
+                if len(rs) != p.degree():
+                    rs = CRootOf.all_roots(p)
+                ufacs += [coeff]
+                args += [(s - c, is_numer) for c in rs]
+                continue
+            a, c = p.all_coeffs()
+            ufacs += [a]
+            c /= -a
+            # Now need to convert s - c
+            if left(c, is_numer):
+                ugammas += [(S.One, -c + 1)]
+                lgammas += [(S.One, -c)]
+            else:
+                ufacs += [-1]
+                ugammas += [(S.NegativeOne, c + 1)]
+                lgammas += [(S.NegativeOne, c)]
+        elif isinstance(fact, gamma):
+            a, b = linear_arg(fact.args[0])
+            if is_numer:
+                if (a > 0 and (left(-b/a, is_numer) == False)) or \
+                   (a < 0 and (left(-b/a, is_numer) == True)):
+                    raise NotImplementedError(
+                        'Gammas partially over the strip.')
+            ugammas += [(a, b)]
+        elif isinstance(fact, sin):
+            # We try to re-write all trigs as gammas. This is not in
+            # general the best strategy, since sometimes this is impossible,
+            # but rewriting as exponentials would work. However trig functions
+            # in inverse mellin transforms usually all come from simplifying
+            # gamma terms, so this should work.
+            a = fact.args[0]
+            if is_numer:
+                # No problem with the poles.
+                gamma1, gamma2, fac_ = gamma(a/pi), gamma(1 - a/pi), pi
+            else:
+                gamma1, gamma2, fac_ = _rewrite_sin(linear_arg(a), s, a_, b_)
+            args += [(gamma1, not is_numer), (gamma2, not is_numer)]
+            ufacs += [fac_]
+        elif isinstance(fact, tan):
+            a = fact.args[0]
+            args += [(sin(a, evaluate=False), is_numer),
+                     (sin(pi/2 - a, evaluate=False), not is_numer)]
+        elif isinstance(fact, cos):
+            a = fact.args[0]
+            args += [(sin(pi/2 - a, evaluate=False), is_numer)]
+        elif isinstance(fact, cot):
+            a = fact.args[0]
+            args += [(sin(pi/2 - a, evaluate=False), is_numer),
+                     (sin(a, evaluate=False), not is_numer)]
+        else:
+            raise exception(fact)
+
+    fac *= Mul(*facs)/Mul(*dfacs)
+
+    # 3)
+    an, ap, bm, bq = [], [], [], []
+    for gammas, plus, minus, is_numer in [(numer_gammas, an, bm, True),
+                                          (denom_gammas, bq, ap, False)]:
+        while gammas:
+            a, c = gammas.pop()
+            if a != -1 and a != +1:
+                # We use the gamma function multiplication theorem.
+                p = Abs(S(a))
+                newa = a/p
+                newc = c/p
+                if not a.is_Integer:
+                    raise TypeError("a is not an integer")
+                for k in range(p):
+                    gammas += [(newa, newc + k/p)]
+                if is_numer:
+                    fac *= (2*pi)**((1 - p)/2) * p**(c - S.Half)
+                    exponentials += [p**a]
+                else:
+                    fac /= (2*pi)**((1 - p)/2) * p**(c - S.Half)
+                    exponentials += [p**(-a)]
+                continue
+            if a == +1:
+                plus.append(1 - c)
+            else:
+                minus.append(c)
+
+    # 4)
+    # TODO
+
+    # 5)
+    arg = Mul(*exponentials)
+
+    # for testability, sort the arguments
+    an.sort(key=default_sort_key)
+    ap.sort(key=default_sort_key)
+    bm.sort(key=default_sort_key)
+    bq.sort(key=default_sort_key)
+
+    return (an, ap), (bm, bq), arg, exponent, fac
+
+
+@_noconds_(True)
+def _inverse_mellin_transform(F, s, x_, strip, as_meijerg=False):
+    """ A helper for the real inverse_mellin_transform function, this one here
+        assumes x to be real and positive. """
+    x = _dummy('t', 'inverse-mellin-transform', F, positive=True)
+    # Actually, we won't try integration at all. Instead we use the definition
+    # of the Meijer G function as a fairly general inverse mellin transform.
+    F = F.rewrite(gamma)
+    for g in [factor(F), expand_mul(F), expand(F)]:
+        if g.is_Add:
+            # do all terms separately
+            ress = [_inverse_mellin_transform(G, s, x, strip, as_meijerg,
+                                              noconds=False)
+                    for G in g.args]
+            conds = [p[1] for p in ress]
+            ress = [p[0] for p in ress]
+            res = Add(*ress)
+            if not as_meijerg:
+                res = factor(res, gens=res.atoms(Heaviside))
+            return res.subs(x, x_), And(*conds)
+
+        try:
+            a, b, C, e, fac = _rewrite_gamma(g, s, strip[0], strip[1])
+        except IntegralTransformError:
+            continue
+        try:
+            G = meijerg(a, b, C/x**e)
+        except ValueError:
+            continue
+        if as_meijerg:
+            h = G
+        else:
+            try:
+                from sympy.simplify import hyperexpand
+                h = hyperexpand(G)
+            except NotImplementedError:
+                raise IntegralTransformError(
+                    'Inverse Mellin', F, 'Could not calculate integral')
+
+            if h.is_Piecewise and len(h.args) == 3:
+                # XXX we break modularity here!
+                h = Heaviside(x - Abs(C))*h.args[0].args[0] \
+                    + Heaviside(Abs(C) - x)*h.args[1].args[0]
+        # We must ensure that the integral along the line we want converges,
+        # and return that value.
+        # See [L], 5.2
+        cond = [Abs(arg(G.argument)) < G.delta*pi]
+        # Note: we allow ">=" here, this corresponds to convergence if we let
+        # limits go to oo symmetrically. ">" corresponds to absolute convergence.
+        cond += [And(Or(len(G.ap) != len(G.bq), 0 >= re(G.nu) + 1),
+                     Abs(arg(G.argument)) == G.delta*pi)]
+        cond = Or(*cond)
+        if cond == False:
+            raise IntegralTransformError(
+                'Inverse Mellin', F, 'does not converge')
+        return (h*fac).subs(x, x_), cond
+
+    raise IntegralTransformError('Inverse Mellin', F, '')
+
+_allowed = None
+
+
+class InverseMellinTransform(IntegralTransform):
+    """
+    Class representing unevaluated inverse Mellin transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute inverse Mellin transforms, see the
+    :func:`inverse_mellin_transform` docstring.
+    """
+
+    _name = 'Inverse Mellin'
+    _none_sentinel = Dummy('None')
+    _c = Dummy('c')
+
+    def __new__(cls, F, s, x, a, b, **opts):
+        if a is None:
+            a = InverseMellinTransform._none_sentinel
+        if b is None:
+            b = InverseMellinTransform._none_sentinel
+        return IntegralTransform.__new__(cls, F, s, x, a, b, **opts)
+
+    @property
+    def fundamental_strip(self):
+        a, b = self.args[3], self.args[4]
+        if a is InverseMellinTransform._none_sentinel:
+            a = None
+        if b is InverseMellinTransform._none_sentinel:
+            b = None
+        return a, b
+
+    def _compute_transform(self, F, s, x, **hints):
+        # IntegralTransform's doit will cause this hint to exist, but
+        # InverseMellinTransform should ignore it
+        hints.pop('simplify', True)
+        global _allowed
+        if _allowed is None:
+            _allowed = {
+                exp, gamma, sin, cos, tan, cot, cosh, sinh, tanh, coth,
+                factorial, rf}
+        for f in postorder_traversal(F):
+            if f.is_Function and f.has(s) and f.func not in _allowed:
+                raise IntegralTransformError('Inverse Mellin', F,
+                                     'Component %s not recognised.' % f)
+        strip = self.fundamental_strip
+        return _inverse_mellin_transform(F, s, x, strip, **hints)
+
+    def _as_integral(self, F, s, x):
+        c = self.__class__._c
+        return Integral(F*x**(-s), (s, c - S.ImaginaryUnit*S.Infinity, c +
+                                    S.ImaginaryUnit*S.Infinity))/(2*S.Pi*S.ImaginaryUnit)
+
+
+def inverse_mellin_transform(F, s, x, strip, **hints):
+    r"""
+    Compute the inverse Mellin transform of `F(s)` over the fundamental
+    strip given by ``strip=(a, b)``.
+
+    Explanation
+    ===========
+
+    This can be defined as
+
+    .. math:: f(x) = \frac{1}{2\pi i} \int_{c - i\infty}^{c + i\infty} x^{-s} F(s) \mathrm{d}s,
+
+    for any `c` in the fundamental strip. Under certain regularity
+    conditions on `F` and/or `f`,
+    this recovers `f` from its Mellin transform `F`
+    (and vice versa), for positive real `x`.
+
+    One of `a` or `b` may be passed as ``None``; a suitable `c` will be
+    inferred.
+
+    If the integral cannot be computed in closed form, this function returns
+    an unevaluated :class:`InverseMellinTransform` object.
+
+    Note that this function will assume x to be positive and real, regardless
+    of the SymPy assumptions!
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+
+    Examples
+    ========
+
+    >>> from sympy import inverse_mellin_transform, oo, gamma
+    >>> from sympy.abc import x, s
+    >>> inverse_mellin_transform(gamma(s), s, x, (0, oo))
+    exp(-x)
+
+    The fundamental strip matters:
+
+    >>> f = 1/(s**2 - 1)
+    >>> inverse_mellin_transform(f, s, x, (-oo, -1))
+    x*(1 - 1/x**2)*Heaviside(x - 1)/2
+    >>> inverse_mellin_transform(f, s, x, (-1, 1))
+    -x*Heaviside(1 - x)/2 - Heaviside(x - 1)/(2*x)
+    >>> inverse_mellin_transform(f, s, x, (1, oo))
+    (1/2 - x**2/2)*Heaviside(1 - x)/x
+
+    See Also
+    ========
+
+    mellin_transform
+    hankel_transform, inverse_hankel_transform
+    """
+    return InverseMellinTransform(F, s, x, strip[0], strip[1]).doit(**hints)
+
+
+##########################################################################
+# Fourier Transform
+##########################################################################
+
+@_noconds_(True)
+def _fourier_transform(f, x, k, a, b, name, simplify=True):
+    r"""
+    Compute a general Fourier-type transform
+
+    .. math::
+
+        F(k) = a \int_{-\infty}^{\infty} e^{bixk} f(x)\, dx.
+
+    For suitable choice of *a* and *b*, this reduces to the standard Fourier
+    and inverse Fourier transforms.
+    """
+    F = integrate(a*f*exp(b*S.ImaginaryUnit*x*k), (x, S.NegativeInfinity, S.Infinity))
+
+    if not F.has(Integral):
+        return _simplify(F, simplify), S.true
+
+    integral_f = integrate(f, (x, S.NegativeInfinity, S.Infinity))
+    if integral_f in (S.NegativeInfinity, S.Infinity, S.NaN) or integral_f.has(Integral):
+        raise IntegralTransformError(name, f, 'function not integrable on real axis')
+
+    if not F.is_Piecewise:
+        raise IntegralTransformError(name, f, 'could not compute integral')
+
+    F, cond = F.args[0]
+    if F.has(Integral):
+        raise IntegralTransformError(name, f, 'integral in unexpected form')
+
+    return _simplify(F, simplify), cond
+
+
+class FourierTypeTransform(IntegralTransform):
+    """ Base class for Fourier transforms."""
+
+    def a(self):
+        raise NotImplementedError(
+            "Class %s must implement a(self) but does not" % self.__class__)
+
+    def b(self):
+        raise NotImplementedError(
+            "Class %s must implement b(self) but does not" % self.__class__)
+
+    def _compute_transform(self, f, x, k, **hints):
+        return _fourier_transform(f, x, k,
+                                  self.a(), self.b(),
+                                  self.__class__._name, **hints)
+
+    def _as_integral(self, f, x, k):
+        a = self.a()
+        b = self.b()
+        return Integral(a*f*exp(b*S.ImaginaryUnit*x*k), (x, S.NegativeInfinity, S.Infinity))
+
+
+class FourierTransform(FourierTypeTransform):
+    """
+    Class representing unevaluated Fourier transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute Fourier transforms, see the :func:`fourier_transform`
+    docstring.
+    """
+
+    _name = 'Fourier'
+
+    def a(self):
+        return 1
+
+    def b(self):
+        return -2*S.Pi
+
+
+def fourier_transform(f, x, k, **hints):
+    r"""
+    Compute the unitary, ordinary-frequency Fourier transform of ``f``, defined
+    as
+
+    .. math:: F(k) = \int_{-\infty}^\infty f(x) e^{-2\pi i x k} \mathrm{d} x.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`FourierTransform` object.
+
+    For other Fourier transform conventions, see the function
+    :func:`sympy.integrals.transforms._fourier_transform`.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import fourier_transform, exp
+    >>> from sympy.abc import x, k
+    >>> fourier_transform(exp(-x**2), x, k)
+    sqrt(pi)*exp(-pi**2*k**2)
+    >>> fourier_transform(exp(-x**2), x, k, noconds=False)
+    (sqrt(pi)*exp(-pi**2*k**2), True)
+
+    See Also
+    ========
+
+    inverse_fourier_transform
+    sine_transform, inverse_sine_transform
+    cosine_transform, inverse_cosine_transform
+    hankel_transform, inverse_hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return FourierTransform(f, x, k).doit(**hints)
+
+
+class InverseFourierTransform(FourierTypeTransform):
+    """
+    Class representing unevaluated inverse Fourier transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute inverse Fourier transforms, see the
+    :func:`inverse_fourier_transform` docstring.
+    """
+
+    _name = 'Inverse Fourier'
+
+    def a(self):
+        return 1
+
+    def b(self):
+        return 2*S.Pi
+
+
+def inverse_fourier_transform(F, k, x, **hints):
+    r"""
+    Compute the unitary, ordinary-frequency inverse Fourier transform of `F`,
+    defined as
+
+    .. math:: f(x) = \int_{-\infty}^\infty F(k) e^{2\pi i x k} \mathrm{d} k.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`InverseFourierTransform` object.
+
+    For other Fourier transform conventions, see the function
+    :func:`sympy.integrals.transforms._fourier_transform`.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import inverse_fourier_transform, exp, sqrt, pi
+    >>> from sympy.abc import x, k
+    >>> inverse_fourier_transform(sqrt(pi)*exp(-(pi*k)**2), k, x)
+    exp(-x**2)
+    >>> inverse_fourier_transform(sqrt(pi)*exp(-(pi*k)**2), k, x, noconds=False)
+    (exp(-x**2), True)
+
+    See Also
+    ========
+
+    fourier_transform
+    sine_transform, inverse_sine_transform
+    cosine_transform, inverse_cosine_transform
+    hankel_transform, inverse_hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return InverseFourierTransform(F, k, x).doit(**hints)
+
+
+##########################################################################
+# Fourier Sine and Cosine Transform
+##########################################################################
+
+@_noconds_(True)
+def _sine_cosine_transform(f, x, k, a, b, K, name, simplify=True):
+    """
+    Compute a general sine or cosine-type transform
+        F(k) = a int_0^oo b*sin(x*k) f(x) dx.
+        F(k) = a int_0^oo b*cos(x*k) f(x) dx.
+
+    For suitable choice of a and b, this reduces to the standard sine/cosine
+    and inverse sine/cosine transforms.
+    """
+    F = integrate(a*f*K(b*x*k), (x, S.Zero, S.Infinity))
+
+    if not F.has(Integral):
+        return _simplify(F, simplify), S.true
+
+    if not F.is_Piecewise:
+        raise IntegralTransformError(name, f, 'could not compute integral')
+
+    F, cond = F.args[0]
+    if F.has(Integral):
+        raise IntegralTransformError(name, f, 'integral in unexpected form')
+
+    return _simplify(F, simplify), cond
+
+
+class SineCosineTypeTransform(IntegralTransform):
+    """
+    Base class for sine and cosine transforms.
+    Specify cls._kern.
+    """
+
+    def a(self):
+        raise NotImplementedError(
+            "Class %s must implement a(self) but does not" % self.__class__)
+
+    def b(self):
+        raise NotImplementedError(
+            "Class %s must implement b(self) but does not" % self.__class__)
+
+
+    def _compute_transform(self, f, x, k, **hints):
+        return _sine_cosine_transform(f, x, k,
+                                      self.a(), self.b(),
+                                      self.__class__._kern,
+                                      self.__class__._name, **hints)
+
+    def _as_integral(self, f, x, k):
+        a = self.a()
+        b = self.b()
+        K = self.__class__._kern
+        return Integral(a*f*K(b*x*k), (x, S.Zero, S.Infinity))
+
+
+class SineTransform(SineCosineTypeTransform):
+    """
+    Class representing unevaluated sine transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute sine transforms, see the :func:`sine_transform`
+    docstring.
+    """
+
+    _name = 'Sine'
+    _kern = sin
+
+    def a(self):
+        return sqrt(2)/sqrt(pi)
+
+    def b(self):
+        return S.One
+
+
+def sine_transform(f, x, k, **hints):
+    r"""
+    Compute the unitary, ordinary-frequency sine transform of `f`, defined
+    as
+
+    .. math:: F(k) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty f(x) \sin(2\pi x k) \mathrm{d} x.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`SineTransform` object.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import sine_transform, exp
+    >>> from sympy.abc import x, k, a
+    >>> sine_transform(x*exp(-a*x**2), x, k)
+    sqrt(2)*k*exp(-k**2/(4*a))/(4*a**(3/2))
+    >>> sine_transform(x**(-a), x, k)
+    2**(1/2 - a)*k**(a - 1)*gamma(1 - a/2)/gamma(a/2 + 1/2)
+
+    See Also
+    ========
+
+    fourier_transform, inverse_fourier_transform
+    inverse_sine_transform
+    cosine_transform, inverse_cosine_transform
+    hankel_transform, inverse_hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return SineTransform(f, x, k).doit(**hints)
+
+
+class InverseSineTransform(SineCosineTypeTransform):
+    """
+    Class representing unevaluated inverse sine transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute inverse sine transforms, see the
+    :func:`inverse_sine_transform` docstring.
+    """
+
+    _name = 'Inverse Sine'
+    _kern = sin
+
+    def a(self):
+        return sqrt(2)/sqrt(pi)
+
+    def b(self):
+        return S.One
+
+
+def inverse_sine_transform(F, k, x, **hints):
+    r"""
+    Compute the unitary, ordinary-frequency inverse sine transform of `F`,
+    defined as
+
+    .. math:: f(x) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty F(k) \sin(2\pi x k) \mathrm{d} k.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`InverseSineTransform` object.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import inverse_sine_transform, exp, sqrt, gamma
+    >>> from sympy.abc import x, k, a
+    >>> inverse_sine_transform(2**((1-2*a)/2)*k**(a - 1)*
+    ...     gamma(-a/2 + 1)/gamma((a+1)/2), k, x)
+    x**(-a)
+    >>> inverse_sine_transform(sqrt(2)*k*exp(-k**2/(4*a))/(4*sqrt(a)**3), k, x)
+    x*exp(-a*x**2)
+
+    See Also
+    ========
+
+    fourier_transform, inverse_fourier_transform
+    sine_transform
+    cosine_transform, inverse_cosine_transform
+    hankel_transform, inverse_hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return InverseSineTransform(F, k, x).doit(**hints)
+
+
+class CosineTransform(SineCosineTypeTransform):
+    """
+    Class representing unevaluated cosine transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute cosine transforms, see the :func:`cosine_transform`
+    docstring.
+    """
+
+    _name = 'Cosine'
+    _kern = cos
+
+    def a(self):
+        return sqrt(2)/sqrt(pi)
+
+    def b(self):
+        return S.One
+
+
+def cosine_transform(f, x, k, **hints):
+    r"""
+    Compute the unitary, ordinary-frequency cosine transform of `f`, defined
+    as
+
+    .. math:: F(k) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty f(x) \cos(2\pi x k) \mathrm{d} x.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`CosineTransform` object.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import cosine_transform, exp, sqrt, cos
+    >>> from sympy.abc import x, k, a
+    >>> cosine_transform(exp(-a*x), x, k)
+    sqrt(2)*a/(sqrt(pi)*(a**2 + k**2))
+    >>> cosine_transform(exp(-a*sqrt(x))*cos(a*sqrt(x)), x, k)
+    a*exp(-a**2/(2*k))/(2*k**(3/2))
+
+    See Also
+    ========
+
+    fourier_transform, inverse_fourier_transform,
+    sine_transform, inverse_sine_transform
+    inverse_cosine_transform
+    hankel_transform, inverse_hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return CosineTransform(f, x, k).doit(**hints)
+
+
+class InverseCosineTransform(SineCosineTypeTransform):
+    """
+    Class representing unevaluated inverse cosine transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute inverse cosine transforms, see the
+    :func:`inverse_cosine_transform` docstring.
+    """
+
+    _name = 'Inverse Cosine'
+    _kern = cos
+
+    def a(self):
+        return sqrt(2)/sqrt(pi)
+
+    def b(self):
+        return S.One
+
+
+def inverse_cosine_transform(F, k, x, **hints):
+    r"""
+    Compute the unitary, ordinary-frequency inverse cosine transform of `F`,
+    defined as
+
+    .. math:: f(x) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty F(k) \cos(2\pi x k) \mathrm{d} k.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`InverseCosineTransform` object.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import inverse_cosine_transform, sqrt, pi
+    >>> from sympy.abc import x, k, a
+    >>> inverse_cosine_transform(sqrt(2)*a/(sqrt(pi)*(a**2 + k**2)), k, x)
+    exp(-a*x)
+    >>> inverse_cosine_transform(1/sqrt(k), k, x)
+    1/sqrt(x)
+
+    See Also
+    ========
+
+    fourier_transform, inverse_fourier_transform,
+    sine_transform, inverse_sine_transform
+    cosine_transform
+    hankel_transform, inverse_hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return InverseCosineTransform(F, k, x).doit(**hints)
+
+
+##########################################################################
+# Hankel Transform
+##########################################################################
+
+@_noconds_(True)
+def _hankel_transform(f, r, k, nu, name, simplify=True):
+    r"""
+    Compute a general Hankel transform
+
+    .. math:: F_\nu(k) = \int_{0}^\infty f(r) J_\nu(k r) r \mathrm{d} r.
+    """
+    F = integrate(f*besselj(nu, k*r)*r, (r, S.Zero, S.Infinity))
+
+    if not F.has(Integral):
+        return _simplify(F, simplify), S.true
+
+    if not F.is_Piecewise:
+        raise IntegralTransformError(name, f, 'could not compute integral')
+
+    F, cond = F.args[0]
+    if F.has(Integral):
+        raise IntegralTransformError(name, f, 'integral in unexpected form')
+
+    return _simplify(F, simplify), cond
+
+
+class HankelTypeTransform(IntegralTransform):
+    """
+    Base class for Hankel transforms.
+    """
+
+    def doit(self, **hints):
+        return self._compute_transform(self.function,
+                                       self.function_variable,
+                                       self.transform_variable,
+                                       self.args[3],
+                                       **hints)
+
+    def _compute_transform(self, f, r, k, nu, **hints):
+        return _hankel_transform(f, r, k, nu, self._name, **hints)
+
+    def _as_integral(self, f, r, k, nu):
+        return Integral(f*besselj(nu, k*r)*r, (r, S.Zero, S.Infinity))
+
+    @property
+    def as_integral(self):
+        return self._as_integral(self.function,
+                                 self.function_variable,
+                                 self.transform_variable,
+                                 self.args[3])
+
+
+class HankelTransform(HankelTypeTransform):
+    """
+    Class representing unevaluated Hankel transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute Hankel transforms, see the :func:`hankel_transform`
+    docstring.
+    """
+
+    _name = 'Hankel'
+
+
+def hankel_transform(f, r, k, nu, **hints):
+    r"""
+    Compute the Hankel transform of `f`, defined as
+
+    .. math:: F_\nu(k) = \int_{0}^\infty f(r) J_\nu(k r) r \mathrm{d} r.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`HankelTransform` object.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import hankel_transform, inverse_hankel_transform
+    >>> from sympy import exp
+    >>> from sympy.abc import r, k, m, nu, a
+
+    >>> ht = hankel_transform(1/r**m, r, k, nu)
+    >>> ht
+    2*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/(2**m*gamma(m/2 + nu/2))
+
+    >>> inverse_hankel_transform(ht, k, r, nu)
+    r**(-m)
+
+    >>> ht = hankel_transform(exp(-a*r), r, k, 0)
+    >>> ht
+    a/(k**3*(a**2/k**2 + 1)**(3/2))
+
+    >>> inverse_hankel_transform(ht, k, r, 0)
+    exp(-a*r)
+
+    See Also
+    ========
+
+    fourier_transform, inverse_fourier_transform
+    sine_transform, inverse_sine_transform
+    cosine_transform, inverse_cosine_transform
+    inverse_hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return HankelTransform(f, r, k, nu).doit(**hints)
+
+
+class InverseHankelTransform(HankelTypeTransform):
+    """
+    Class representing unevaluated inverse Hankel transforms.
+
+    For usage of this class, see the :class:`IntegralTransform` docstring.
+
+    For how to compute inverse Hankel transforms, see the
+    :func:`inverse_hankel_transform` docstring.
+    """
+
+    _name = 'Inverse Hankel'
+
+
+def inverse_hankel_transform(F, k, r, nu, **hints):
+    r"""
+    Compute the inverse Hankel transform of `F` defined as
+
+    .. math:: f(r) = \int_{0}^\infty F_\nu(k) J_\nu(k r) k \mathrm{d} k.
+
+    Explanation
+    ===========
+
+    If the transform cannot be computed in closed form, this
+    function returns an unevaluated :class:`InverseHankelTransform` object.
+
+    For a description of possible hints, refer to the docstring of
+    :func:`sympy.integrals.transforms.IntegralTransform.doit`.
+    Note that for this transform, by default ``noconds=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import hankel_transform, inverse_hankel_transform
+    >>> from sympy import exp
+    >>> from sympy.abc import r, k, m, nu, a
+
+    >>> ht = hankel_transform(1/r**m, r, k, nu)
+    >>> ht
+    2*k**(m - 2)*gamma(-m/2 + nu/2 + 1)/(2**m*gamma(m/2 + nu/2))
+
+    >>> inverse_hankel_transform(ht, k, r, nu)
+    r**(-m)
+
+    >>> ht = hankel_transform(exp(-a*r), r, k, 0)
+    >>> ht
+    a/(k**3*(a**2/k**2 + 1)**(3/2))
+
+    >>> inverse_hankel_transform(ht, k, r, 0)
+    exp(-a*r)
+
+    See Also
+    ========
+
+    fourier_transform, inverse_fourier_transform
+    sine_transform, inverse_sine_transform
+    cosine_transform, inverse_cosine_transform
+    hankel_transform
+    mellin_transform, laplace_transform
+    """
+    return InverseHankelTransform(F, k, r, nu).doit(**hints)
+
+
+##########################################################################
+# Laplace Transform
+##########################################################################
+
+# Stub classes and functions that used to be here
+import sympy.integrals.laplace as _laplace
+
+LaplaceTransform = _laplace.LaplaceTransform
+laplace_transform = _laplace.laplace_transform
+laplace_correspondence = _laplace.laplace_correspondence
+laplace_initial_conds = _laplace.laplace_initial_conds
+InverseLaplaceTransform = _laplace.InverseLaplaceTransform
+inverse_laplace_transform = _laplace.inverse_laplace_transform

parrot/lib/python3.10/site-packages/sympy/parsing/fortran/fortran_parser.py

@@ -0,0 +1,347 @@
+from sympy.external import import_module
+
+lfortran = import_module('lfortran')
+
+if lfortran:
+    from sympy.codegen.ast import (Variable, IntBaseType, FloatBaseType, String,
+                                   Return, FunctionDefinition, Assignment)
+    from sympy.core import Add, Mul, Integer, Float
+    from sympy.core.symbol import Symbol
+
+    asr_mod = lfortran.asr
+    asr = lfortran.asr.asr
+    src_to_ast = lfortran.ast.src_to_ast
+    ast_to_asr = lfortran.semantic.ast_to_asr.ast_to_asr
+
+    """
+    This module contains all the necessary Classes and Function used to Parse
+    Fortran code into SymPy expression
+
+    The module and its API are currently under development and experimental.
+    It is also dependent on LFortran for the ASR that is converted to SymPy syntax
+    which is also under development.
+    The module only supports the features currently supported by the LFortran ASR
+    which will be updated as the development of LFortran and this module progresses
+
+    You might find unexpected bugs and exceptions while using the module, feel free
+    to report them to the SymPy Issue Tracker
+
+    The API for the module might also change while in development if better and
+    more effective ways are discovered for the process
+
+    Features Supported
+    ==================
+
+    - Variable Declarations (integers and reals)
+    - Function Definitions
+    - Assignments and Basic Binary Operations
+
+
+    Notes
+    =====
+
+    The module depends on an external dependency
+
+    LFortran : Required to parse Fortran source code into ASR
+
+
+    References
+    ==========
+
+    .. [1] https://github.com/sympy/sympy/issues
+    .. [2] https://gitlab.com/lfortran/lfortran
+    .. [3] https://docs.lfortran.org/
+
+    """
+
+
+    class ASR2PyVisitor(asr.ASTVisitor):  # type: ignore
+        """
+        Visitor Class for LFortran ASR
+
+        It is a Visitor class derived from asr.ASRVisitor which visits all the
+        nodes of the LFortran ASR and creates corresponding AST node for each
+        ASR node
+
+        """
+
+        def __init__(self):
+            """Initialize the Parser"""
+            self._py_ast = []
+
+        def visit_TranslationUnit(self, node):
+            """
+            Function to visit all the elements of the Translation Unit
+            created by LFortran ASR
+            """
+            for s in node.global_scope.symbols:
+                sym = node.global_scope.symbols[s]
+                self.visit(sym)
+            for item in node.items:
+                self.visit(item)
+
+        def visit_Assignment(self, node):
+            """Visitor Function for Assignment
+
+            Visits each Assignment is the LFortran ASR and creates corresponding
+            assignment for SymPy.
+
+            Notes
+            =====
+
+            The function currently only supports variable assignment and binary
+            operation assignments of varying multitudes. Any type of numberS or
+            array is not supported.
+
+            Raises
+            ======
+
+            NotImplementedError() when called for Numeric assignments or Arrays
+
+            """
+            # TODO: Arithmetic Assignment
+            if isinstance(node.target, asr.Variable):
+                target = node.target
+                value = node.value
+                if isinstance(value, asr.Variable):
+                    new_node = Assignment(
+                            Variable(
+                                    target.name
+                                ),
+                            Variable(
+                                    value.name
+                                )
+                        )
+                elif (type(value) == asr.BinOp):
+                    exp_ast = call_visitor(value)
+                    for expr in exp_ast:
+                        new_node = Assignment(
+                                Variable(target.name),
+                                expr
+                            )
+                else:
+                    raise NotImplementedError("Numeric assignments not supported")
+            else:
+                raise NotImplementedError("Arrays not supported")
+            self._py_ast.append(new_node)
+
+        def visit_BinOp(self, node):
+            """Visitor Function for Binary Operations
+
+            Visits each binary operation present in the LFortran ASR like addition,
+            subtraction, multiplication, division and creates the corresponding
+            operation node in SymPy's AST
+
+            In case of more than one binary operations, the function calls the
+            call_visitor() function on the child nodes of the binary operations
+            recursively until all the operations have been processed.
+
+            Notes
+            =====
+
+            The function currently only supports binary operations with Variables
+            or other binary operations. Numerics are not supported as of yet.
+
+            Raises
+            ======
+
+            NotImplementedError() when called for Numeric assignments
+
+            """
+            # TODO: Integer Binary Operations
+            op = node.op
+            lhs = node.left
+            rhs = node.right
+
+            if (type(lhs) == asr.Variable):
+                left_value = Symbol(lhs.name)
+            elif(type(lhs) == asr.BinOp):
+                l_exp_ast = call_visitor(lhs)
+                for exp in l_exp_ast:
+                    left_value = exp
+            else:
+                raise NotImplementedError("Numbers Currently not supported")
+
+            if (type(rhs) == asr.Variable):
+                right_value = Symbol(rhs.name)
+            elif(type(rhs) == asr.BinOp):
+                r_exp_ast = call_visitor(rhs)
+                for exp in r_exp_ast:
+                    right_value = exp
+            else:
+                raise NotImplementedError("Numbers Currently not supported")
+
+            if isinstance(op, asr.Add):
+                new_node = Add(left_value, right_value)
+            elif isinstance(op, asr.Sub):
+                new_node = Add(left_value, -right_value)
+            elif isinstance(op, asr.Div):
+                new_node = Mul(left_value, 1/right_value)
+            elif isinstance(op, asr.Mul):
+                new_node = Mul(left_value, right_value)
+
+            self._py_ast.append(new_node)
+
+        def visit_Variable(self, node):
+            """Visitor Function for Variable Declaration
+
+            Visits each variable declaration present in the ASR and creates a
+            Symbol declaration for each variable
+
+            Notes
+            =====
+
+            The functions currently only support declaration of integer and
+            real variables. Other data types are still under development.
+
+            Raises
+            ======
+
+            NotImplementedError() when called for unsupported data types
+
+            """
+            if isinstance(node.type, asr.Integer):
+                var_type = IntBaseType(String('integer'))
+                value = Integer(0)
+            elif isinstance(node.type, asr.Real):
+                var_type = FloatBaseType(String('real'))
+                value = Float(0.0)
+            else:
+                raise NotImplementedError("Data type not supported")
+
+            if not (node.intent == 'in'):
+                new_node = Variable(
+                    node.name
+                ).as_Declaration(
+                    type = var_type,
+                    value = value
+                )
+                self._py_ast.append(new_node)
+
+        def visit_Sequence(self, seq):
+            """Visitor Function for code sequence
+
+            Visits a code sequence/ block and calls the visitor function on all the
+            children of the code block to create corresponding code in python
+
+            """
+            if seq is not None:
+                for node in seq:
+                    self._py_ast.append(call_visitor(node))
+
+        def visit_Num(self, node):
+            """Visitor Function for Numbers in ASR
+
+            This function is currently under development and will be updated
+            with improvements in the LFortran ASR
+
+            """
+            # TODO:Numbers when the LFortran ASR is updated
+            # self._py_ast.append(Integer(node.n))
+            pass
+
+        def visit_Function(self, node):
+            """Visitor Function for function Definitions
+
+            Visits each function definition present in the ASR and creates a
+            function definition node in the Python AST with all the elements of the
+            given function
+
+            The functions declare all the variables required as SymPy symbols in
+            the function before the function definition
+
+            This function also the call_visior_function to parse the contents of
+            the function body
+
+            """
+            # TODO: Return statement, variable declaration
+            fn_args = [Variable(arg_iter.name) for arg_iter in node.args]
+            fn_body = []
+            fn_name = node.name
+            for i in node.body:
+                fn_ast = call_visitor(i)
+            try:
+                fn_body_expr = fn_ast
+            except UnboundLocalError:
+                fn_body_expr = []
+            for sym in node.symtab.symbols:
+                decl = call_visitor(node.symtab.symbols[sym])
+                for symbols in decl:
+                    fn_body.append(symbols)
+            for elem in fn_body_expr:
+                fn_body.append(elem)
+            fn_body.append(
+                Return(
+                    Variable(
+                        node.return_var.name
+                    )
+                )
+            )
+            if isinstance(node.return_var.type, asr.Integer):
+                ret_type = IntBaseType(String('integer'))
+            elif isinstance(node.return_var.type, asr.Real):
+                ret_type = FloatBaseType(String('real'))
+            else:
+                raise NotImplementedError("Data type not supported")
+            new_node = FunctionDefinition(
+                        return_type = ret_type,
+                        name = fn_name,
+                        parameters = fn_args,
+                        body = fn_body
+                    )
+            self._py_ast.append(new_node)
+
+        def ret_ast(self):
+            """Returns the AST nodes"""
+            return self._py_ast
+else:
+    class ASR2PyVisitor():  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError('lfortran not available')
+
+def call_visitor(fort_node):
+    """Calls the AST Visitor on the Module
+
+    This function is used to call the AST visitor for a program or module
+    It imports all the required modules and calls the visit() function
+    on the given node
+
+    Parameters
+    ==========
+
+    fort_node : LFortran ASR object
+        Node for the operation for which the NodeVisitor is called
+
+    Returns
+    =======
+
+    res_ast : list
+        list of SymPy AST Nodes
+
+    """
+    v = ASR2PyVisitor()
+    v.visit(fort_node)
+    res_ast = v.ret_ast()
+    return res_ast
+
+
+def src_to_sympy(src):
+    """Wrapper function to convert the given Fortran source code to SymPy Expressions
+
+    Parameters
+    ==========
+
+    src : string
+        A string with the Fortran source code
+
+    Returns
+    =======
+
+    py_src : string
+        A string with the Python source code compatible with SymPy
+
+    """
+    a_ast = src_to_ast(src, translation_unit=False)
+    a = ast_to_asr(a_ast)
+    py_src = call_visitor(a)
+    return py_src

parrot/lib/python3.10/site-packages/sympy/strategies/__init__.py

@@ -0,0 +1,50 @@
+""" Rewrite Rules
+
+DISCLAIMER: This module is experimental. The interface is subject to change.
+
+A rule is a function that transforms one expression into another
+
+    Rule :: Expr -> Expr
+
+A strategy is a function that says how a rule should be applied to a syntax
+tree. In general strategies take rules and produce a new rule
+
+    Strategy :: [Rules], Other-stuff -> Rule
+
+This allows developers to separate a mathematical transformation from the
+algorithmic details of applying that transformation. The goal is to separate
+the work of mathematical programming from algorithmic programming.
+
+Submodules
+
+strategies.rl         - some fundamental rules
+strategies.core       - generic non-SymPy specific strategies
+strategies.traverse   - strategies that traverse a SymPy tree
+strategies.tools      - some conglomerate strategies that do depend on SymPy
+"""
+
+from . import rl
+from . import traverse
+from .rl import rm_id, unpack, flatten, sort, glom, distribute, rebuild
+from .util import new
+from .core import (
+    condition, debug, chain, null_safe, do_one, exhaust, minimize, tryit)
+from .tools import canon, typed
+from . import branch
+
+__all__ = [
+    'rl',
+
+    'traverse',
+
+    'rm_id', 'unpack', 'flatten', 'sort', 'glom', 'distribute', 'rebuild',
+
+    'new',
+
+    'condition', 'debug', 'chain', 'null_safe', 'do_one', 'exhaust',
+    'minimize', 'tryit',
+
+    'canon', 'typed',
+
+    'branch',
+]

parrot/lib/python3.10/site-packages/sympy/strategies/branch/__init__.py

@@ -0,0 +1,14 @@
+from . import traverse
+from .core import (
+    condition, debug, multiplex, exhaust, notempty,
+    chain, onaction, sfilter, yieldify, do_one, identity)
+from .tools import canon
+
+__all__ = [
+    'traverse',
+
+    'condition', 'debug', 'multiplex', 'exhaust', 'notempty', 'chain',
+    'onaction', 'sfilter', 'yieldify', 'do_one', 'identity',
+
+    'canon',
+]