passagemath-objects 10.6.41__cp312-cp312-win_amd64.whl

sage/arith/long.pxd

@@ -0,0 +1,411 @@
+# sage_setup: distribution = sagemath-objects
+# sage.doctest: needs sage.misc.cython
+r"""
+Fast conversion of Python objects to C long
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2015 Vincent Delecroix <20100.delecroix@gmail.com>
+#       Copyright (C) 2017 Jeroen Demeyer <J.Demeyer@UGent.be>
+#
+# 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 libc.limits cimport LONG_MIN, LONG_MAX
+
+from cpython.object cimport Py_SIZE
+from cpython.number cimport PyNumber_Index, PyIndex_Check
+from cpython.longintrepr cimport py_long, PyLong_SHIFT, digit
+from sage.cpython.pycore_long cimport (
+    ob_digit, _PyLong_IsNegative, _PyLong_DigitCount)
+
+from sage.libs.gmp.mpz cimport mpz_fits_slong_p, mpz_get_si
+from sage.rings.integer_fake cimport is_Integer, Integer_AS_MPZ
+
+
+cdef inline long pyobject_to_long(x) except? LONG_MIN:
+    r"""
+    Given a Python object ``x`` cast it quickly to a C long.
+
+    A :exc:`TypeError` is raised if the input cannot be converted to
+    an integer or
+    an :exc:`OverflowError` is raised if it does not fit into a C long.
+
+    TESTS:
+
+    We test indirectly that ``Integer.__pow__`` works::
+
+        sage: a = 10
+        sage: a^10
+        10000000000
+        sage: a^(10r)
+        10000000000
+        sage: a^(10l)
+        10000000000
+        sage: a^(10/1)
+        10000000000
+        sage: a^(2**258)
+        Traceback (most recent call last):
+        ...
+        OverflowError: exponent must be at most 2147483647           # 32-bit
+        OverflowError: exponent must be at most 9223372036854775807  # 64-bit
+
+    See :issue:`22319`::
+
+        sage: a^pari(10)
+        10000000000
+    """
+    cdef long value
+    cdef int err
+    if integer_check_long_py(x, &value, &err):
+        if err:
+            raise OverflowError("Python int too large to convert to C long")
+        return value
+    if is_Integer(x):
+        z = Integer_AS_MPZ(x)
+        if mpz_fits_slong_p(z):
+            return mpz_get_si(z)
+        else:
+            raise OverflowError("Sage Integer too large to convert to C long")
+
+    return PyNumber_Index(x)
+
+
+# Error values for integer_check_long()
+cdef enum:
+    ERR_TYPE = 1
+    ERR_INDEX = 2
+    ERR_OVERFLOW = 3
+
+
+cdef inline bint integer_check_long(x, long* value, int* err) except -1:
+    """
+    Return whether ``x`` is some integer type. This is true for the
+    Python type ``int``, for Sage Integers and for types
+    implementing ``__index__``.
+
+    If possible, compute the value of this integer as C long and store
+    it in ``*value``.
+
+    Errors are returned as an error indicator ``*err`` (without raising
+    any Python exception).
+
+    Possible errors when returning ``True``:
+
+    - ``0`` -- ``x`` was successfully converted to a C long and its value
+      is stored in ``*value``
+
+    - ``ERR_OVERFLOW`` -- ``x`` is an integer type but too large to store
+      in a C long
+
+    Possible errors when returning ``False``:
+
+    - ``ERR_TYPE`` -- ``x`` is not an integer type of any kind
+
+    - ``ERR_INDEX`` -- ``x`` implements ``__index__`` but a :exc:`TypeError`
+      was raised calling ``__index__()``
+
+    - Other exceptions in ``__index__`` are simply propagated. This is
+      the only way this function can raise an exception.
+
+    EXAMPLES:
+
+    We create a pure Python wrapper of this function::
+
+        sage: cython('''
+        ....: from sage.arith.long cimport *
+        ....: from sage.rings.integer cimport smallInteger
+        ....: def check_long(x):
+        ....:     cdef long value
+        ....:     cdef int err
+        ....:     cdef bint c = integer_check_long(x, &value, &err)
+        ....:     if c:
+        ....:         if err == 0:
+        ....:             return value
+        ....:         elif err == ERR_OVERFLOW:
+        ....:             raise OverflowError(f"integer_check_long: overflow ({x})")
+        ....:     elif err == ERR_TYPE:
+        ....:         raise TypeError("integer_check_long: wrong type")
+        ....:     elif err == ERR_INDEX:
+        ....:         raise TypeError("integer_check_long: bad __index__")
+        ....:     assert False
+        ....: from libc.limits cimport LONG_MIN, LONG_MAX
+        ....: def long_min():
+        ....:     return smallInteger(LONG_MIN)
+        ....: def long_max():
+        ....:     return smallInteger(LONG_MAX)
+        ....: ''')
+        sage: L = [1, 12345, 10^9, 2^30, long_max()//9, long_max()//3, long_max()]
+        sage: L += [-x for x in L] + [0, long_min()]
+        sage: for v in L:
+        ....:     for t in (Integer, int, QQ):
+        ....:         assert check_long(t(v)) == v
+        sage: check_long(2^100)
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+        sage: check_long(long_max() + 1)
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+        sage: check_long(long_min() - 1)
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+        sage: check_long("hello")
+        Traceback (most recent call last):
+        ...
+        TypeError: integer_check_long: wrong type
+        sage: check_long(2/3)
+        Traceback (most recent call last):
+        ...
+        TypeError: integer_check_long: bad __index__
+
+    Repeat the overflow tests with python integers:
+
+        sage: check_long(int(2^100))
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+        sage: check_long(int(long_max() + 1))
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+        sage: check_long(int(long_min() - 1))
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+
+    And again with rationals:
+
+        sage: check_long(QQ(2^100))
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+        sage: check_long(QQ(long_max() + 1))
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+        sage: check_long(QQ(long_min() - 1))
+        Traceback (most recent call last):
+        ...
+        OverflowError: integer_check_long: overflow (...)
+    """
+    cdef int c = integer_check_long_py(x, value, err)
+    if c:
+        return c
+    if is_Integer(x):
+        z = Integer_AS_MPZ(x)
+        if mpz_fits_slong_p(z):
+            value[0] = mpz_get_si(z)
+            err[0] = 0
+        else:
+            err[0] = ERR_OVERFLOW
+        return 1
+    elif PyIndex_Check(x):
+        err[0] = ERR_INDEX
+        try:
+            x = PyNumber_Index(x)
+        except TypeError:
+            return 0
+        return integer_check_long_py(x, value, err)
+    else:
+        err[0] = ERR_TYPE
+        return 0
+
+
+cdef inline long dig(const digit* D, int n) noexcept:
+    # Convenient helper function for integer_check_long_py()
+    return (<long>D[n]) << (n * PyLong_SHIFT)
+
+
+cdef inline bint integer_check_long_py(x, long* value, int* err) noexcept:
+    """
+    Return whether ``x`` is a Python object of type ``int``.
+
+    If possible, compute the value of this integer as C long and store
+    it in ``*value``.
+
+    Errors are returned as an error indicator ``*err`` (without raising
+    any Python exception).
+
+    Possible errors when returning ``True``:
+
+    - ``0`` -- ``x`` was successfully converted to a C long and its value
+      is stored in ``*value``
+
+    - ``ERR_OVERFLOW`` -- ``x`` is a Python object of type ``int`` but
+      too large to store in a C long
+
+    Possible errors when returning ``False``:
+
+    - ``ERR_TYPE`` -- ``x`` is not a Python object of type ``int``
+
+    EXAMPLES:
+
+    We create a pure Python wrapper of this function::
+
+        sage: cython('''
+        ....: from sage.arith.long cimport *
+        ....: def check_long_py(x):
+        ....:     cdef long value
+        ....:     cdef int err
+        ....:     cdef bint c = integer_check_long_py(x, &value, &err)
+        ....:     if c:
+        ....:         if err == 0:
+        ....:             return value
+        ....:         elif err == ERR_OVERFLOW:
+        ....:             return f"Overflow ({x})"
+        ....:     elif err == ERR_TYPE:
+        ....:         return f"Bad type ({x})"
+        ....:     return f"This should never happen ({x})"
+        ....: from libc.limits cimport LONG_MIN, LONG_MAX
+        ....: def long_min():
+        ....:     return LONG_MIN
+        ....: def long_max():
+        ....:     return LONG_MAX
+        ....: ''')
+        sage: L = [1, 12345, 10^9, 2^30, long_max()//9, long_max()//3, long_max()]
+        sage: L += [-x for x in L] + [0, long_min()]
+        sage: for v in L:
+        ....:     assert check_long_py(int(v)) == v
+        sage: check_long_py(int(2^60))
+        1152921504606846976                 # 64-bit
+        'Overflow (...)'                    # 32-bit
+        sage: check_long_py(int(2^61))
+        2305843009213693952                 # 64-bit
+        'Overflow (...)'                    # 32-bit
+        sage: check_long_py(int(2^62))
+        4611686018427387904                 # 64-bit
+        'Overflow (...)'                    # 32-bit
+        sage: check_long_py(int(2^63))
+        'Overflow (...)'
+        sage: check_long_py(int(2^100))
+        'Overflow (...)'
+        sage: check_long_py(int(long_max() + 1))
+        'Overflow (...)'
+        sage: check_long_py(int(long_min() - 1))
+        'Overflow (...)'
+        sage: check_long_py(389)
+        'Bad type (...)'
+        sage: check_long_py("hello")
+        'Bad type (...)'
+        sage: check_long_py(2/3)
+        'Bad type (...)'
+    """
+    if not isinstance(x, int):
+        err[0] = ERR_TYPE
+        return 0
+
+    # x is a Python "int" (aka PyLongObject or py_long in cython)
+    cdef const digit* D = ob_digit(x)
+    cdef Py_ssize_t size = _PyLong_DigitCount(x)
+
+    if _PyLong_IsNegative(x):
+        size = -size
+
+    # We assume PyLong_SHIFT <= BITS_IN_LONG <= 3 * PyLong_SHIFT.
+    # This is true in all the default configurations:
+    # - BITS_IN_LONG = 63, PyLong_SHIFT = 30
+    # - BITS_IN_LONG = 31, PyLong_SHIFT = 15 (python <= 3.10)
+    # - BITS_IN_LONG = 31, PyLong_SHIFT = 30 (new in python 3.11)
+    # cf. https://github.com/sagemath/sage/issues/33842#comment:130
+    #
+    # This way, we know that 1 digit certainly fits in a C long
+    # and 4 or more digits never fit.
+    # For 2 or 3 digits, we need an explicit overflow check.
+    cdef int BITS_IN_LONG = 8 * sizeof(long) - 1
+    if not (PyLong_SHIFT <= BITS_IN_LONG <= 3 * PyLong_SHIFT):
+        raise AssertionError(
+                f"PyLong_SHIFT = {PyLong_SHIFT}, "
+                f"BITS_IN_LONG = {BITS_IN_LONG}")
+
+    cdef long lead
+    cdef long lead_2_overflow = (<long>1) << (BITS_IN_LONG - PyLong_SHIFT)
+    cdef long lead_3_overflow
+    if BITS_IN_LONG < 2 * PyLong_SHIFT:
+        # in this case 3 digit is always overflow
+        lead_3_overflow = 0
+    else:
+        lead_3_overflow = (<long>1) << (BITS_IN_LONG - 2 * PyLong_SHIFT)
+    if size == 0:
+        value[0] = 0
+        err[0] = 0
+    elif size == 1:
+        value[0] = dig(D, 0)
+        err[0] = 0
+    elif size == -1:
+        value[0] = -dig(D, 0)
+        err[0] = 0
+    elif size == 2:
+        if BITS_IN_LONG < 2 * PyLong_SHIFT and D[1] >= lead_2_overflow:
+            err[0] = ERR_OVERFLOW
+            return 1
+        value[0] = dig(D, 0) + dig(D, 1)
+        err[0] = 0
+    elif size == -2:
+        if BITS_IN_LONG < 2 * PyLong_SHIFT and D[1] >= lead_2_overflow:
+            if D[0] == 0 and D[1] == lead_2_overflow:
+                # Special case for LONG_MIN
+                value[0] = (<long>-1) << BITS_IN_LONG
+                err[0] = 0
+            else:
+                err[0] = ERR_OVERFLOW
+            return 1
+        value[0] = -(dig(D, 0) + dig(D, 1))
+        err[0] = 0
+    elif size == 3:
+        lead = D[2]
+        if lead < lead_3_overflow:
+            value[0] = dig(D, 0) + dig(D, 1) + dig(D, 2)
+            err[0] = 0
+        else:
+            err[0] = ERR_OVERFLOW
+    elif size == -3:
+        lead = D[2]
+        if lead < lead_3_overflow:
+            value[0] = -(dig(D, 0) + dig(D, 1) + dig(D, 2))
+            err[0] = 0
+        elif D[0] == 0 and D[1] == 0 and lead == lead_3_overflow:
+            # Special case for LONG_MIN
+            value[0] = (<long>-1) << BITS_IN_LONG
+            err[0] = 0
+        else:
+            err[0] = ERR_OVERFLOW
+    else:
+        # 4 digits or more: guaranteed overflow
+        err[0] = ERR_OVERFLOW
+    return 1
+
+
+cdef inline bint is_small_python_int(obj) noexcept:
+    """
+    Test whether Python object is a small Python integer.
+
+    Meaning that it can be converted to a C long. In Python 2,
+    this is equivalent to it being the ``int`` Python type. In Python
+    3, the ``int`` Python type has unlimited precision so we need to
+    check its range.
+
+    EXAMPLES::
+
+        sage: cython('''
+        ....: from sage.arith.long cimport is_small_python_int
+        ....: def is_small_wrapper(x):
+        ....:     return is_small_python_int(x)
+        ....: ''')
+        sage: is_small_wrapper(int(3))
+        True
+        sage: is_small_wrapper(ZZ(3))   # not a Python int
+        False
+        sage: import sys
+        sage: is_small_wrapper(int(sys.maxsize))   # does fit into C long
+        True
+        sage: is_small_wrapper(int(sys.maxsize + 1))   # does not fit into C long
+        False
+    """
+    return (type(obj) is int) and (LONG_MIN <= obj <= LONG_MAX)

sage/arith/numerical_approx.pxd

@@ -0,0 +1,35 @@
+# sage_setup: distribution = sagemath-objects
+# sage.doctest: needs sage.rings.real_mpfr
+
+cpdef inline long digits_to_bits(d) except -1:
+    """
+    EXAMPLES::
+
+        sage: from sage.arith.numerical_approx import digits_to_bits
+        sage: digits_to_bits(None)
+        53
+        sage: digits_to_bits(15)
+        54
+        sage: digits_to_bits(-1)
+        Traceback (most recent call last):
+        ...
+        ValueError: number of digits must be positive
+
+    TESTS::
+
+        sage: digits_to_bits("10")
+        Traceback (most recent call last):
+        ...
+        TypeError: must be real number, not str
+    """
+    if d is None:
+        return 53
+    cdef double x = d
+    if x <= 0:
+        raise ValueError("number of digits must be positive")
+
+    # Add 1 because of the way how we display real numbers by default
+    x += 1
+    cdef double LOG_TEN_TWO = 3.321928094887362
+    # Add 1 to round up
+    return <long>(x * LOG_TEN_TWO) + 1

sage/arith/numerical_approx.pyx

@@ -0,0 +1,75 @@
+# sage_setup: distribution = sagemath-objects
+# sage.doctest: needs sage.rings.real_mpfr
+r"""
+Generic numerical approximation function
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2016 Jeroen Demeyer <jdemeyer@cage.ugent.be>
+#
+# 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 sage.structure.parent cimport Parent
+from sage.structure.element cimport parent
+cdef Parent CDF
+from sage.rings.real_mpfr import RealField
+from sage.rings.complex_mpfr import ComplexField
+from sage.rings.complex_double import CDF
+
+
+def numerical_approx_generic(x, prec):
+    """
+    Generic implementation of ``numerical_approx`` using coercion or
+    conversion to a real or complex field.
+
+    EXAMPLES::
+
+        sage: from sage.arith.numerical_approx import numerical_approx_generic
+        sage: numerical_approx_generic(pi, 20)                                          # needs sage.symbolic
+        3.1416
+        sage: numerical_approx_generic(int(42), 20)
+        42.000
+        sage: numerical_approx_generic(float(4.2), 20)
+        4.2000
+    """
+    P = parent(x)
+
+    cdef Parent RR = RealField(prec)
+    cmap = RR.coerce_map_from(P)
+    if cmap is not None:
+        return cmap(x)
+
+    cdef Parent CC = ComplexField(prec)
+    cmap = CC.coerce_map_from(P)
+    if cmap is not None:
+        return cmap(x)
+
+    # Coercion didn't work: there are 3 possibilities:
+    # (1) There is a coercion possible to a lower precision
+    # (2) There is a conversion but no coercion
+    # (3) The type doesn't convert at all
+
+    # Figure out input precision to check for case (1)
+    try:
+        inprec = x.prec()
+    except AttributeError:
+        if prec > 53 and CDF.has_coerce_map_from(P):
+            # If we can coerce to CDF, assume input precision was 53 bits
+            inprec = 53
+        else:
+            # Otherwise, assume precision wasn't the issue
+            inprec = prec
+
+    if prec > inprec:
+        raise TypeError("cannot approximate to a precision of %s bits, use at most %s bits" % (prec, inprec))
+
+    # The issue is not precision, try conversion instead
+    try:
+        return RR(x)
+    except (TypeError, ValueError):
+        return CC(x)

sage/arith/power.pxd

@@ -0,0 +1,31 @@
+# sage_setup: distribution = sagemath-objects
+from cpython.number cimport PyNumber_TrueDivide
+from sage.structure.element cimport Element
+
+
+ctypedef fused ulong_or_object:
+    unsigned long
+    object
+
+
+cpdef generic_power(a, n)
+cdef generic_power_long(a, long n)
+cdef generic_power_pos(a, ulong_or_object n)  # n > 0
+
+
+cdef inline invert(a):
+    """
+    Return ``a^(-1)``.
+    """
+    if isinstance(a, Element):
+        return ~a
+    return PyNumber_TrueDivide(type(a)(1), a)
+
+
+cdef inline one(a):
+    """
+    Return ``a^0``.
+    """
+    if isinstance(a, Element):
+        return (<Element>a)._parent.one()
+    return type(a)(1)

sage/arith/power.pyx

@@ -0,0 +1,127 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Generic implementation of powering
+
+This implements powering of arbitrary objects using a
+square-and-multiply algorithm.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2017 Jeroen Demeyer <J.Demeyer@UGent.be>
+#
+# 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 cysignals.signals cimport sig_check
+
+from sage.arith.long cimport integer_check_long
+
+
+cpdef generic_power(a, n):
+    """
+    Return `a^n`.
+
+    If `n` is negative, return `(1/a)^{-n}`.
+
+    INPUT:
+
+    - ``a`` -- any object supporting multiplication
+      (and division if n < 0)
+
+    - ``n`` -- any integer (in the duck typing sense)
+
+    EXAMPLES::
+
+        sage: from sage.arith.power import generic_power
+        sage: generic_power(int(12), int(0))
+        1
+        sage: generic_power(int(0), int(100))
+        0
+        sage: generic_power(Integer(10), Integer(0))
+        1
+        sage: generic_power(Integer(0), Integer(23))
+        0
+        sage: sum([generic_power(2,i) for i in range(17)]) #test all 4-bit combinations
+        131071
+        sage: F = Zmod(5)
+        sage: a = generic_power(F(2), 5); a
+        2
+        sage: a.parent() is F
+        True
+        sage: a = generic_power(F(1), 2)
+        sage: a.parent() is F
+        True
+
+        sage: generic_power(int(5), 0)
+        1
+        sage: generic_power(2, 5/4)
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: non-integral exponents not supported
+
+    ::
+
+        sage: class SymbolicMul(str):
+        ....:     def __mul__(self, other):
+        ....:         s = "({}*{})".format(self, other)
+        ....:         return type(self)(s)
+        sage: x = SymbolicMul("x")
+        sage: print(generic_power(x, 7))
+        (((x*x)*(x*x))*((x*x)*x))
+    """
+    if not n:
+        return one(a)
+
+    cdef long value = 0
+    cdef int err
+    if not integer_check_long(n, &value, &err):
+        raise NotImplementedError("non-integral exponents not supported")
+    if not err:
+        return generic_power_long(a, value)
+
+    if n < 0:
+        n = -n
+        a = invert(a)
+    return generic_power_pos(a, n)
+
+
+cdef generic_power_long(a, long n):
+    """
+    As ``generic_power`` but where ``n`` is a C long.
+    """
+    if not n:
+        return one(a)
+
+    cdef unsigned long u = <unsigned long>n
+    if n < 0:
+        u = -u
+        a = invert(a)
+    return generic_power_pos(a, u)
+
+
+cdef generic_power_pos(a, ulong_or_object n):
+    """
+    Return `a^n` where `n > 0`.
+    """
+    # Find least significant set bit as starting point
+    apow = a
+    while not (n & 1):
+        sig_check()
+        apow *= apow
+        n >>= 1
+
+    # Now multiply together the correct factors a^(2^i)
+    res = apow
+    n >>= 1
+    while n:
+        sig_check()
+        apow *= apow
+        if n & 1:
+            res = apow * res
+        n >>= 1
+
+    return res