passagemath-symbolics 10.6.40__cp314-cp314t-macosx_13_0_x86_64.whl

sage/symbolic/benchmark.py

@@ -0,0 +1,93 @@
+# sage_setup: distribution = sagemath-symbolics
+r"""
+Benchmarks
+
+Tests that will take a long time if something is wrong, but be very
+quick otherwise.  See https://wiki.sagemath.org/symbench.  The
+parameters chosen below are such that with pynac most of these take
+well less than a second, but would not even be feasible using Sage's
+Maxima-based symbolics.
+
+Problem R1
+
+Important note. Below we do s.expand().real() because s.real() takes forever (TODO?). ::
+
+    sage: f(z) = sqrt(1/3)*z^2 + i/3
+    sage: s = f(f(f(f(f(f(f(f(f(f(i/2))))))))))
+    sage: s.expand().real()
+    -15323490199844318074242473679071410934833494247466385771803570370858961112774390851798166656796902695599442662754502211584226105508648298600018090510170430216881977761279503642801008178271982531042720727178135881702924595044672634313417239327304576652633321095875724771887486594852083526001648217317718794685379391946143663292907934545842931411982264788766619812559999515408813796287448784343854980686798782575952258163992236113752353237705088451481168691158059505161807961082162315225057299394348203539002582692884735745377391416638540520323363224931163680324690025802009761307137504963304640835891588925883135078996398616361571065941964628043214890356454145039464055430143/160959987592246947739944859375773744043416001841910423046466880402863187009126824419781711398533250016237703449459397319370100476216445123130147322940019839927628599479294678599689928643570237983736966305423831947366332466878486992676823215303312139985015592974537721140932243906832125049776934072927576666849331956351862828567668505777388133331284248870175178634054430823171923639987569211668426477739974572402853248951261366399284257908177157179099041115431335587887276292978004143353025122721401971549897673882099546646236790739903146970578001092018346524464799146331225822142880459202800229013082033028722077703362360159827236163041299500992177627657014103138377287073792*sqrt(1/3)
+
+
+Problem R2::
+
+    sage: def hermite(n, y):
+    ....:     if n == 1: return 2*y
+    ....:     if n == 0: return 1
+    ....:     return expand(2*y*hermite(n-1,y) - 2*(n-1)*hermite(n-2,y))
+    sage: hermite(15,var('y'))
+    32768*y^15 - 1720320*y^13 + 33546240*y^11 - 307507200*y^9 + 1383782400*y^7 - 2905943040*y^5 + 2421619200*y^3 - 518918400*y
+
+Problem R3::
+
+    sage: f = sum(var('x,y,z')); a = [bool(f==f) for _ in range(100000)]
+
+Problem R4::
+
+    sage: u = [e,pi,sqrt(2)]; Tuples(u,3).cardinality()
+    27
+
+Problem R5::
+
+    sage: def blowup(L, n):
+    ....:    for i in [0..n]:
+    ....:        L.append( (L[i] + L[i+1]) * L[i+2] )
+    sage: L = list(var('x,y,z'))
+    sage: blowup(L,15)
+    sage: len(set(L))
+    19
+
+Problem R6::
+
+    sage: sum(((x+sin(i))/x+(x-sin(i))/x) for i in range(100)).expand()
+    200
+
+Problem R7::
+
+    sage: f = x^24+34*x^12+45*x^3+9*x^18 +34*x^10+ 32*x^21
+    sage: a = [f(x=random()) for _ in range(10^4)]
+
+Problem R10::
+
+    sage: v = [float(z) for z in [-pi,-pi+1/100..,pi]]
+
+Problem R11::
+
+    sage: a = [random() + random()*I for w in [0..100]]
+    sage: a.sort()
+
+Problem W3::
+
+    sage: acos(cos(x))
+    arccos(cos(x))
+
+PROBLEM S1::
+
+    sage: _ = var('x,y,z')
+    sage: f = (x+y+z+1)^10
+    sage: g = expand(f*(f+1))
+
+PROBLEM S2::
+
+    sage: _ = var('x,y')
+    sage: a = expand((x^sin(x) + y^cos(y) - z^(x+y))^100)
+
+PROBLEM S3::
+
+    sage: _ = var('x,y,z')
+    sage: f = expand((x^y + y^z + z^x)^50)
+    sage: g = f.diff(x)
+
+PROBLEM S4::
+
+    sage: w = (sin(x)*cos(x)).series(x,400)
+"""

