passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/misc/citation.pyx

@@ -0,0 +1,159 @@
+# sage_setup: distribution = sagemath-categories
+# cython: old_style_globals=True
+"""
+Dependency usage tracking for citations
+"""
+
+from sage.misc.temporary_file import tmp_filename
+from sage.env import SAGE_LOCAL, SAGE_VENV
+
+systems = {}
+systems['PARI'] = ['cypari2', 'sage.interfaces.gp']
+systems['Singular'] = ['sage.interfaces.singular', '_libsingular',
+                       'sage.libs.singular']
+systems['Maxima'] = ['sage.interfaces.maxima']
+systems['GAP'] = ['sage.interfaces.gap']
+systems['Magma'] = ['sage.interfaces.magma', 'sage.interfaces.magma_free']
+systems['Axiom'] = ['sage.interfaces.axiom']
+systems['ECM'] = ['sage.interfaces.ecm']
+systems['scipy'] = ['scipy']
+systems['numpy'] = ['numpy']
+systems['ginac'] = ['sage.symbolic']
+systems['Maple'] = ['sage.interfaces.maple']
+systems['Mathematica'] = ['sage.interfaces.mathematica']
+systems['MuPAD'] = ['sage.interfaces.mupad']
+systems['Octave'] = ['sage.interfaces.octave']
+systems['povray'] = ['sage.interfaces.povray']
+systems['Macaulay2'] = ['sage.interfaces.macaulay2']
+systems['mwrank'] = ['sage.interfaces.mwrank', 'sage.libs.eclib']
+systems['matlab'] = ['sage.interfaces.matlab']
+systems['LiE'] = ['sage.interfaces.lie']
+systems['Tachyon'] = ['sage.interfaces.tachyon']
+systems['Frobby'] = ['sage.interfaces.frobby']
+systems['gfan'] = ['sage.interfaces.gfan']
+systems['R'] = ['sage.interfaces.r']
+systems['KASH'] = ['sage.interfaces.kash']
+systems['Linbox'] = ['sage.libs.linbox']
+systems['Symmetrica'] = ['sage.libs.symmetrica']
+systems['NTL'] = ['sage.libs.ntl',
+                  'sage.rings.finite_rings.element_ntl_gf2e']
+systems['FLINT'] = ['_flint']
+systems['GMP'] = ['sage.rings.integer.Integer']
+systems['MPFR'] = ['sage.rings.real_mpfr',
+                   'sage.rings.complex_mpfr']
+systems['MPFI'] = ['sage.rings.real_mpfi',
+                   'sage.rings.complex_interval']
+systems['M4RI'] = ['sage.matrix.matrix_mod2_dense']
+systems['Givaro'] = ['sage.rings.finite_rings.element_givaro']
+systems['PolyBoRi'] = ['sage.rings.polynomial.pbori.pbori']
+
+
+def get_systems(cmd):
+    """
+    Return a list of the systems used in running the command ``cmd``.
+
+    Note that the results can sometimes include systems that did not
+    actually contribute to the computation. Due to caching, it
+    could miss some dependencies as well.
+
+    INPUT:
+
+    - ``cmd`` -- string to run
+
+    .. WARNING::
+
+        In order to properly support Cython code, this requires that
+        Sage was compiled with the environment variable
+        ``SAGE_PROFILE=yes``. If this was not the case, a warning will
+        be given when calling this function.
+
+    EXAMPLES::
+
+        sage: from sage.misc.citation import get_systems
+        sage: get_systems('print("hello")')  # random (may print warning)
+        []
+        sage: integrate(x^2, x)  # Priming coercion model                               # needs sage.symbolic
+        1/3*x^3
+        sage: get_systems('integrate(x^2, x)')                                          # needs sage.symbolic
+        ['Maxima', 'ginac']
+        sage: R.<x,y,z> = QQ[]
+        sage: I = R.ideal(x^2 + y^2, z^2 + y)
+        sage: get_systems('I.primary_decomposition()')                                  # needs sage.libs.singular
+        ['Singular']
+    """
+    import cProfile
+    import pstats
+    import re
+
+    if not cython_profile_enabled():
+        from warnings import warn
+        warn("get_systems() requires Cython profiling to be enabled, "
+             "otherwise the results will be very unreliable. "
+             "Rebuild Sage with the environment variable 'SAGE_PROFILE=yes' "
+             "to enable profiling.")
+
+    if not isinstance(cmd, str):
+        raise TypeError("command must be a string")
+
+    from sage.repl.preparse import preparse
+    cmd = preparse(cmd)
+
+    # Run the command and get the stats
+    filename = tmp_filename()
+    cProfile.runctx(cmd, globals(), {}, filename)
+    stats = pstats.Stats(filename)
+
+    # Strings is a list of method names and modules which get run
+    def string_from_stat(a):
+        s = a[0]
+        if SAGE_LOCAL:
+            s = s.replace(SAGE_LOCAL, "")
+        if SAGE_VENV:
+            s = s.replace(SAGE_VENV, "")
+        return s + " " + a[2]
+
+    strings = [string_from_stat(a)
+               for a in stats.stats]
+
+    # Remove trivial functions
+    bad_res = [re.compile(r'is_.*Element'), re.compile("is_[a-z_]*_type")]
+    for bad_re in bad_res:
+        i = 0
+        while i < len(strings):
+            if bad_re.findall(strings[i]):
+                strings.pop(i)
+            else:
+                i += 1
+
+    # Check to see which systems appear in the profiled run
+    systems_used = []
+    for system in systems:
+        if any((r in s) or (r.replace('.', '/') in s)
+               for r in systems[system] for s in strings):
+            systems_used.append(system)
+    return sorted(systems_used)
+
+
+cdef extern from *:
+    int CYTHON_PROFILE """
+        #ifdef CYTHON_PROFILE
+        CYTHON_PROFILE
+        #else
+        0
+        #endif
+        """
+
+
+cpdef inline bint cython_profile_enabled() noexcept:
+    """
+    Return whether Cython profiling is enabled.
+
+    EXAMPLES::
+
+        sage: from sage.misc.citation import cython_profile_enabled
+        sage: cython_profile_enabled()  # random
+        False
+        sage: type(cython_profile_enabled()) is bool
+        True
+    """
+    return CYTHON_PROFILE

