passagemath-symbolics 10.6.40__cp314-cp314t-macosx_13_0_x86_64.whl

sage/modules/all__sagemath_symbolics.py

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

sage/modules/vector_callable_symbolic_dense.py

@@ -0,0 +1,105 @@
+# sage_setup: distribution = sagemath-symbolics
+"""
+Vectors over callable symbolic rings
+
+AUTHOR:
+
+- Jason Grout (2010)
+
+EXAMPLES::
+
+    sage: f(r, theta, z) = (r*cos(theta), r*sin(theta), z)
+    sage: f.parent()
+    Vector space of dimension 3 over Callable function ring with arguments (r, theta, z)
+    sage: f
+    (r, theta, z) |--> (r*cos(theta), r*sin(theta), z)
+    sage: f[0]
+    (r, theta, z) |--> r*cos(theta)
+    sage: f+f
+    (r, theta, z) |--> (2*r*cos(theta), 2*r*sin(theta), 2*z)
+    sage: 3*f
+    (r, theta, z) |--> (3*r*cos(theta), 3*r*sin(theta), 3*z)
+    sage: f*f # dot product
+    (r, theta, z) |--> r^2*cos(theta)^2 + r^2*sin(theta)^2 + z^2
+    sage: f.diff()(0,1,2) # the matrix derivative
+    [cos(1)      0      0]
+    [sin(1)      0      0]
+    [     0      0      1]
+
+
+TESTS::
+
+    sage: f(u,v,w) = (2*u+v,u-w,w^2+u)
+    sage: loads(dumps(f)) == f
+    True
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2010 Jason Grout <jason-sage@creativetrax.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.modules import free_module_element
+from sage.symbolic.ring import SR
+
+
+class Vector_callable_symbolic_dense(free_module_element.FreeModuleElement_generic_dense):
+    def _repr_(self):
+        """
+        Return the string representation of the vector.
+
+        EXAMPLES::
+
+            sage: f(u,v,w) = (2*u+v,u-w,w^2+u)
+            sage: f
+            (u, v, w) |--> (2*u + v, u - w, w^2 + u)
+            sage: r(t) = (cos(t), sin(t))
+            sage: r
+            t |--> (cos(t), sin(t))
+        """
+        ring = self.coordinate_ring()
+        args = ring.arguments()
+        repr_x = self.change_ring(SR)._repr_()
+        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_(self):
+        r"""
+        Return the latex representation of the vector.
+
+        EXAMPLES::
+
+            sage: f(u,v,w) = (2*u+v,u-w,w^2+u)
+            sage: f
+            (u, v, w) |--> (2*u + v, u - w, w^2 + u)
+            sage: latex(f)
+            \left( u, v, w \right) \ {\mapsto} \ \left(2 \, u + v,\,u - w,\,w^{2} + u\right)
+            sage: r(t) = (cos(t), sin(t))
+            sage: r
+            t |--> (cos(t), sin(t))
+            sage: latex(r)
+            t \ {\mapsto}\ \left(\cos\left(t\right),\,\sin\left(t\right)\right)
+        """
+        from sage.misc.latex import latex
+        ring = self.coordinate_ring()
+        args = ring.arguments()
+        args = [latex(arg) for arg in args]
+        latex_x = self.change_ring(SR)._latex_()
+        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)

sage/modules/vector_symbolic_dense.py

@@ -0,0 +1,116 @@
+# sage_setup: distribution = sagemath-symbolics
+"""
+Dense vectors over the symbolic ring
+
+Implements dense vectors over the symbolic ring.
+
+AUTHORS:
+
+- Robert Bradshaw (2011-05-25): Added more element-wise simplification methods
+
+- Joris Vankerschaver (2011-05-15): Initial version
+
+EXAMPLES::
+
+    sage: x, y = var('x, y')
+    sage: u = vector([sin(x)^2 + cos(x)^2, log(2*y) + log(3*y)]); u
+    (cos(x)^2 + sin(x)^2, log(3*y) + log(2*y))
+    sage: type(u)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: u.simplify_full()
+    (1, log(3*y) + log(2*y))
+
+TESTS:
+
+Check that the outcome of arithmetic with symbolic vectors is again
+a symbolic vector (:issue:`11549`)::
+
+    sage: v = vector(SR, [1, 2])
+    sage: w = vector(SR, [sin(x), 0])
+    sage: type(v)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(w)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(v + w)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(-v)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(5*w)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+
+Test pickling/unpickling::
+
+    sage: u = vector(SR, [sin(x^2)])
+    sage: loads(dumps(u)) == u
+    True
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2011 Joris Vankerschaver (jv@caltech.edu)
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.modules import free_module_element
+from sage.symbolic.expression import Expression
+
+
+def apply_map(phi):
+    """
+    Return a function that applies ``phi`` to its argument.
+
+    EXAMPLES::
+
+        sage: from sage.modules.vector_symbolic_dense import apply_map
+        sage: v = vector([1,2,3])
+        sage: f = apply_map(lambda x: x+1)
+        sage: f(v)
+        (2, 3, 4)
+    """
+    def apply(self, *args, **kwds):
+        """
+        Generic function used to implement common symbolic operations
+        elementwise as methods of a vector.
+
+        EXAMPLES::
+
+            sage: var('x,y')
+            (x, y)
+            sage: v = vector([sin(x)^2 + cos(x)^2, log(x*y), sin(x/(x^2 + x)), factorial(x+1)/factorial(x)])
+            sage: v.simplify_trig()
+            (1, log(x*y), sin(1/(x + 1)), factorial(x + 1)/factorial(x))
+            sage: v.canonicalize_radical()
+            (cos(x)^2 + sin(x)^2, log(x) + log(y), sin(1/(x + 1)), factorial(x + 1)/factorial(x))
+            sage: v.simplify_rational()
+            (cos(x)^2 + sin(x)^2, log(x*y), sin(1/(x + 1)), factorial(x + 1)/factorial(x))
+            sage: v.simplify_factorial()
+            (cos(x)^2 + sin(x)^2, log(x*y), sin(x/(x^2 + x)), x + 1)
+            sage: v.simplify_full()
+            (1, log(x*y), sin(1/(x + 1)), x + 1)
+
+            sage: v = vector([sin(2*x), sin(3*x)])
+            sage: v.simplify_trig()
+            (2*cos(x)*sin(x), (4*cos(x)^2 - 1)*sin(x))
+            sage: v.simplify_trig(False)
+            (sin(2*x), sin(3*x))
+            sage: v.simplify_trig(expand=False)
+            (sin(2*x), sin(3*x))
+        """
+        return self.apply_map(lambda x: phi(x, *args, **kwds))
+    apply.__doc__ += "\nSee Expression." + phi.__name__ + "() for optional arguments."
+    return apply
+
+
+class Vector_symbolic_dense(free_module_element.FreeModuleElement_generic_dense):
+    pass
+
+
+# Add elementwise methods.
+for method in ['simplify', 'simplify_factorial',
+               'simplify_log', 'simplify_rational',
+               'simplify_trig', 'simplify_full', 'trig_expand',
+               'canonicalize_radical', 'trig_reduce']:
+    setattr(Vector_symbolic_dense, method, apply_map(getattr(Expression, method)))

