passagemath-objects 10.6.44__cp314-cp314t-macosx_13_0_arm64.whl

sage/libs/gmp/types.pxd

@@ -0,0 +1,53 @@
+# sage_setup: distribution = sagemath-objects
+from libc.stdio cimport FILE
+
+cdef extern from "gmp.h":
+    # GMP's configuration of how many bits are stuffed into a limb
+    cdef unsigned int GMP_LIMB_BITS
+    cdef int mp_bits_per_limb
+
+    # Underlying typedefs
+    ctypedef unsigned long mp_limb_t
+    ctypedef long mp_limb_signed_t
+    ctypedef unsigned long mp_bitcnt_t
+    ctypedef long mp_size_t
+    ctypedef long mp_exp_t
+
+    ctypedef mp_limb_t* mp_ptr
+    ctypedef mp_limb_t* mp_srcptr
+
+    # This internal structure is not guaranteed to stay the same with
+    # future releases of GMP or MPIR.
+    ctypedef struct __mpz_struct:
+        int _mp_alloc
+        int _mp_size
+        mp_ptr _mp_d
+
+    ctypedef struct __mpq_struct:
+        __mpz_struct _mp_num
+        __mpz_struct _mp_den
+
+    ctypedef struct __mpf_struct:
+        int _mp_prec
+        int _mp_size
+        mp_exp_t _mp_exp
+        mp_limb_t *_mp_d
+
+    ctypedef struct __gmp_randstate_struct:
+        pass
+
+    # User facing types
+    ctypedef __mpz_struct mpz_t[1]
+    ctypedef __mpq_struct mpq_t[1]
+    ctypedef __mpf_struct mpf_t[1]
+    ctypedef __gmp_randstate_struct gmp_randstate_t[1]
+
+    ctypedef __mpz_struct *mpz_ptr
+    ctypedef __mpq_struct *mpq_ptr
+    ctypedef __mpf_struct *mpf_ptr
+    ctypedef __mpz_struct *mpz_srcptr
+    ctypedef __mpq_struct *mpq_srcptr
+    ctypedef __mpf_struct *mpf_srcptr
+
+    # Cython doesn't want to take the address of an mpz_t
+    cdef mpz_t* address_of_mpz "&"(mpz_t x)

sage/libs/gmpxx.pxd

@@ -0,0 +1,19 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: language = c++
+# distutils: libraries = gmpxx gmp
+
+from sage.libs.gmp.types cimport mpz_t, mpq_t
+
+cdef extern from 'gmpxx.h':
+    cdef cppclass mpz_class:
+        mpz_class()
+        mpz_class(int i)
+        mpz_class(mpz_t z)
+        mpz_class(mpz_class)
+        mpz_t get_mpz_t()
+        mpz_class operator % (mpz_class, mpz_class)
+
+    cdef cppclass mpq_class:
+        mpq_class()
+        mpz_t get_num_mpz_t()
+        mpz_t get_den_mpz_t()

sage/misc/abstract_method.py