sage/misc/converting_dict.py

@@ -0,0 +1,293 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Converting Dictionary
+
+At the moment, the only class contained in this module is a key
+converting dictionary, which applies some function (e.g. type
+conversion function) to all arguments used as keys.
+
+.. It is conceivable that a other dicts might be added later on.
+
+AUTHORS:
+
+- Martin von Gagern (2015-01-31): initial version
+
+EXAMPLES:
+
+A ``KeyConvertingDict`` will apply a conversion function to all method
+arguments which are keys::
+
+    sage: from sage.misc.converting_dict import KeyConvertingDict
+    sage: d = KeyConvertingDict(int)
+    sage: d["3"] = 42
+    sage: list(d.items())
+    [(3, 42)]
+
+This is used e.g. in the result of a variety, to allow access to the
+result no matter how a generator is identified::
+
+    sage: # needs sage.libs.singular sage.rings.number_field
+    sage: K.<x,y> = QQ[]
+    sage: I = ideal([x^2 + 2*y - 5, x + y + 3])
+    sage: V = sorted(I.variety(AA), key=str)
+    sage: v = V[0]
+    sage: v['x'], v['y']
+    (-2.464101615137755?, -0.535898384862246?)
+    sage: list(v)[0].parent()
+    Multivariate Polynomial Ring in x, y over Algebraic Real Field
+"""
+# ****************************************************************************
+#       Copyright (C) 2015 Martin von Gagern <Martin.vGagern@gmx.net>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License 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 collections.abc import Mapping
+
+
+class KeyConvertingDict(dict):
+    r"""
+    A dictionary which automatically applies a conversions to its keys.
+
+    The most common application is the case where the conversion
+    function is the object representing some category, so that key
+    conversion means a type conversion to adapt keys to that
+    category. This allows different representations for keys which in
+    turn makes accessing the correct element easier.
+
+    INPUT:
+
+    - ``key_conversion_function`` -- a function which will be
+      applied to all method arguments which represent keys
+    - ``data`` -- (optional) dictionary or sequence of key-value pairs
+      to initialize this mapping
+
+    EXAMPLES::
+
+        sage: from sage.misc.converting_dict import KeyConvertingDict
+        sage: d = KeyConvertingDict(int)
+        sage: d["3"] = 42
+        sage: list(d.items())
+        [(3, 42)]
+        sage: d[5.0] = 64
+        sage: d["05"]
+        64
+    """
+
+    def __init__(self, key_conversion_function, data=None):
+        r"""
+        Construct a dictionary with a given conversion function.
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d["3"] = 42
+            sage: list(d.items())
+            [(3, 42)]
+            sage: list(KeyConvertingDict(int, {"5": 7}).items())
+            [(5, 7)]
+            sage: list(KeyConvertingDict(int, [("9", 99)]).items())
+            [(9, 99)]
+        """
+        super().__init__()
+        self.key_conversion_function = key_conversion_function
+        if data:
+            self.update(data)
+
+    def __getitem__(self, key):
+        r"""
+        Retrieve an element from the dictionary.
+
+        INPUT:
+
+        - ``key`` -- a value identifying the element, will be converted
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d[3] = 42
+            sage: d["3"]
+            42
+        """
+        key = self.key_conversion_function(key)
+        return super().__getitem__(key)
+
+    def __setitem__(self, key, value):
+        r"""
+        Assign an element in the dictionary.
+
+        INPUT:
+
+        - ``key`` -- a value identifying the element, will be converted
+        - ``value`` -- the associated value, will be left unmodified
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d["3"] = 42
+            sage: list(d.items())
+            [(3, 42)]
+        """
+        key = self.key_conversion_function(key)
+        return super().__setitem__(key, value)
+
+    def __delitem__(self, key):
+        r"""
+        Remove a mapping from the dictionary.
+
+        INPUT:
+
+        - ``key`` -- a value identifying the element, will be converted
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d[3] = 42
+            sage: del d["3"]
+            sage: len(d)
+            0
+        """
+        key = self.key_conversion_function(key)
+        return super().__delitem__(key)
+
+    def __contains__(self, key):
+        r"""
+        Test whether a given key is contained in the mapping.
+
+        INPUT:
+
+        - ``key`` -- a value identifying the element, will be converted
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d[3] = 42
+            sage: "3" in d
+            True
+            sage: 4 in d
+            False
+        """
+        key = self.key_conversion_function(key)
+        return super().__contains__(key)
+
+    def pop(self, key, *args):
+        r"""
+        Remove and retrieve a given element from the dictionary.
+
+        INPUT:
+
+        - ``key`` -- a value identifying the element, will be converted
+        - ``default`` -- the value to return if the element is not mapped, optional
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d[3] = 42
+            sage: d.pop("3")
+            42
+            sage: d.pop("3", 33)
+            33
+            sage: d.pop("3")
+            Traceback (most recent call last):
+            ...
+            KeyError: ...
+        """
+        key = self.key_conversion_function(key)
+        return super().pop(key, *args)
+
+    def setdefault(self, key, default=None):
+        r"""
+        Create a given mapping unless there already exists a mapping
+        for that key.
+
+        INPUT:
+
+        - ``key`` -- a value identifying the element, will be converted
+        - ``default`` -- the value to associate with the key
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d.setdefault("3")
+            sage: list(d.items())
+            [(3, None)]
+        """
+        key = self.key_conversion_function(key)
+        return super().setdefault(key, default)
+
+    def update(self, *args, **kwds):
+        r"""
+        Update the dictionary with key-value pairs from another dictionary,
+        sequence of key-value pairs, or keyword arguments.
+
+        INPUT:
+
+        - ``key`` -- a value identifying the element, will be converted
+        - ``args`` -- a single dict or sequence of pairs
+        - ``kwds`` -- named elements require that the conversion
+          function accept strings
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d.update([("3",1),(4,2)])
+            sage: d[3]
+            1
+            sage: d.update({"5": 7, "9": 12})
+            sage: d[9]
+            12
+            sage: d = KeyConvertingDict(QQ['x'])
+            sage: d.update(x=42)
+            sage: d
+            {x: 42}
+        """
+        f = self.key_conversion_function
+        u = super().update
+        if args:
+            if len(args) != 1:
+                raise TypeError("update expected at most 1 argument")
+            arg = args[0]
+            if isinstance(arg, Mapping):
+                seq = ((f(k), arg[k]) for k in arg)
+            else:
+                seq = ((f(k), v) for k, v in arg)
+            u(seq)
+        if kwds:
+            seq = ((f(k), v) for k, v in kwds.items())
+            u(seq)
+
+    def _repr_pretty_(self, p, cycle):
+        """
+        For pretty printing in the Sage command prompt.
+
+        Since ``KeyConvertingDict`` inherits from ``dict``, we just use IPython's
+        built-in ``dict`` pretty printer.
+        When :issue:`36801` is fixed, this function will be redundant.
+
+        EXAMPLES::
+
+            sage: from sage.misc.converting_dict import KeyConvertingDict
+            sage: d = KeyConvertingDict(int)
+            sage: d["3"] = 4
+            sage: d["1"] = 2
+            sage: repr(d)    # dictionaries are insertion ordered since Python 3.6
+            '{3: 4, 1: 2}'
+            sage: d          # indirect doctest
+            {1: 2, 3: 4}
+
+        The last example output will be ``{3: 4, 1: 2}`` outside of doctesting,
+        see :func:`sage.doctest.forker.init_sage`.
+        """
+        p.pretty(dict(self))

sage/misc/defaults.py

@@ -0,0 +1,129 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Default Settings
+
+AUTHORS: William Stein and David Kohel
+"""
+# ****************************************************************************
+#       Copyright (C) 2004 William Stein <wstein@gmail.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/
+# ****************************************************************************
+
+# default variable name
+var_name = 'x'
+
+
+def variable_names(n, name=None):
+    r"""
+    Convert a root string into a tuple of variable names by adding
+    numbers in sequence.
+
+    INPUT:
+
+    - ``n`` -- a nonnegative Integer; the number of variable names to
+      output
+    - ``names`` a string (default: ``None``); the root of the variable
+      name
+
+    EXAMPLES::
+
+        sage: from sage.misc.defaults import variable_names
+        sage: variable_names(0)
+        ()
+        sage: variable_names(1)
+        ('x',)
+        sage: variable_names(1,'alpha')
+        ('alpha',)
+        sage: variable_names(2,'alpha')
+        ('alpha0', 'alpha1')
+    """
+    if name is None:
+        name = var_name
+    n = int(n)
+    if n == 1:
+        return (name,)
+    return tuple(['%s%s' % (name, i) for i in range(n)])
+
+
+def latex_variable_names(n, name=None):
+    r"""
+    Convert a root string into a tuple of variable names by adding
+    numbers in sequence.
+
+    INPUT:
+
+    - ``n`` -- a nonnegative Integer; the number of variable names to
+      output
+    - ``names`` a string (default: ``None``); the root of the variable
+      name
+
+    EXAMPLES::
+
+        sage: from sage.misc.defaults import latex_variable_names
+        sage: latex_variable_names(0)
+        ()
+        sage: latex_variable_names(1,'a')
+        ('a',)
+        sage: latex_variable_names(3,beta)
+        ('beta_{0}', 'beta_{1}', 'beta_{2}')
+        sage: latex_variable_names(3,r'\beta')
+        ('\\beta_{0}', '\\beta_{1}', '\\beta_{2}')
+    """
+    if name is None:
+        name = var_name
+    n = int(n)
+    if n == 1:
+        return (name,)
+    return tuple(['%s_{%s}' % (name, i) for i in range(n)])
+
+
+def set_default_variable_name(name, separator=''):
+    r"""
+    Change the default variable name and separator.
+    """
+    global var_name, var_sep
+    var_name = str(name)
+    var_sep = str(separator)
+
+
+# default series precision
+series_prec = 20
+
+
+def series_precision():
+    """
+    Return the Sage-wide precision for series (symbolic,
+    power series, Laurent series).
+
+    EXAMPLES::
+
+        sage: series_precision()
+        20
+    """
+    return series_prec
+
+
+def set_series_precision(prec):
+    """
+    Change the Sage-wide precision for series (symbolic,
+    power series, Laurent series).
+
+    EXAMPLES::
+
+        sage: set_series_precision(5)
+        sage: series_precision()
+        5
+        sage: set_series_precision(20)
+    """
+    global series_prec
+    series_prec = prec