passagemath-symbolics 10.6.43__cp314-cp314t-musllinux_1_2_x86_64.whl

sage/symbolic/function_factory.py

@@ -0,0 +1,355 @@
+# sage_setup: distribution = sagemath-symbolics
+r"""
+Factory for symbolic functions
+"""
+
+###############################################################################
+#   Sage: Open Source Mathematical Software
+#       Copyright (C) 2009 Burcin Erocal <burcin@erocal.org>
+#  Distributed under the terms of the GNU General Public License (GPL),
+#  version 2 or any later version.  The full text of the GPL is available at:
+#                  https://www.gnu.org/licenses/
+###############################################################################
+from __future__ import annotations
+
+from sage.symbolic.function import (SymbolicFunction, sfunctions_funcs,
+                                    unpickle_wrapper)
+
+
+def function_factory(name, nargs=0, latex_name=None, conversions=None,
+            evalf_params_first=True, eval_func=None, evalf_func=None,
+            conjugate_func=None, real_part_func=None, imag_part_func=None,
+            derivative_func=None, tderivative_func=None, power_func=None,
+            series_func=None, print_func=None, print_latex_func=None):
+    r"""
+    Create a formal symbolic function. For an explanation of the arguments see
+    the documentation for the method :meth:`function`.
+
+    EXAMPLES::
+
+        sage: from sage.symbolic.function_factory import function_factory
+        sage: f = function_factory('f', 2, '\\foo', {'mathematica':'Foo'})
+        sage: f(2,4)
+        f(2, 4)
+        sage: latex(f(1,2))
+        \foo\left(1, 2\right)
+        sage: f._mathematica_init_()
+        'Foo'
+
+        sage: def evalf_f(self, x, parent=None, algorithm=None): return x*.5r
+        sage: g = function_factory('g',1,evalf_func=evalf_f)
+        sage: g(2)
+        g(2)
+        sage: g(2).n()
+        1.00000000000000
+    """
+    class NewSymbolicFunction(SymbolicFunction):
+        def __init__(self):
+            """
+            EXAMPLES::
+
+                sage: from sage.symbolic.function_factory import function_factory
+                sage: f = function_factory('f', 2) # indirect doctest
+                sage: f(2,4)
+                f(2, 4)
+            """
+            SymbolicFunction.__init__(self, name, nargs, latex_name,
+                    conversions, evalf_params_first)
+
+        def _maxima_init_(self):
+            """
+            EXAMPLES::
+
+                sage: from sage.symbolic.function_factory import function_factory
+                sage: f = function_factory('f', 2) # indirect doctest
+                sage: f._maxima_init_()
+                "'f"
+            """
+            return "'%s" % self.name()
+
+        def _fricas_init_(self):
+            """
+            Return the FriCAS equivalent of a formal function.
+
+            Note that the arity is ignored.
+
+            EXAMPLES::
+
+                sage: from sage.symbolic.function_factory import function_factory
+                sage: f = function_factory('f', 2) # indirect doctest
+                sage: f._fricas_init_()
+                'operator("f")'
+            """
+            return 'operator("%s")' % self.name()
+
+        def _sympy_(self):
+            from sympy import Function
+            return Function(self.name())
+
+        def __reduce__(self):
+            """
+            EXAMPLES::
+
+                sage: from sage.symbolic.function_factory import function_factory
+                sage: f = function_factory('f', 2) # indirect doctest
+                sage: nf = loads(dumps(f))
+                sage: nf(1, 2)
+                f(1, 2)
+            """
+            pickled_functions = self.__getstate__()[6]
+            return (unpickle_function, (name, nargs, latex_name, conversions,
+                evalf_params_first, pickled_functions))
+
+    l = locals()
+    for func_name in sfunctions_funcs:
+        func = l.get(func_name+"_func", None)
+        if func:
+            if not callable(func):
+                raise ValueError(func_name + "_func" + " parameter must be callable")
+            setattr(NewSymbolicFunction, '_%s_' % func_name, func)
+
+    return NewSymbolicFunction()
+
+
+def unpickle_function(name, nargs, latex_name, conversions, evalf_params_first,
+        pickled_funcs):
+    r"""
+    This is returned by the ``__reduce__`` method of symbolic functions to be
+    called during unpickling to recreate the given function.
+
+    It calls :meth:`function_factory` with the supplied arguments.
+
+    EXAMPLES::
+
+        sage: from sage.symbolic.function_factory import unpickle_function
+        sage: nf = unpickle_function('f', 2, '\\foo', {'mathematica':'Foo'}, True, [])
+        sage: nf
+        f
+        sage: nf(1,2)
+        f(1, 2)
+        sage: latex(nf(x,x))
+        \foo\left(x, x\right)
+        sage: nf._mathematica_init_()
+        'Foo'
+
+        sage: from sage.symbolic.function import pickle_wrapper
+        sage: def evalf_f(self, x, parent=None, algorithm=None): return 2r*x + 5r
+        sage: def conjugate_f(self, x): return x/2r
+        sage: nf = unpickle_function('g', 1, None, None, True, [None, pickle_wrapper(evalf_f), pickle_wrapper(conjugate_f)] + [None]*8)
+        sage: nf
+        g
+        sage: nf(2)
+        g(2)
+        sage: nf(2).n()
+        9.00000000000000
+        sage: nf(2).conjugate()
+        1
+    """
+    funcs = [unpickle_wrapper(_) for _ in pickled_funcs]
+    args = [name, nargs, latex_name, conversions, evalf_params_first] + funcs
+    return function_factory(*args)
+
+
+def function(s, **kwds) -> SymbolicFunction | list[SymbolicFunction]:
+    r"""
+    Create a formal symbolic function with the name *s*.
+
+    INPUT:
+
+    - ``nargs=0`` -- number of arguments the function accepts, defaults to
+      variable number of arguments, or 0
+    - ``latex_name`` -- name used when printing in latex mode
+    - ``conversions`` -- dictionary specifying names of this function in
+      other systems, this is used by the interfaces internally during conversion
+    - ``eval_func`` -- method used for automatic evaluation
+    - ``evalf_func`` -- method used for numeric evaluation
+    - ``evalf_params_first`` -- boolean to indicate if parameters should be
+      evaluated numerically before calling the custom evalf function
+    - ``conjugate_func`` -- method used for complex conjugation
+    - ``real_part_func`` -- method used when taking real parts
+    - ``imag_part_func`` -- method used when taking imaginary parts
+    - ``derivative_func`` -- method to be used for (partial) derivation
+      This method should take a keyword argument deriv_param specifying
+      the index of the argument to differentiate w.r.t
+    - ``tderivative_func`` -- method to be used for derivatives
+    - ``power_func`` -- method used when taking powers
+      This method should take a keyword argument power_param specifying
+      the exponent
+    - ``series_func`` -- method used for series expansion
+      This method should expect keyword arguments
+      - ``order`` -- order for the expansion to be computed
+      - ``var`` -- variable to expand w.r.t.
+      - ``at`` -- expand at this value
+    - ``print_func`` -- method for custom printing
+    - ``print_latex_func`` -- method for custom printing in latex mode
+
+    Note that custom methods must be instance methods, i.e., expect the instance
+    of the symbolic function as the first argument.
+
+    EXAMPLES::
+
+        sage: from sage.symbolic.function_factory import function
+        sage: var('a, b')
+        (a, b)
+        sage: cr = function('cr')
+        sage: f = cr(a)
+        sage: g = f.diff(a).integral(b); g
+        b*diff(cr(a), a)
+        sage: foo = function("foo", nargs=2)
+        sage: x,y,z = var("x y z")
+        sage: foo(x, y) + foo(y, z)^2
+        foo(y, z)^2 + foo(x, y)
+
+    You need to use :meth:`substitute_function` to
+    replace all occurrences of a function with another::
+
+        sage: g.substitute_function(cr, cos)
+        -b*sin(a)
+
+        sage: g.substitute_function(cr, (sin(x) + cos(x)).function(x))
+        b*(cos(a) - sin(a))
+
+    Basic arithmetic with unevaluated functions is no
+    longer supported::
+
+        sage: x = var('x')
+        sage: f = function('f')
+        sage: 2*f
+        Traceback (most recent call last):
+        ...
+        TypeError: unsupported operand parent(s) for *: 'Integer Ring' and
+        '<class 'sage.symbolic.function_factory...NewSymbolicFunction'>'
+
+    You now need to evaluate the function in order to do the arithmetic::
+
+        sage: 2*f(x)
+        2*f(x)
+
+
+    We create a formal function of one variable, write down
+    an expression that involves first and second derivatives,
+    and extract off coefficients.
+
+    ::
+
+        sage: r, kappa = var('r,kappa')
+        sage: psi = function('psi', nargs=1)(r); psi
+        psi(r)
+        sage: g = 1/r^2*(2*r*psi.derivative(r,1) + r^2*psi.derivative(r,2)); g
+        (r^2*diff(psi(r), r, r) + 2*r*diff(psi(r), r))/r^2
+        sage: g.expand()
+        2*diff(psi(r), r)/r + diff(psi(r), r, r)
+        sage: g.coefficient(psi.derivative(r,2))
+        1
+        sage: g.coefficient(psi.derivative(r,1))
+        2/r
+
+    Defining custom methods for automatic or numeric evaluation, derivation,
+    conjugation, etc. is supported::
+
+        sage: def ev(self, x): return 2*x
+        sage: foo = function("foo", nargs=1, eval_func=ev)
+        sage: foo(x)
+        2*x
+        sage: foo = function("foo", nargs=1, eval_func=lambda self, x: 5)
+        sage: foo(x)
+        5
+        sage: def ef(self, x): pass
+        sage: bar = function("bar", nargs=1, eval_func=ef)
+        sage: bar(x)
+        bar(x)
+
+        sage: def evalf_f(self, x, parent=None, algorithm=None): return 6
+        sage: foo = function("foo", nargs=1, evalf_func=evalf_f)
+        sage: foo(x)
+        foo(x)
+        sage: foo(x).n()
+        6
+
+        sage: foo = function("foo", nargs=1, conjugate_func=ev)
+        sage: foo(x).conjugate()
+        2*x
+
+        sage: def deriv(self, *args, **kwds):
+        ....:     print("{} {}".format(args, kwds))
+        ....:     return args[kwds['diff_param']]^2
+        sage: foo = function("foo", nargs=2, derivative_func=deriv)
+        sage: foo(x,y).derivative(y)
+        (x, y) {'diff_param': 1}
+        y^2
+
+        sage: def pow(self, x, power_param=None):
+        ....:     print("{} {}".format(x, power_param))
+        ....:     return x*power_param
+        sage: foo = function("foo", nargs=1, power_func=pow)
+        sage: foo(y)^(x+y)
+        y x + y
+        (x + y)*y
+
+        sage: def expand(self, *args, **kwds):
+        ....:     print("{} {}".format(args, sorted(kwds.items())))
+        ....:     return sum(args[0]^i for i in range(kwds['order']))
+        sage: foo = function("foo", nargs=1, series_func=expand)
+        sage: foo(y).series(y, 5)
+        (y,) [('at', 0), ('options', 0), ('order', 5), ('var', y)]
+        y^4 + y^3 + y^2 + y + 1
+
+        sage: def my_print(self, *args): return "my args are: " + ', '.join(map(repr, args))
+        sage: foo = function('t', nargs=2, print_func=my_print)
+        sage: foo(x,y^z)
+        my args are: x, y^z
+
+        sage: latex(foo(x,y^z))
+        t\left(x, y^{z}\right)
+        sage: foo = function('t', nargs=2, print_latex_func=my_print)
+        sage: foo(x,y^z)
+        t(x, y^z)
+        sage: latex(foo(x,y^z))
+        my args are: x, y^z
+        sage: foo = function('t', nargs=2, latex_name='foo')
+        sage: latex(foo(x,y^z))
+        foo\left(x, y^{z}\right)
+
+    Chain rule::
+
+        sage: def print_args(self, *args, **kwds): print("args: {}".format(args)); print("kwds: {}".format(kwds)); return args[0]
+        sage: foo = function('t', nargs=2, tderivative_func=print_args)
+        sage: foo(x,x).derivative(x)
+        args: (x, x)
+        kwds: {'diff_param': x}
+        x
+        sage: foo = function('t', nargs=2, derivative_func=print_args)
+        sage: foo(x,x).derivative(x)
+        args: (x, x)
+        kwds: {'diff_param': 0}
+        args: (x, x)
+        kwds: {'diff_param': 1}
+        2*x
+
+    TESTS:
+
+    Make sure that :issue:`15860` is fixed and whitespaces are removed::
+
+        sage: C, D, E = function(' C  D E')
+        sage: C(D(x))
+        C(D(x))
+        sage: E
+        E
+    """
+    if not isinstance(s, str):
+        raise TypeError("expect string as first argument")
+
+    # create the function or functions
+    if ',' in s:
+        names = s.split(',')
+    elif ' ' in s:
+        names = s.split(' ')
+    else:
+        names = [s]
+    names = [sn.strip() for sn in names if sn.strip()]
+
+    funcs = tuple(function_factory(name, **kwds) for name in names)
+
+    if len(funcs) == 1:
+        return funcs[0]
+    return funcs