sage/symbolic/callable.py

@@ -0,0 +1,459 @@
+# sage_setup: distribution = sagemath-symbolics
+"""
+Callable Symbolic Expressions
+
+EXAMPLES:
+
+When you do arithmetic with::
+
+    sage: f(x, y, z) = sin(x+y+z)
+    sage: g(x, y) = y + 2*x
+    sage: f + g
+    (x, y, z) |--> 2*x + y + sin(x + y + z)
+
+::
+
+    sage: f(x, y, z) = sin(x+y+z)
+    sage: g(w, t) = cos(w - t)
+    sage: f + g
+    (t, w, x, y, z) |--> cos(-t + w) + sin(x + y + z)
+
+::
+
+    sage: f(x, y, t) = y*(x^2-t)
+    sage: g(x, y, w) = x + y - cos(w)
+    sage: f*g
+    (x, y, t, w) |--> (x^2 - t)*(x + y - cos(w))*y
+
+::
+
+    sage: f(x,y, t) = x+y
+    sage: g(x, y, w) = w + t
+    sage: f + g
+    (x, y, t, w) |--> t + w + x + y
+
+TESTS:
+
+The arguments in the definition must be symbolic variables (:issue:`10747`)::
+
+    sage: f(1)=2
+    Traceback (most recent call last):
+    ...
+    SyntaxError: can...t assign to function call...
+
+    sage: f(x,1)=2
+    Traceback (most recent call last):
+    ...
+    SyntaxError: can...t assign to function call...
+
+    sage: f(1,2)=3
+    Traceback (most recent call last):
+    ...
+    SyntaxError: can...t assign to function call...
+
+    sage: f(1,2)=x
+    Traceback (most recent call last):
+    ...
+    SyntaxError: can...t assign to function call...
+
+    sage: f(x,2)=x
+    Traceback (most recent call last):
+    ...
+    SyntaxError: can...t assign to function call...
+"""
+import sage.rings.abc
+from sage.symbolic.ring import SymbolicRing, SR
+from sage.categories.pushout import ConstructionFunctor
+from sage.structure.factory import UniqueFactory
+
+
+######################################################################
+#  Callable functions
+######################################################################
+
+class CallableSymbolicExpressionFunctor(ConstructionFunctor):
+    def __init__(self, arguments):
+        """
+        A functor which produces a CallableSymbolicExpressionRing from
+        the SymbolicRing.
+
+        EXAMPLES::
+
+            sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
+            sage: x,y = var('x,y')
+            sage: f = CallableSymbolicExpressionFunctor((x,y)); f
+            CallableSymbolicExpressionFunctor(x, y)
+            sage: f(SR)
+            Callable function ring with arguments (x, y)
+
+            sage: loads(dumps(f))
+            CallableSymbolicExpressionFunctor(x, y)
+        """
+        self._arguments = arguments
+        from sage.categories.rings import Rings
+        self.rank = 3
+        ConstructionFunctor.__init__(self, Rings(), Rings())
+
+    def __repr__(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
+            sage: x,y = var('x,y')
+            sage: CallableSymbolicExpressionFunctor((x,y))
+            CallableSymbolicExpressionFunctor(x, y)
+        """
+        return "CallableSymbolicExpressionFunctor%s" % repr(self.arguments())
+
+    def merge(self, other):
+        """
+        EXAMPLES::
+
+            sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
+            sage: x,y = var('x,y')
+            sage: a = CallableSymbolicExpressionFunctor((x,))
+            sage: b = CallableSymbolicExpressionFunctor((y,))
+            sage: a.merge(b)
+            CallableSymbolicExpressionFunctor(x, y)
+        """
+        arguments = self.unify_arguments(other)
+        return CallableSymbolicExpressionFunctor(arguments)
+
+    def __call__(self, R):
+        """
+        EXAMPLES::
+
+            sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
+            sage: x,y = var('x,y')
+            sage: a = CallableSymbolicExpressionFunctor((x,y))
+            sage: a(SR)
+            Callable function ring with arguments (x, y)
+        """
+        if R is not SR:
+            raise ValueError("can only make callable symbolic expression rings from the Symbolic Ring")
+        return CallableSymbolicExpressionRing(self.arguments())
+
+    def arguments(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
+            sage: x,y = var('x,y')
+            sage: a = CallableSymbolicExpressionFunctor((x,y))
+            sage: a.arguments()
+            (x, y)
+        """
+        return self._arguments
+
+    def unify_arguments(self, x):
+        r"""
+        Take the variable list from another ``CallableSymbolicExpression``
+        object and compare it with the current ``CallableSymbolicExpression``
+        object's variable list, combining them according to the following rules:
+
+        Let ``a`` be ``self``'s variable list, let ``b`` be ``y``'s
+        variable list.
+
+        #. If ``a == b``, then the variable lists are
+           identical, so return that variable list.
+
+        #. If ``a`` `\neq` ``b``, then check if the first `n` items in
+           ``a`` are the first `n` items in ``b``, or vice versa. If
+           so, return a list with these `n` items, followed by the
+           remaining items in ``a`` and ``b`` sorted together in
+           alphabetical order.
+
+
+        .. NOTE::
+
+           When used for arithmetic between
+           ``CallableSymbolicExpression``'s, these rules ensure that
+           the set of ``CallableSymbolicExpression``'s will have
+           certain properties. In particular, it ensures that the set
+           is a *commutative* ring, i.e., the order of the input
+           variables is the same no matter in which order arithmetic
+           is done.
+
+        INPUT:
+
+        - ``x`` -- a ``CallableSymbolicExpression``
+
+        OUTPUT: a tuple of variables
+
+        EXAMPLES::
+
+            sage: from sage.symbolic.callable import CallableSymbolicExpressionFunctor
+            sage: x,y = var('x,y')
+            sage: a = CallableSymbolicExpressionFunctor((x,))
+            sage: b = CallableSymbolicExpressionFunctor((y,))
+            sage: a.unify_arguments(b)
+            (x, y)
+
+        AUTHORS:
+
+        - Bobby Moretti: thanks to William Stein for the rules
+        """
+        a = self.arguments()
+        b = x.arguments()
+
+        # Rule #1
+        if [str(y) for y in a] == [str(z) for z in b]:
+            return a
+
+        # Rule #2
+        new_list = []
+        done = False
+        i = 0
+        while not done and i < min(len(a), len(b)):
+            if repr(a[i]) == repr(b[i]):
+                new_list.append(a[i])
+                i += 1
+            else:
+                done = True
+
+        temp = set()
+        # Sorting remaining variables.
+        for j in range(i, len(a)):
+            if a[j] not in temp:
+                temp.add(a[j])
+
+        for j in range(i, len(b)):
+            if b[j] not in temp:
+                temp.add(b[j])
+
+        new_list.extend(sorted(temp, key=repr))
+        return tuple(new_list)
+
+
+class CallableSymbolicExpressionRing_class(SymbolicRing, sage.rings.abc.CallableSymbolicExpressionRing):
+    def __init__(self, arguments):
+        """
+        EXAMPLES:
+
+        We verify that coercion works in the case where ``x`` is not an
+        instance of SymbolicExpression, but its parent is still the
+        SymbolicRing::
+
+            sage: f(x) = 1
+            sage: f*e
+            x |--> e
+
+        TESTS::
+
+            sage: TestSuite(f.parent()).run(skip=['_test_divides'])
+        """
+        self._arguments = arguments
+        SymbolicRing.__init__(self, SR)
+        self._populate_coercion_lists_(coerce_list=[SR])
+        self.symbols = SR.symbols  # Use the same list of symbols as SR
+
+    def _coerce_map_from_(self, R):
+        """
+        EXAMPLES::
+
+            sage: f(x,y) = x^2 + y
+            sage: g(x,y,z) = x + y + z
+            sage: f.parent().has_coerce_map_from(g.parent())
+            False
+            sage: g.parent().has_coerce_map_from(f.parent())
+            True
+        """
+        if isinstance(R, CallableSymbolicExpressionRing_class):
+            args = self.arguments()
+            if all(a in args for a in R.arguments()):
+                return True
+            else:
+                return False
+        return SymbolicRing._coerce_map_from_(self, R)
+
+    def construction(self):
+        """
+        EXAMPLES::
+
+            sage: f(x,y) = x^2 + y
+            sage: f.parent().construction()
+            (CallableSymbolicExpressionFunctor(x, y), Symbolic Ring)
+        """
+        return (CallableSymbolicExpressionFunctor(self.arguments()), SR)
+
+    def _element_constructor_(self, x):
+        """
+        TESTS::
+
+            sage: f(x) = x+1; g(y) = y+1
+            sage: f.parent()(g)
+            x |--> y + 1
+            sage: g.parent()(f)
+            y |--> x + 1
+            sage: f(x) = x+2*y; g(y) = y+3*x
+            sage: f.parent()(g)
+            x |--> 3*x + y
+            sage: g.parent()(f)
+            y |--> x + 2*y
+        """
+        return SymbolicRing._element_constructor_(self, x)
+
+    def _repr_(self):
+        """
+        String representation of ring of callable symbolic expressions.
+
+        EXAMPLES::
+
+            sage: R = CallableSymbolicExpressionRing(var('x,y,theta'))
+            sage: R._repr_()
+            'Callable function ring with arguments (x, y, theta)'
+
+        We verify that :issue:`12298` has been fixed::
+
+            sage: S = CallableSymbolicExpressionRing([var('z')])
+            sage: S._repr_()
+            'Callable function ring with argument z'
+        """
+        if len(self._arguments) == 0:
+            return "Callable function ring with no named arguments"
+        elif len(self._arguments) == 1:
+            return "Callable function ring with argument {}".format(self._arguments[0])
+        else:
+            return "Callable function ring with arguments {}".format(self._arguments)
+
+    def arguments(self):
+        """
+        Return the arguments of ``self``.
+
+        The order that the variables appear in ``self.arguments()`` is
+        the order that is used in evaluating the elements of ``self``.
+
+        EXAMPLES::
+
+            sage: x,y = var('x,y')
+            sage: f(x,y) = 2*x+y
+            sage: f.parent().arguments()
+            (x, y)
+            sage: f(y,x) = 2*x+y
+            sage: f.parent().arguments()
+            (y, x)
+        """
+        return self._arguments
+
+    args = arguments
+
+    def _repr_element_(self, x):
+        """
+        Return the string representation of the Expression ``x``.
+
+        EXAMPLES::
+
+            sage: f(y,x) = x + y
+            sage: f
+            (y, x) |--> x + y
+            sage: f.parent()
+            Callable function ring with arguments (y, x)
+        """
+        args = self.arguments()
+        repr_x = SymbolicRing._repr_element_(self, x)
+        if len(args) == 1:
+            return "%s |--> %s" % (args[0], repr_x)
+        else:
+            args = ", ".join(map(str, args))
+            return "(%s) |--> %s" % (args, repr_x)
+
+    def _latex_element_(self, x):
+        r"""
+        Finds the LaTeX representation of this expression.
+
+        EXAMPLES::
+
+            sage: f(A, t, omega, psi) = A*cos(omega*t - psi)
+            sage: f._latex_()
+            '\\left( A, t, \\omega, \\psi \\right) \\ {\\mapsto} \\ A \\cos\\left(\\omega t - \\psi\\right)'
+
+            sage: f(mu) =  mu^3
+            sage: f._latex_()
+            '\\mu \\ {\\mapsto}\\ \\mu^{3}'
+        """
+        from sage.misc.latex import latex
+        args = self.args()
+        args = [latex(arg) for arg in args]
+        latex_x = SymbolicRing._latex_element_(self, x)
+        if len(args) == 1:
+            return r"%s \ {\mapsto}\ %s" % (args[0], latex_x)
+        else:
+            vars = ", ".join(args)
+            return r"\left( %s \right) \ {\mapsto} \ %s" % (vars, latex_x)
+
+    def _call_element_(self, _the_element, *args, **kwds):
+        """
+        Calling a callable symbolic expression returns a symbolic expression
+        with the appropriate arguments substituted.
+
+        EXAMPLES::
+
+            sage: var('a, x, y, z')
+            (a, x, y, z)
+            sage: f(x,y) = a + 2*x + 3*y + z
+            sage: f
+            (x, y) |--> a + 2*x + 3*y + z
+            sage: f(1,2)
+            a + z + 8
+            sage: f(y=2, a=-1)
+            2*x + z + 5
+
+        Note that keyword arguments will override the regular arguments.
+        ::
+
+
+            sage: f.arguments()
+            (x, y)
+            sage: f(1,2)
+            a + z + 8
+            sage: f(10,2)
+            a + z + 26
+            sage: f(10,2,x=1)
+            a + z + 8
+            sage: f(z=100)
+            a + 2*x + 3*y + 100
+        """
+        if any(type(arg).__module__ == 'numpy' and type(arg).__name__ == "ndarray" for arg in args):  # avoid importing
+            raise NotImplementedError("Numpy arrays are not supported as arguments for symbolic expressions")
+
+        d = dict(zip([repr(_) for _ in self.arguments()], args))
+        d.update(kwds)
+        return SR(_the_element.substitute(**d))
+
+    # __reduce__ gets replaced by the CallableSymbolicExpressionRingFactory
+    __reduce__ = object.__reduce__
+
+
+class CallableSymbolicExpressionRingFactory(UniqueFactory):
+    def create_key(self, args, check=True):
+        """
+        EXAMPLES::
+
+            sage: x,y = var('x,y')
+            sage: CallableSymbolicExpressionRing.create_key((x,y))
+            (x, y)
+        """
+        if check:
+            from sage.structure.element import Expression
+            if len(args) == 1 and isinstance(args[0], (list, tuple)):
+                args, = args
+            for arg in args:
+                if not (isinstance(arg, Expression) and arg.is_symbol()):
+                    raise TypeError("must construct a function with a tuple (or list) of variables")
+            args = tuple(args)
+        return args
+
+    def create_object(self, version, key, **extra_args):
+        """
+        Return a CallableSymbolicExpressionRing given a version and a key.
+
+        EXAMPLES::
+
+            sage: x,y = var('x,y')
+            sage: CallableSymbolicExpressionRing.create_object(0, (x, y))
+            Callable function ring with arguments (x, y)
+        """
+        return CallableSymbolicExpressionRing_class(key)
+
+
+CallableSymbolicExpressionRing = CallableSymbolicExpressionRingFactory('sage.symbolic.callable.CallableSymbolicExpressionRing')

sage/symbolic/complexity_measures.py

@@ -0,0 +1,35 @@
+# sage_setup: distribution = sagemath-symbolics
+"""
+Complexity Measures
+
+Some measures of symbolic expression complexity. Each complexity
+measure is expected to take a symbolic expression as an argument, and
+return a number.
+"""
+
+
+def string_length(expr):
+    """
+    Return the length of ``expr`` after converting it to a string.
+
+    INPUT:
+
+    - ``expr`` -- the expression whose complexity we want to measure
+
+    OUTPUT: a real number representing the complexity of ``expr``
+
+    RATIONALE:
+
+    If the expression is longer on-screen, then a human would probably
+    consider it more complex.
+
+    EXAMPLES:
+
+    This expression has three characters, ``x``, ``^``, and ``2``::
+
+        sage: from sage.symbolic.complexity_measures import string_length
+        sage: f = x^2
+        sage: string_length(f)
+        3
+    """
+    return len(str(expr))