passagemath-objects 10.6.44__cp314-cp314t-macosx_13_0_arm64.whl

sage/misc/repr.py

@@ -0,0 +1,203 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Repr formatting support
+"""
+
+
+def coeff_repr(c, is_latex=False):
+    r"""
+    String representing coefficients in a linear combination.
+
+    INPUT:
+
+    - ``c`` -- a coefficient (i.e., an element of a ring)
+
+    OUTPUT: string
+
+    EXAMPLES::
+
+        sage: from sage.misc.repr import coeff_repr
+        sage: coeff_repr(QQ(1/2))
+        '1/2'
+        sage: coeff_repr(-x^2)                                                          # needs sage.symbolic
+        '(-x^2)'
+        sage: coeff_repr(QQ(1/2), is_latex=True)
+        '\\frac{1}{2}'
+        sage: coeff_repr(-x^2, is_latex=True)                                           # needs sage.symbolic
+        '\\left(-x^{2}\\right)'
+    """
+    if not is_latex:
+        try:
+            return c._coeff_repr()
+        except AttributeError:
+            pass
+    if isinstance(c, (int, float)):
+        return str(c)
+    if is_latex and hasattr(c, '_latex_'):
+        s = c._latex_()
+    else:
+        s = str(c).replace(' ', '')
+    if s.find("+") != -1 or s.find("-") != -1:
+        if is_latex:
+            return "\\left(%s\\right)" % s
+        else:
+            return "(%s)" % s
+    return s
+
+
+def repr_lincomb(terms, is_latex=False, scalar_mult='*', strip_one=False,
+                 repr_monomial=None, latex_scalar_mult=None):
+    """
+    Compute a string representation of a linear combination of some
+    formal symbols.
+
+    INPUT:
+
+    - ``terms`` -- list of terms, as pairs (support, coefficient)
+    - ``is_latex`` -- whether to produce latex (default: ``False``)
+    - ``scalar_mult`` -- string representing the multiplication (default: ``'*'``)
+    - ``latex_scalar_mult`` -- latex string representing the multiplication
+      (default: a space if ``scalar_mult`` is ``'*'``; otherwise ``scalar_mult``)
+    - ``coeffs`` -- for backward compatibility
+
+    EXAMPLES::
+
+        sage: repr_lincomb([('a',1), ('b',-2), ('c',3)])
+        'a - 2*b + 3*c'
+        sage: repr_lincomb([('a',0), ('b',-2), ('c',3)])
+        '-2*b + 3*c'
+        sage: repr_lincomb([('a',0), ('b',2), ('c',3)])
+        '2*b + 3*c'
+        sage: repr_lincomb([('a',1), ('b',0), ('c',3)])
+        'a + 3*c'
+        sage: repr_lincomb([('a',-1), ('b','2+3*x'), ('c',3)])
+        '-a + (2+3*x)*b + 3*c'
+        sage: repr_lincomb([('a', '1+x^2'), ('b', '2+3*x'), ('c', 3)])
+        '(1+x^2)*a + (2+3*x)*b + 3*c'
+        sage: repr_lincomb([('a', '1+x^2'), ('b', '-2+3*x'), ('c', 3)])
+        '(1+x^2)*a + (-2+3*x)*b + 3*c'
+        sage: repr_lincomb([('a', 1), ('b', -2), ('c', -3)])
+        'a - 2*b - 3*c'
+        sage: t = PolynomialRing(RationalField(),'t').gen()
+        sage: repr_lincomb([('a', -t), ('s', t - 2), ('', t^2 + 2)])
+        '-t*a + (t-2)*s + (t^2+2)'
+
+    Examples for ``scalar_mult``::
+
+        sage: repr_lincomb([('a',1), ('b',2), ('c',3)], scalar_mult='*')
+        'a + 2*b + 3*c'
+        sage: repr_lincomb([('a',2), ('b',0), ('c',-3)], scalar_mult='**')
+        '2**a - 3**c'
+        sage: repr_lincomb([('a',-1), ('b',2), ('c',3)], scalar_mult='**')
+        '-a + 2**b + 3**c'
+
+    Examples for ``scalar_mult`` and ``is_latex``::
+
+        sage: repr_lincomb([('a',-1), ('b',2), ('c',3)], is_latex=True)
+        '-a + 2 b + 3 c'
+        sage: repr_lincomb([('a',-1), ('b',-1), ('c',3)], is_latex=True, scalar_mult='*')
+        '-a - b + 3 c'
+        sage: repr_lincomb([('a',-1), ('b',2), ('c',-3)], is_latex=True, scalar_mult='**')
+        '-a + 2**b - 3**c'
+        sage: repr_lincomb([('a',-2), ('b',-1), ('c',-3)], is_latex=True, latex_scalar_mult='*')
+        '-2*a - b - 3*c'
+        sage: repr_lincomb([('a',-2), ('b',-1), ('c',-3)], is_latex=True, latex_scalar_mult='')
+        '-2a - b - 3c'
+
+    Examples for ``strip_one``::
+
+        sage: repr_lincomb([ ('a',1), (1,-2), ('3',3) ])
+        'a - 2*1 + 3*3'
+        sage: repr_lincomb([ ('a',-1), (1,1), ('3',3) ])
+        '-a + 1 + 3*3'
+        sage: repr_lincomb([ ('a',1), (1,-2), ('3',3) ], strip_one = True)
+        'a - 2 + 3*3'
+        sage: repr_lincomb([ ('a',-1), (1,1), ('3',3) ], strip_one = True)
+        '-a + 1 + 3*3'
+        sage: repr_lincomb([ ('a',1), (1,-1), ('3',3) ], strip_one = True)
+        'a - 1 + 3*3'
+
+    Examples for ``repr_monomial``::
+
+        sage: repr_lincomb([('a',1), ('b',2), ('c',3)], repr_monomial = lambda s: s+"1")
+        'a1 + 2*b1 + 3*c1'
+
+    TESTS:
+
+    Verify that :issue:`31672` is fixed::
+
+        sage: # needs sage.symbolic
+        sage: alpha = var("alpha")
+        sage: repr_lincomb([(x, alpha)], is_latex=True)
+        '\\alpha x'
+        sage: A.<psi> = PolynomialRing(QQ)
+        sage: B.<t> = FreeAlgebra(A)                                                    # needs sage.combinat sage.modules
+        sage: (psi * t)._latex_()                                                       # needs sage.combinat sage.modules
+        '\\psi t'
+    """
+    # Setting scalar_mult: symbol used for scalar multiplication
+    if is_latex:
+        if latex_scalar_mult is not None:
+            scalar_mult = latex_scalar_mult
+        elif scalar_mult == "*":
+            scalar_mult = " "
+
+    if repr_monomial is None:
+        if is_latex:
+
+            def repr_monomial(monomial):
+                return monomial._latex_() if hasattr(monomial, '_latex_') else str(monomial)
+        else:
+            repr_monomial = str
+
+    s = ""
+    first = True
+
+    if scalar_mult is None:
+        scalar_mult = "" if is_latex else "*"
+
+    for (monomial, c) in terms:
+        if c != 0:
+            coeff = coeff_repr(c)
+            negative = False
+            if len(coeff) and coeff[0] == "-":
+                negative = True
+            try:
+                if c < 0:
+                    negative = True
+            except (NotImplementedError, TypeError):
+                # comparisons may not be implemented for some coefficients
+                pass
+            if negative:
+                coeff = coeff_repr(-c, is_latex)
+            else:
+                coeff = coeff_repr(c, is_latex)
+            if coeff == "1":
+                coeff = ""
+            if coeff != "0":
+                if negative:
+                    if first:
+                        sign = "-"  # add trailing space?
+                    else:
+                        sign = " - "
+                else:
+                    if first:
+                        sign = ""
+                    else:
+                        sign = " + "
+                b = repr_monomial(monomial)
+                if len(b):
+                    if coeff != "":
+                        if b == "1" and strip_one:
+                            b = ""
+                        else:
+                            b = scalar_mult + b
+                s += "%s%s%s" % (sign, coeff, b)
+                first = False
+    if first:
+        return "0"
+        # this can happen only if are only terms with coeff_repr(c) == "0"
+    # elif s == "":
+        # return "1"  # is empty string representation invalid?
+    else:
+        return s

sage/misc/reset.pyx

@@ -0,0 +1,196 @@
+# sage_setup: distribution = sagemath-objects
+# cython: old_style_globals=True
+"""
+Interpreter reset
+"""
+import sys
+
+# Exclude these from the reset command.
+# DATA, base64 -- needed by the notebook
+# Add exit and quit to EXCLUDE to resolve Issue #22529 and Issue #16704
+EXCLUDE = set(['sage_mode', '__DIR__', 'DIR', 'DATA', 'base64', 'exit', 'quit'])
+
+
+def reset(vars=None, attached=False):
+    """
+    Delete all user-defined variables, reset all global variables
+    back to their default states, and reset all interfaces to other
+    computer algebra systems.
+
+    If vars is specified, just restore the value of vars and leave
+    all other variables alone (i.e., call restore).
+
+    Note that the variables in the set :obj:`sage.misc.reset.EXCLUDE` are
+    excluded from being reset.
+
+    INPUT:
+
+    - ``vars`` -- list or space or comma separated string (default:
+      ``None``); variables to restore
+
+    - ``attached`` -- boolean (default: ``False``); if ``vars`` is not ``None``,
+      whether to detach all attached files
+
+    EXAMPLES::
+
+        sage: x = 5
+        sage: reset()
+        sage: x                                                                         # needs sage.symbolic
+        x
+
+        sage: fn = tmp_filename(ext='.py')
+        sage: sage.misc.reset.EXCLUDE.add('fn')
+        sage: with open(fn, 'w') as f:
+        ....:     _ = f.write('a = 111')
+        sage: attach(fn)
+        sage: af = attached_files(); len(af)
+        1
+        sage: af == [fn]
+        True
+        sage: reset()
+        sage: af = attached_files(); len(af)
+        1
+        sage: reset(attached=True)
+        sage: af = attached_files(); len(af)
+        0
+        sage: sage.misc.reset.EXCLUDE.remove('fn')
+
+    TESTS:
+
+    Confirm that assumptions do not survive a reset (:issue:`10855`)::
+
+        sage: # needs sage.symbolic
+        sage: assume(x > 3)
+        sage: assumptions()
+        [x > 3]
+        sage: bool(x > 3)
+        True
+        sage: reset()
+        sage: assumptions()
+        []
+        sage: bool(x > 3)
+        False
+    """
+    if vars is not None:
+        restore(vars)
+        return
+    G = globals()  # this is the reason the code must be in Cython.
+    T = type(sys)
+    for k in list(G):
+        if k[0] != '_' and not isinstance(k, T) and k not in EXCLUDE:
+            try:
+                del G[k]
+            except KeyError:
+                pass
+    restore()
+    try:
+        from sage.symbolic.assumptions import forget
+    except ImportError:
+        pass
+    else:
+        forget()
+    reset_interfaces()
+    if attached:
+        import sage.repl.attach
+        sage.repl.attach.reset()
+
+
+def restore(vars=None):
+    """
+    Restore predefined global variables to their default values.
+
+    INPUT:
+
+    - ``vars`` -- string or list (default: ``None``); if not ``None``, restores
+      just the given variables to the default value
+
+    EXAMPLES::
+
+        sage: x = 10; y = 15/3; QQ='red'
+        sage: QQ
+        'red'
+        sage: restore('QQ')
+        sage: QQ
+        Rational Field
+        sage: x
+        10
+        sage: y = var('y')                                                              # needs sage.symbolic
+        sage: restore('x y')
+        sage: x                                                                         # needs sage.symbolic
+        x
+        sage: y
+        Traceback (most recent call last):
+        ...
+        NameError: name 'y' is not defined
+        sage: x = 10; y = 15/3; QQ='red'
+        sage: ww = 15
+        sage: restore()
+        sage: x, QQ, ww                                                                 # needs sage.symbolic
+        (x, Rational Field, 15)
+        sage: restore('ww')
+        sage: ww
+        Traceback (most recent call last):
+        ...
+        NameError: name 'ww' is not defined
+    """
+    G = globals()  # this is the reason the code must be in Cython.
+    if 'sage_mode' not in G:
+        try:
+            import sage.all as toplevel
+        except ImportError:
+            try:
+                import sage.all__sagemath_polyhedra as toplevel
+            except ImportError:
+                try:
+                    import sage.all__sagemath_symbolics as toplevel
+                except ImportError:
+                    try:
+                        import sage.all__sagemath_modules as toplevel
+                    except ImportError:
+                        try:
+                            import sage.all__sagemath_categories as toplevel
+                        except ImportError:
+                            import sage.all__sagemath_objects as toplevel
+    else:
+        mode = G['sage_mode']
+        if mode == 'cmdline':
+            import sage.all_cmdline as toplevel
+        else:
+            import sage.all as toplevel
+    D = toplevel.__dict__
+    _restore(G, D, vars)
+    try:
+        import sage.calculus.calculus
+    except ImportError:
+        pass
+    else:
+        _restore(sage.calculus.calculus.syms_cur, sage.calculus.calculus.syms_default, vars)
+
+
+def _restore(G, D, vars):
+    if vars is None:
+        for k, v in D.iteritems():
+            G[k] = v
+    else:
+        if isinstance(vars, str):
+            if ',' in vars:
+                vars = vars.split(',')
+            else:
+                vars = vars.split()
+        for k in vars:
+            if k in D:
+                G[k] = D[k]
+            else:
+                try:
+                    del G[k]      # the default value was "unset"
+                except KeyError:
+                    pass
+
+
+def reset_interfaces():
+    try:
+        from sage.interfaces.quit import expect_quitall
+    except ImportError:
+        pass
+    else:
+        expect_quitall()