sage/modules/vector_symbolic_sparse.py

@@ -0,0 +1,118 @@
+# sage_setup: distribution = sagemath-symbolics
+"""
+Sparse vectors over the symbolic ring
+
+Implements vectors over the symbolic ring.
+
+AUTHORS:
+
+- Robert Bradshaw (2011-05-25): Added more element-wise simplification methods
+
+- Joris Vankerschaver (2011-05-15): Initial version
+
+- Dima Pasechnik (2023-06-04): cloning from the dense case
+
+EXAMPLES::
+
+    sage: x, y = var('x, y')
+    sage: u = vector([sin(x)^2 + cos(x)^2, log(2*y) + log(3*y)], sparse=True); u
+    (cos(x)^2 + sin(x)^2, log(3*y) + log(2*y))
+    sage: type(u)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: u.simplify_full()
+    (1, log(3*y) + log(2*y))
+
+TESTS:
+
+Check that the outcome of arithmetic with symbolic vectors is again
+a symbolic vector (:issue:`11549`)::
+
+    sage: v = vector(SR, [1, 2], sparse=True)
+    sage: w = vector(SR, [sin(x), 0], sparse=True)
+    sage: type(v)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(w)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(v + w)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(-v)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+    sage: type(5*w)
+    <class 'sage.modules.free_module.FreeModule_ambient_field_with_category.element_class'>
+
+Test pickling/unpickling::
+
+    sage: u = vector(SR, [sin(x^2)], sparse=True)
+    sage: loads(dumps(u)) == u
+    True
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2011 Joris Vankerschaver (jv@caltech.edu)
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.modules import free_module_element
+from sage.symbolic.expression import Expression
+
+
+def apply_map(phi):
+    """
+    Return a function that applies ``phi`` to its argument.
+
+    EXAMPLES::
+
+        sage: from sage.modules.vector_symbolic_sparse import apply_map
+        sage: v = vector([1,2,3], sparse=True)
+        sage: f = apply_map(lambda x: x+1)
+        sage: f(v)
+        (2, 3, 4)
+    """
+    def apply(self, *args, **kwds):
+        """
+        Generic function used to implement common symbolic operations
+        elementwise as methods of a vector.
+
+        EXAMPLES::
+
+            sage: var('x,y')
+            (x, y)
+            sage: v = vector([sin(x)^2 + cos(x)^2, log(x*y), sin(x/(x^2 + x)), factorial(x+1)/factorial(x)], sparse=True)
+            sage: v.simplify_trig()
+            (1, log(x*y), sin(1/(x + 1)), factorial(x + 1)/factorial(x))
+            sage: v.canonicalize_radical()
+            (cos(x)^2 + sin(x)^2, log(x) + log(y), sin(1/(x + 1)), factorial(x + 1)/factorial(x))
+            sage: v.simplify_rational()
+            (cos(x)^2 + sin(x)^2, log(x*y), sin(1/(x + 1)), factorial(x + 1)/factorial(x))
+            sage: v.simplify_factorial()
+            (cos(x)^2 + sin(x)^2, log(x*y), sin(x/(x^2 + x)), x + 1)
+            sage: v.simplify_full()
+            (1, log(x*y), sin(1/(x + 1)), x + 1)
+
+            sage: v = vector([sin(2*x), sin(3*x)], sparse=True)
+            sage: v.simplify_trig()
+            (2*cos(x)*sin(x), (4*cos(x)^2 - 1)*sin(x))
+            sage: v.simplify_trig(False)
+            (sin(2*x), sin(3*x))
+            sage: v.simplify_trig(expand=False)
+            (sin(2*x), sin(3*x))
+        """
+        return self.apply_map(lambda x: phi(x, *args, **kwds))
+    apply.__doc__ += "\nSee Expression." + phi.__name__ + "() for optional arguments."
+    return apply
+
+
+class Vector_symbolic_sparse(free_module_element.FreeModuleElement_generic_sparse):
+    pass
+
+
+# Add elementwise methods.
+for method in ['simplify', 'simplify_factorial',
+               'simplify_log', 'simplify_rational',
+               'simplify_trig', 'simplify_full', 'trig_expand',
+               'canonicalize_radical', 'trig_reduce']:
+    setattr(Vector_symbolic_sparse, method, apply_map(getattr(Expression, method)))

sage/rings/all__sagemath_symbolics.py

@@ -0,0 +1,4 @@
+# sage_setup: distribution = sagemath-symbolics
+from sage.rings.all__sagemath_modules import *
+
+from sage.rings.asymptotic.all import *

sage/rings/asymptotic/all.py

@@ -0,0 +1,6 @@
+# sage_setup: distribution = sagemath-symbolics
+from sage.misc.lazy_import import lazy_import
+lazy_import('sage.rings.asymptotic.asymptotic_ring', 'AsymptoticRing')
+lazy_import('sage.rings.asymptotic.asymptotic_expansion_generators',
+            'asymptotic_expansions')
+del lazy_import