sage/symbolic/integration/all.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-symbolics

sage/symbolic/integration/external.py

@@ -0,0 +1,270 @@
+# sage_setup: distribution = sagemath-symbolics
+"""Symbolic Integration via External Software
+
+TESTS::
+
+    sage: from sage.symbolic.integration.external import sympy_integrator
+    sage: sympy_integrator(sin(x), x)                                                   # needs sympy
+    -cos(x)
+"""
+from sage.symbolic.expression import Expression
+from sage.symbolic.ring import SR
+
+
+def maxima_integrator(expression, v, a=None, b=None):
+    """
+    Integration using Maxima.
+
+    EXAMPLES::
+
+        sage: from sage.symbolic.integration.external import maxima_integrator
+        sage: maxima_integrator(sin(x), x)
+        -cos(x)
+        sage: maxima_integrator(cos(x), x)
+        sin(x)
+        sage: f(x) = function('f')(x)
+        sage: maxima_integrator(f(x), x)
+        integrate(f(x), x)
+
+    TESTS:
+
+    Check that :issue:`25817` is fixed::
+
+        sage: maxima_integrator(log(e^x*log(x)*sin(x))/x^2, x)
+        1/2*(x*(Ei(-log(x)) + conjugate(Ei(-log(x))))
+        - 2*x*integrate(sin(x)/(x*cos(x)^2 + x*sin(x)^2
+        + 2*x*cos(x) + x), x) + 2*x*integrate(sin(x)/(x*cos(x)^2
+        + x*sin(x)^2 - 2*x*cos(x) + x), x) + 2*x*log(x) + 2*log(2)
+        - log(cos(x)^2 + sin(x)^2 + 2*cos(x) + 1) - log(cos(x)^2
+        + sin(x)^2 - 2*cos(x) + 1) - 2*log(log(x)))/x
+    """
+    from sage.calculus.calculus import maxima
+    if not isinstance(expression, Expression):
+        expression = SR(expression)
+    if a is None:
+        result = maxima.sr_integral(expression, v)
+    else:
+        result = maxima.sr_integral(expression, v, a, b)
+    return result._sage_()
+
+
+def sympy_integrator(expression, v, a=None, b=None):
+    """
+    Integration using SymPy.
+
+    EXAMPLES::
+
+        sage: from sage.symbolic.integration.external import sympy_integrator
+        sage: sympy_integrator(sin(x), x)                                               # needs sympy
+        -cos(x)
+        sage: sympy_integrator(cos(x), x)                                               # needs sympy
+        sin(x)
+    """
+    import sympy
+    ex = expression._sympy_()
+    v = v._sympy_()
+    if a is None:
+        result = sympy.integrate(ex, v)
+    else:
+        result = sympy.integrate(ex, (v, a._sympy_(), b._sympy_()))
+    return result._sage_()
+
+
+def mma_free_integrator(expression, v, a=None, b=None):
+    """
+    Integration using Mathematica's online integrator.
+
+    EXAMPLES::
+
+        sage: from sage.symbolic.integration.external import mma_free_integrator
+        sage: mma_free_integrator(sin(x), x) # optional - internet
+        -cos(x)
+
+    A definite integral::
+
+        sage: mma_free_integrator(e^(-x), x, a=0, b=oo) # optional - internet
+        1
+
+    TESTS:
+
+    Check that :issue:`18212` is resolved::
+
+        sage: var('y')   # optional - internet
+        y
+        sage: result = integral(sin(y)^2, y, algorithm='mathematica_free') # optional - internet
+        sage: result.simplify_trig()               # optional - internet
+        -1/2*cos(y)*sin(y) + 1/2*y
+
+    Check that :issue:`14764` is resolved::
+
+        sage: integrate(x^2, x, 0, 1, algorithm='mathematica_free') # optional - internet
+        1/3
+        sage: integrate(sin(x), [x, 0, pi], algorithm='mathematica_free') # optional - internet
+        2
+        sage: integrate(sqrt(x), (x, 0, 1), algorithm='mathematica_free') # optional - internet
+        2/3
+
+    ::
+
+        sage: mma_free_integrator(exp(-x^2)*log(x), x) # optional - internet
+        1/2*sqrt(pi)*erf(x)*log(x) - x*hypergeometric((1/2, 1/2), (3/2, 3/2), -x^2)
+    """
+    from sage.interfaces.mathematica import request_wolfram_alpha, parse_moutput_from_json, symbolic_expression_from_mathematica_string
+    math_expr = expression._mathematica_init_()
+    variable = v._mathematica_init_()
+    if a is None and b is None:
+        input = "Integrate[{},{}]".format(math_expr, variable)
+    elif a is not None and b is not None:
+        input = "Integrate[{},{{{},{},{}}}]".format(math_expr, variable,
+                                                    a._mathematica_init_(),
+                                                    b._mathematica_init_())
+    else:
+        raise ValueError('a(={}) and b(={}) should be both None'
+                         ' or both defined'.format(a, b))
+    json_page_data = request_wolfram_alpha(input)
+    all_outputs = parse_moutput_from_json(json_page_data)
+    if not all_outputs:
+        raise ValueError("no outputs found in the answer from Wolfram Alpha")
+    first_output = all_outputs[0]
+    return symbolic_expression_from_mathematica_string(first_output)
+
+
+def fricas_integrator(expression, v, a=None, b=None, noPole=True):
+    """
+    Integration using FriCAS.
+
+    EXAMPLES::
+
+        sage: # optional - fricas
+        sage: from sage.symbolic.integration.external import fricas_integrator
+        sage: fricas_integrator(sin(x), x)
+        -cos(x)
+        sage: fricas_integrator(cos(x), x)
+        sin(x)
+        sage: fricas_integrator(1/(x^2-2), x, 0, 1)
+        -1/8*sqrt(2)*(log(2) - log(-24*sqrt(2) + 34))
+        sage: fricas_integrator(1/(x^2+6), x, -oo, oo)
+        1/6*sqrt(6)*pi
+
+    TESTS:
+
+    Check that :issue:`25220` is fixed::
+
+        sage: integral(sqrt(1-cos(x)), x, 0, 2*pi, algorithm='fricas')          # optional - fricas
+        4*sqrt(2)
+
+    Check that in case of failure one gets unevaluated integral::
+
+        sage: integral(cos(ln(cos(x))), x, 0, pi/8, algorithm='fricas')         # optional - fricas
+        integrate(cos(log(cos(x))), x, 0, 1/8*pi)
+
+        sage: integral(cos(ln(cos(x))), x, algorithm='fricas')                  # optional - fricas
+        integral(cos(log(cos(x))), x)
+
+    Check that :issue:`28641` is fixed::
+
+        sage: integrate(sqrt(2)*x^2 + 2*x, x, algorithm='fricas')               # optional - fricas
+        1/3*sqrt(2)*x^3 + x^2
+
+        sage: integrate(sqrt(2), x, algorithm='fricas')                         # optional - fricas
+        sqrt(2)*x
+
+        sage: integrate(1, x, algorithm='fricas')                               # optional - fricas
+        x
+
+    Check that :issue:`28630` is fixed::
+
+        sage: f = polylog(3, x)
+        sage: f.integral(x, algorithm='fricas')                                 # optional - fricas
+        -x*dilog(x) - (x - 1)*log(-x + 1) + x*polylog(3, x) + x
+
+    Check that :issue:`29043` is fixed::
+
+        sage: var("a c d"); f = (I*a*tan(d*x + c) + a)*sec(d*x + c)^10
+        (a, c, d)
+        sage: ii = integrate(f, x, algorithm='fricas')                               # optional - fricas
+        sage: 1/315*(64512*I*a*e^(10*I*d*x + 10*I*c) + 53760*I*a*e^(8*I*d*x + 8*I*c) + 30720*I*a*e^(6*I*d*x + 6*I*c) + 11520*I*a*e^(4*I*d*x + 4*I*c) + 2560*I*a*e^(2*I*d*x + 2*I*c) + 256*I*a)/(d*e^(20*I*d*x + 20*I*c) + 10*d*e^(18*I*d*x + 18*I*c) + 45*d*e^(16*I*d*x + 16*I*c) + 120*d*e^(14*I*d*x + 14*I*c) + 210*d*e^(12*I*d*x + 12*I*c) + 252*d*e^(10*I*d*x + 10*I*c) + 210*d*e^(8*I*d*x + 8*I*c) + 120*d*e^(6*I*d*x + 6*I*c) + 45*d*e^(4*I*d*x + 4*I*c) + 10*d*e^(2*I*d*x + 2*I*c) + d) - ii                        # optional - fricas
+        0
+    """
+    if not isinstance(expression, Expression):
+        expression = SR(expression)
+
+    from sage.interfaces.fricas import fricas
+    e_fricas = fricas(expression)
+    v_fricas = fricas(v)
+
+    if a is None:
+        result = e_fricas.integrate(v_fricas)
+    else:
+        seg = fricas.equation(v_fricas, fricas.segment(a, b))
+
+        if noPole:
+            result = e_fricas.integrate(seg, '"noPole"')
+        else:
+            result = e_fricas.integrate(seg)
+
+    result = result.sage()
+
+    if result == "failed":
+        result = expression.integrate(v, a, b, hold=True)
+
+    elif result == "potentialPole":
+        raise ValueError("The integrand has a potential pole"
+                         " in the integration interval")
+
+    return result
+
+
+def libgiac_integrator(expression, v, a=None, b=None):
+    r"""
+    Integration using libgiac.
+
+    EXAMPLES::
+
+        sage: # needs sage.libs.giac
+        sage: import sage.libs.giac
+        ...
+        sage: from sage.symbolic.integration.external import libgiac_integrator
+        sage: libgiac_integrator(sin(x), x)
+        -cos(x)
+        sage: libgiac_integrator(1/(x^2+6), x, -oo, oo)
+        1/6*sqrt(6)*pi
+
+    TESTS::
+
+        sage: # needs sage.libs.giac
+        sage: libgiac_integrator(e^(-x^2)*log(x), x)
+        integrate(e^(-x^2)*log(x), x)
+
+    The following integral fails with the Giac Pexpect interface, but works
+    with libgiac (:issue:`31873`)::
+
+        sage: # needs sage.libs.giac
+        sage: a, x = var('a,x')
+        sage: f = sec(2*a*x)
+        sage: F = libgiac_integrator(f, x)
+        ...
+        sage: (F.derivative(x) - f).simplify_trig()
+        0
+    """
+    try:
+        from sage.libs.giac import libgiac
+    except ImportError:
+        # If libgiac isn't available, return a symbolic answer
+        # (without actually integrating anything). This is essentially
+        # the failure case of any integration: see below for what we
+        # do if libgiac is *available* but unable to do much.
+        return expression.integrate(v, a, b, hold=True)
+
+    from sage.libs.giac.giac import Pygen
+    # We call Pygen on first argument because otherwise some
+    # expressions involving derivatives result in doctest failures in
+    # sage/interfaces/sympy.py
+    if a is None:
+        result = libgiac.integrate(Pygen(expression), v)
+    else:
+        result = libgiac.integrate(Pygen(expression), v, a, b)
+    if 'integrate' in format(result) or 'integration' in format(result):
+        return expression.integrate(v, a, b, hold=True)
+    else:
+        return result.sage()