@@ -0,0 +1,276 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Abstract methods
+"""
+# ****************************************************************************
+#       Copyright (C) 2008 Nicolas M. Thiery <nthiery at users.sf.net>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import types
+
+
+def abstract_method(f=None, optional=False):
+    r"""
+    Abstract methods.
+
+    INPUT:
+
+    - ``f`` -- a function
+    - ``optional`` -- boolean (default: ``False``)
+
+    The decorator :obj:`abstract_method` can be used to declare
+    methods that should be implemented by all concrete derived
+    classes. This declaration should typically include documentation
+    for the specification for this method.
+
+    The purpose is to enforce a consistent and visual syntax for such
+    declarations. It is used by the Sage categories for automated
+    tests (see ``Sets.Parent.test_not_implemented``).
+
+    EXAMPLES:
+
+    We create a class with an abstract method::
+
+        sage: class A():
+        ....:
+        ....:     @abstract_method
+        ....:     def my_method(self):
+        ....:         '''
+        ....:         The method :meth:`my_method` computes my_method
+        ....:
+        ....:         EXAMPLES::
+        ....:
+        ....:         '''
+        ....:         pass
+
+        sage: A.my_method
+        <abstract method my_method at ...>
+
+    The current policy is that a :exc:`NotImplementedError` is raised
+    when accessing the method through an instance, even before the
+    method is called::
+
+        sage: x = A()
+        sage: x.my_method
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: <abstract method my_method at ...>
+
+    It is also possible to mark abstract methods as optional::
+
+        sage: class A():
+        ....:
+        ....:     @abstract_method(optional = True)
+        ....:     def my_method(self):
+        ....:         '''
+        ....:         The method :meth:`my_method` computes my_method
+        ....:
+        ....:         EXAMPLES::
+        ....:
+        ....:         '''
+        ....:         pass
+
+        sage: A.my_method
+        <optional abstract method my_method at ...>
+
+        sage: x = A()
+        sage: x.my_method
+        NotImplemented
+
+    The official mantra for testing whether an optional abstract
+    method is implemented is::
+
+        sage: if x.my_method is not NotImplemented:
+        ....:     x.my_method()
+        ....: else:
+        ....:     print("x.my_method is not available.")
+        x.my_method is not available.
+
+    .. rubric:: Discussion
+
+    The policy details are not yet fixed. The purpose of this first
+    implementation is to let developers experiment with it and give
+    feedback on what's most practical.
+
+    The advantage of the current policy is that attempts at using a
+    non implemented methods are caught as early as possible. On the
+    other hand, one cannot use introspection directly to fetch the
+    documentation::
+
+        sage: x.my_method?      # todo: not implemented
+
+    Instead one needs to do::
+
+        sage: A._my_method?     # todo: not implemented
+
+    This could probably be fixed in :mod:`sage.misc.sageinspect`.
+
+    .. TODO:: what should be the recommended mantra for existence testing from the class?
+
+    .. TODO::
+
+        should extra information appear in the output? The name of the
+        class? That of the super class where the abstract method is
+        defined?
+
+    .. TODO:: look for similar decorators on the web, and merge
+
+    .. rubric:: Implementation details
+
+    Technically, an abstract_method is a non-data descriptor (see
+    Invoking Descriptors in the Python reference manual).
+
+    The syntax ``@abstract_method`` w.r.t. @abstract_method(optional = True)
+    is achieved by a little trick which we test here::
+
+        sage: abstract_method(optional = True)
+        <function abstract_method.<locals>.<lambda> at ...>
+        sage: abstract_method(optional = True)(version)
+        <optional abstract method version at ...>
+        sage: abstract_method(version, optional = True)
+        <optional abstract method version at ...>
+    """
+    if f is None:
+        return lambda f: AbstractMethod(f, optional=optional)
+    else:
+        return AbstractMethod(f, optional)
+
+
+class AbstractMethod:
+    def __init__(self, f, optional=False):
+        """
+        Constructor for abstract methods.
+
+        EXAMPLES::
+
+            sage: def f(x):
+            ....:     "doc of f"
+            ....:     return 1
+            sage: x = abstract_method(f); x
+            <abstract method f at ...>
+            sage: x.__doc__
+            'doc of f'
+            sage: x.__name__
+            'f'
+            sage: x.__module__
+            '__main__'
+        """
+        assert (isinstance(f, types.FunctionType) or
+                getattr(type(f), '__name__', None) == 'cython_function_or_method')
+        assert isinstance(optional, bool)
+        self._f = f
+        self._optional = optional
+        self.__doc__ = f.__doc__
+        self.__name__ = f.__name__
+        try:
+            self.__module__ = f.__module__
+        except AttributeError:
+            pass
+
+    def __repr__(self):
+        """
+        EXAMPLES::
+
+            sage: abstract_method(version)
+            <abstract method version at ...>
+
+            sage: abstract_method(version, optional = True)
+            <optional abstract method version at ...>
+        """
+        return "<" + ("optional " if self._optional else "") + "abstract method %s at %s>" % (self.__name__, hex(id(self._f)))
+
+    def _sage_src_lines_(self):
+        r"""
+        Return the source code location for the wrapped function.
+
+        EXAMPLES::
+
+            sage: from sage.misc.sageinspect import sage_getsourcelines
+            sage: g = abstract_method(version)
+            sage: (src, lines) = sage_getsourcelines(g)
+            sage: src[0]
+            'def version():\n'
+            sage: lines
+            20
+        """
+        from sage.misc.sageinspect import sage_getsourcelines
+        return sage_getsourcelines(self._f)
+
+    def __get__(self, instance, cls):
+        """
+        Implement the attribute access protocol.
+
+        EXAMPLES::
+
+            sage: class A: pass
+            sage: def f(x): return 1
+            sage: f = abstract_method(f)
+            sage: f.__get__(A(), A)
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: <abstract method f at ...>
+        """
+        if instance is None:
+            return self
+        elif self._optional:
+            return NotImplemented
+        else:
+            raise NotImplementedError(repr(self))
+
+    def is_optional(self):
+        """
+        Return whether an abstract method is optional or not.
+
+        EXAMPLES::
+
+            sage: class AbstractClass:
+            ....:     @abstract_method
+            ....:     def required(): pass
+            ....:
+            ....:     @abstract_method(optional = True)
+            ....:     def optional(): pass
+            sage: AbstractClass.required.is_optional()
+            False
+            sage: AbstractClass.optional.is_optional()
+            True
+        """
+        return self._optional
+
+
+def abstract_methods_of_class(cls):
+    """
+    Return the required and optional abstract methods of the class.
+
+    EXAMPLES::
+
+        sage: class AbstractClass:
+        ....:     @abstract_method
+        ....:     def required1(): pass
+        ....:
+        ....:     @abstract_method(optional = True)
+        ....:     def optional2(): pass
+        ....:
+        ....:     @abstract_method(optional = True)
+        ....:     def optional1(): pass
+        ....:
+        ....:     @abstract_method
+        ....:     def required2(): pass
+
+        sage: sage.misc.abstract_method.abstract_methods_of_class(AbstractClass)
+        {'optional': ['optional1', 'optional2'],
+         'required': ['required1', 'required2']}
+    """
+    result = {"required": [],
+              "optional": []}
+    for name in dir(cls):
+        entry = getattr(cls, name)
+        if not isinstance(entry, AbstractMethod):
+            continue
+        if entry.is_optional():
+            result["optional"].append(name)
+        else:
+            result["required"].append(name)
+    return result

sage/misc/all__sagemath_objects.py

@@ -0,0 +1,43 @@
+# sage_setup: distribution = sagemath-objects
+# Subset of sage.misc.all that is made available by the sage-objects distribution
+
+import sage.structure.all   # to break a cyclic import
+
+from sage.misc.lazy_attribute import lazy_attribute, lazy_class_attribute
+from sage.misc.lazy_import import lazy_import
+
+from sage.misc.verbose import (set_verbose, set_verbose_files,
+                               get_verbose_files, unset_verbose_files, get_verbose)
+lazy_import('sage.misc.verbose', 'verbose',
+            deprecation=17815)
+from sage.misc.call import attrcall
+
+from sage.misc.misc_c import prod, running_total, balanced_sum
+mul = prod
+add = sum
+
+from sage.misc.repr import repr_lincomb
+
+from sage.misc.flatten import flatten
+
+from sage.misc.persist import save, load, dumps, loads, db, db_save
+
+from sage.misc.constant_function import ConstantFunction
+
+from sage.misc.sage_unittest import TestSuite
+
+from sage.misc.decorators import specialize, sage_wraps, infix_operator
+
+from sage.misc.unknown import Unknown, UnknownError
+
+from sage.misc.cachefunc import CachedFunction, cached_function, cached_method, cached_in_parent_method, disk_cached_function
+
+from sage.misc.abstract_method import abstract_method
+
+from sage.misc.timing import walltime, cputime
+
+from sage.misc.randstate import seed, set_random_seed, initial_seed, current_randstate
+from sage.misc.prandom import *
+from sage.misc.sage_timeit_class import timeit
+from sage.misc.session import load_session, save_session, show_identifiers
+from sage.misc.reset import reset, restore

sage/misc/bindable_class.py

@@ -0,0 +1,253 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Bindable classes
+"""
+# ****************************************************************************
+#       Copyright (C) 2012 Nicolas M. Thiery <nthiery at users.sf.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/
+# ****************************************************************************
+import functools
+from sage.misc.nested_class import NestedClassMetaclass
+from sage.misc.classcall_metaclass import ClasscallMetaclass
+
+
+class BindableClass(metaclass=ClasscallMetaclass):
+    """
+    Bindable classes.
+
+    This class implements a binding behavior for nested classes that
+    derive from it. Namely, if a nested class ``Outer.Inner`` derives
+    from ``BindableClass``, and if ``outer`` is an instance of
+    ``Outer``, then ``outer.Inner(...)`` is equivalent to
+    ``Outer.Inner(outer, ...)``.
+
+    EXAMPLES:
+
+    Let us consider the following class ``Outer`` with a nested class ``Inner``::
+
+        sage: from sage.misc.nested_class import NestedClassMetaclass
+        sage: class Outer(metaclass=NestedClassMetaclass):
+        ....:     class Inner:
+        ....:         def __init__(self, *args):
+        ....:             print(args)
+        ....:     def f(self, *args):
+        ....:         print("{} {}".format(self, args))
+        ....:     @staticmethod
+        ....:     def f_static(*args):
+        ....:         print(args)
+
+        sage: outer = Outer()
+
+    By default, when ``Inner`` is a class nested in ``Outer``,
+    accessing ``outer.Inner`` returns the ``Inner`` class as is::
+
+        sage: outer.Inner is Outer.Inner
+        True
+
+    In particular, ``outer`` is completely ignored in the following call::
+
+        sage: x = outer.Inner(1,2,3)
+        (1, 2, 3)
+
+    This is similar to what happens with a static method::
+
+        sage: outer.f_static(1,2,3)
+        (1, 2, 3)
+
+    In some cases, we would want instead ``Inner`` to receive ``outer``
+    as parameter, like in a usual method call::
+
+        sage: outer.f(1,2,3)
+        <__main__.Outer object at ...> (1, 2, 3)
+
+    To this end, ``outer.f`` returns a *bound method*::
+
+        sage: outer.f
+        <bound method Outer.f of <__main__.Outer object at ...>>
+
+    so that ``outer.f(1,2,3)`` is equivalent to::
+
+        sage: Outer.f(outer, 1,2,3)
+        <__main__.Outer object at ...> (1, 2, 3)
+
+    :class:`BindableClass` gives this binding behavior to all its subclasses::
+
+        sage: from sage.misc.bindable_class import BindableClass
+        sage: class Outer(metaclass=NestedClassMetaclass):
+        ....:     class Inner(BindableClass):
+        ....:         " some documentation "
+        ....:         def __init__(self, outer, *args):
+        ....:             print("{} {}".format(outer, args))
+
+    Calling ``Outer.Inner`` returns the (unbound) class as usual::
+
+        sage: Outer.Inner
+        <class '__main__.Outer.Inner'>
+
+    However, ``outer.Inner(1,2,3)`` is equivalent to ``Outer.Inner(outer, 1,2,3)``::
+
+        sage: outer = Outer()
+        sage: x = outer.Inner(1,2,3)
+        <__main__.Outer object at ...> (1, 2, 3)
+
+    To achieve this, ``outer.Inner`` returns (some sort of) bound class::
+
+        sage: outer.Inner
+        <bound class '__main__.Outer.Inner' of <__main__.Outer object at ...>>
+
+    .. NOTE::
+
+        This is not actually a class, but an instance of
+        :class:`functools.partial`::
+
+            sage: type(outer.Inner).mro()
+            [<class 'sage.misc.bindable_class.BoundClass'>,
+             <... 'functools.partial'>,
+             <... 'object'>]
+
+        Still, documentation works as usual::
+
+            sage: outer.Inner.__doc__
+            '...some documentation '
+
+    TESTS::
+
+        sage: from sage.misc.bindable_class import Outer
+        sage: TestSuite(Outer.Inner).run()
+        sage: outer = Outer()
+        sage: TestSuite(outer.Inner).run(skip=["_test_pickling"])
+    """
+    @staticmethod
+    def __classget__(cls, instance, owner):
+        """
+        Bind ``cls`` to ``instance``, returning a ``BoundClass``.
+
+        INPUT:
+
+        - ``instance`` -- an object of the outer class or ``None``
+
+        For technical details, see the Section :python:`Implementing Descriptor
+        <reference/datamodel.html#implementing-descriptors>` in the Python
+        reference manual.
+
+        EXAMPLES::
+
+            sage: from sage.misc.bindable_class import Outer
+            sage: Outer.Inner
+            <class 'sage.misc.bindable_class.Outer.Inner'>
+            sage: Outer().Inner
+            <bound class 'sage.misc.bindable_class.Outer.Inner' of <sage.misc.bindable_class.Outer object at ...>>
+        """
+        if instance is None:
+            return cls
+        return BoundClass(cls, instance)
+        # We probably do not need to use sage_wraps, since
+        # sageinspect already supports partial functions
+        # return sage_wraps(cls)(BoundClass(cls, instance))
+
+
+class BoundClass(functools.partial):
+    """
+    TESTS::
+
+        sage: from sage.misc.sageinspect import *
+        sage: from sage.misc.bindable_class import Outer
+        sage: x = Outer()
+        sage: c = x.Inner; c
+        <bound class 'sage.misc.bindable_class.Outer.Inner' of <sage.misc.bindable_class.Outer object at ...>>
+
+    Introspection works, at least partially::
+
+        sage: sage_getdoc(c).strip()
+        'Some documentation for Outer.Inner'
+        sage: sage_getfile(c)
+        '.../sage/misc/bindable_class.py'
+
+        sage: c = x.Inner2
+        sage: sage_getdoc(c).strip()
+        'Some documentation for Inner2'
+        sage: sage_getsourcelines(c)
+        (['class Inner2(BindableClass):...], ...)
+
+    .. warning::
+
+        Since ``c`` is not a class (as tested by :func:`inspect.isclass`),
+        and has a ``__call__`` method, IPython's introspection
+        (with ``c?``) insists on showing not only its
+        documentation but also its class documentation and call
+        documentation (see :meth:`IPython.OInspect.Inspector.pdoc`)
+        if available.
+
+        Until a better approach is found, we reset the documentation
+        of :class:`BoundClass` below, and make an exception for
+        :meth:`__init__` to the strict rule that every method should
+        be doctested::
+
+            sage: c.__class__.__doc__
+            sage: c.__class__.__init__.__doc__
+
+    Make sure classes which inherit from :class:`functools.partial` have the correct
+    syntax, see :issue:`14748`::
+
+        sage: import warnings
+        sage: warnings.simplefilter('error', DeprecationWarning)
+        sage: import functools
+        sage: def f(x, y): return x^y
+        sage: g = functools.partial(f, 2, 3)
+        sage: g()
+        8
+
+    The following has correct syntax and no :class:`DeprecationWarning`::
+
+        sage: class mynewpartial(functools.partial):
+        ....:     def __init__(self, f, i, j):
+        ....:         functools.partial.__init__(self)
+        sage: g = mynewpartial(f, 2, 3)
+        sage: g()
+        8
+    """
+    __doc__ = None  # See warning above
+
+    def __init__(self, *args):
+        super().__init__()
+        self.__doc__ = self.func.__doc__
+
+    def __repr__(self):
+        """
+        TESTS:
+
+            sage: from sage.misc.bindable_class import Outer
+            sage: x = Outer(); x
+            <sage.misc.bindable_class.Outer object at ...>
+            sage: x.Inner
+            <bound class 'sage.misc.bindable_class.Outer.Inner' of <sage.misc.bindable_class.Outer object at ...>>
+        """
+        return "<bound %s of %s>" % (repr(self.func)[1:-1], self.args[0])
+
+
+##############################################################################
+# Test classes
+##############################################################################
+
+class Inner2(BindableClass):
+    """
+    Some documentation for Inner2
+    """
+
+
+# We need NestedClassMetaclass to work around a Python pickling bug
+class Outer(metaclass=NestedClassMetaclass):
+    """
+    A class with a bindable nested class, for testing purposes
+    """
+    class Inner(BindableClass):
+        """
+        Some documentation for Outer.Inner
+        """
+
+    Inner2 = Inner2

sage/misc/c3_controlled.pxd

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-objects
+cpdef tuple C3_sorted_merge(list lists, key=?)