passagemath-objects 10.6.45__cp313-cp313-musllinux_1_2_x86_64.whl

sage/structure/list_clone_demo.pyx

@@ -0,0 +1,248 @@
+# sage_setup: distribution = sagemath-objects
+r"""
+Elements, Array and Lists With Clone Protocol, demonstration classes
+
+This module demonstrate the usage of the various classes defined in
+:mod:`~sage.structure.list_clone`
+"""
+
+# ***************************************************************************
+#  Copyright (C) 2011 Florent Hivert <Florent.Hivert@univ-rouen.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+from sage.categories.sets_cat import Sets
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.structure.list_clone cimport (
+    ClonableArray, ClonableList, NormalizedClonableList, ClonableIntArray)
+from sage.structure.parent import Parent
+
+
+cdef class IncreasingArray(ClonableArray):
+    """
+    A small extension class for testing
+    :class:`~sage.structure.list_clone.ClonableArray`.
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import IncreasingArrays
+        sage: TestSuite(IncreasingArrays()([1,2,3])).run()
+        sage: TestSuite(IncreasingArrays()([])).run()
+    """
+
+    cpdef check(self):
+        """
+        Check that ``self`` is increasing.
+
+        EXAMPLES::
+
+            sage: from sage.structure.list_clone_demo import IncreasingArrays
+            sage: IncreasingArrays()([1,2,3]) # indirect doctest
+            [1, 2, 3]
+            sage: IncreasingArrays()([3,2,1]) # indirect doctest
+            Traceback (most recent call last):
+            ...
+            ValueError: array is not increasing
+        """
+        cdef int i
+        for i in range(len(self)-1):
+            if self._getitem(i) > self._getitem(i+1):
+                raise ValueError("array is not increasing")
+
+
+class IncreasingArrays(UniqueRepresentation, Parent):
+    """
+    A small (incomplete) parent for testing
+    :class:`~sage.structure.list_clone.ClonableArray`
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import IncreasingArrays
+        sage: IncreasingArrays().element_class
+        <... 'sage.structure.list_clone_demo.IncreasingArray'>
+    """
+
+    def __init__(self):
+        """
+        TESTS::
+
+            sage: from sage.structure.list_clone_demo import IncreasingArrays
+            sage: IncreasingArrays()
+            <sage.structure.list_clone_demo.IncreasingArrays_with_category object at ...>
+            sage: IncreasingArrays() == IncreasingArrays()
+            True
+        """
+        Parent.__init__(self, category = Sets())
+
+    def _element_constructor_(self, *args, **keywords):
+        """
+        TESTS::
+
+            sage: from sage.structure.list_clone_demo import IncreasingArrays
+            sage: IncreasingArrays()([1])     # indirect doctest
+            [1]
+        """
+        return self.element_class(self, *args, **keywords)
+
+    Element = IncreasingArray
+
+
+class IncreasingLists(IncreasingArrays):
+    """
+    A small (incomplete) parent for testing
+    :class:`~sage.structure.list_clone.ClonableList`
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import IncreasingLists
+        sage: IncreasingLists().element_class
+        <... 'sage.structure.list_clone_demo.IncreasingList'>
+    """
+    Element = IncreasingList
+
+
+cdef class IncreasingList(ClonableList):
+    """
+    A small extension class for testing
+    :class:`~sage.structure.list_clone.ClonableList`
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import IncreasingLists
+        sage: TestSuite(IncreasingLists()([1,2,3])).run()
+        sage: TestSuite(IncreasingLists()([])).run()
+    """
+
+    cpdef check(self):
+        """
+        Check that ``self`` is increasing.
+
+        EXAMPLES::
+
+            sage: from sage.structure.list_clone_demo import IncreasingLists
+            sage: IncreasingLists()([1,2,3]) # indirect doctest
+            [1, 2, 3]
+            sage: IncreasingLists()([3,2,1]) # indirect doctest
+            Traceback (most recent call last):
+            ...
+            ValueError: array is not increasing
+        """
+        cdef int i
+        for i in range(len(self)-1):
+            if self._getitem(i) >= self._getitem(i+1):
+                raise ValueError("array is not increasing")
+
+
+cdef class IncreasingIntArray(ClonableIntArray):
+    """
+    A small extension class for testing
+    :class:`~sage.structure.list_clone.ClonableIntArray`.
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import IncreasingIntArrays
+        sage: TestSuite(IncreasingIntArrays()([1,2,3])).run()
+        sage: TestSuite(IncreasingIntArrays()([])).run()
+    """
+
+    cpdef check(self):
+        """
+        Check that ``self`` is increasing.
+
+        EXAMPLES::
+
+            sage: from sage.structure.list_clone_demo import IncreasingIntArrays
+            sage: IncreasingIntArrays()([1,2,3]) # indirect doctest
+            [1, 2, 3]
+            sage: IncreasingIntArrays()([3,2,1]) # indirect doctest
+            Traceback (most recent call last):
+            ...
+            ValueError: array is not increasing
+        """
+        cdef int i
+        if not self:
+            return
+        for i in range(len(self)-1):
+            if self._getitem(i) >= self._getitem(i+1):
+                raise ValueError("array is not increasing")
+
+
+class IncreasingIntArrays(IncreasingArrays):
+    """
+    A small (incomplete) parent for testing
+    :class:`~sage.structure.list_clone.ClonableIntArray`
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import IncreasingIntArrays
+        sage: IncreasingIntArrays().element_class
+        <... 'sage.structure.list_clone_demo.IncreasingIntArray'>
+    """
+    Element = IncreasingIntArray
+
+
+cdef class SortedList(NormalizedClonableList):
+    """
+    A small extension class for testing
+    :class:`~sage.structure.list_clone.NormalizedClonableList`.
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import IncreasingIntArrays
+        sage: TestSuite(IncreasingIntArrays()([1,2,3])).run()
+        sage: TestSuite(IncreasingIntArrays()([])).run()
+    """
+    cpdef normalize(self):
+        """
+        Normalize ``self``.
+
+        Sort the list stored in ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.structure.list_clone_demo import SortedList, SortedLists
+            sage: l = SortedList(SortedLists(), [3,1,2], False, False)
+            sage: l         # indirect doctest
+            [1, 2, 3]
+            sage: l[1] = 5; l
+            [1, 5, 3]
+            sage: l.normalize(); l
+            [1, 3, 5]
+        """
+        self._require_mutable()
+        self._get_list().sort()
+
+    cpdef check(self):
+        """
+        Check that ``self`` is strictly increasing.
+
+        EXAMPLES::
+
+            sage: from sage.structure.list_clone_demo import SortedList, SortedLists
+            sage: SortedLists()([1,2,3]) # indirect doctest
+            [1, 2, 3]
+            sage: SortedLists()([3,2,2]) # indirect doctest
+            Traceback (most recent call last):
+            ...
+            ValueError: list is not strictly increasing
+        """
+        for i in range(len(self)-1):
+            if self._getitem(i) >= self._getitem(i+1):
+                raise ValueError("list is not strictly increasing")
+
+
+class SortedLists(IncreasingLists):
+    """
+    A small (incomplete) parent for testing
+    :class:`~sage.structure.list_clone.NormalizedClonableList`
+
+    TESTS::
+
+        sage: from sage.structure.list_clone_demo import SortedList, SortedLists
+        sage: SL = SortedLists()
+        sage: SL([3,1,2])
+        [1, 2, 3]
+    """
+    Element = SortedList

sage/structure/list_clone_timings.py

@@ -0,0 +1,179 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Performance Test for Clone Protocol
+
+see :class:`sage.structure.list_clone.ClonableArray`
+
+EXAMPLES::
+
+    sage: from sage.structure.list_clone_timings import *
+    sage: cmd =["",
+    ....:     "e.__copy__()",
+    ....:     "copy(e)",
+    ....:     "e.clone()",
+    ....:     "e.__class__(e.parent(), e._get_list())",
+    ....:     "e.__class__(e.parent(), e[:])",
+    ....:     "e.check()",
+    ....:     "",
+    ....:     "add1_internal(e)",
+    ....:     "add1_immutable(e)",
+    ....:     "add1_mutable(e)",
+    ....:     "add1_with(e)",
+    ....:     "",
+    ....:     "cy_add1_internal(e)",
+    ....:     "cy_add1_immutable(e)",
+    ....:     "cy_add1_mutable(e)",
+    ....:     "cy_add1_with(e)"]
+
+Various timings using a Cython class::
+
+    sage: size = 5
+    sage: e = IncreasingArrays()(range(size))
+    sage: # random
+    ....: for p in cmd:
+    ....:     print("{0:36} : ".format(p), end=""); timeit(p)
+                                         :
+    e.__copy__()                         :  625 loops, best of 3: 446 ns per loop
+    copy(e)                              :  625 loops, best of 3: 1.94 µs per loop
+    e.clone()                            :  625 loops, best of 3: 736 ns per loop
+    e.__class__(e.parent(), e._get_list()) :  625 loops, best of 3: 1.34 µs per loop
+    e.__class__(e.parent(), e[:])        :  625 loops, best of 3: 1.35 µs per loop
+    e.check()                            :  625 loops, best of 3: 342 ns per loop
+                                         :
+    add1_internal(e)                     :  625 loops, best of 3: 3.53 µs per loop
+    add1_immutable(e)                    :  625 loops, best of 3: 3.72 µs per loop
+    add1_mutable(e)                      :  625 loops, best of 3: 3.42 µs per loop
+    add1_with(e)                         :  625 loops, best of 3: 4.05 µs per loop
+                                         :
+    cy_add1_internal(e)                  :  625 loops, best of 3: 752 ns per loop
+    cy_add1_immutable(e)                 :  625 loops, best of 3: 1.28 µs per loop
+    cy_add1_mutable(e)                   :  625 loops, best of 3: 861 ns per loop
+    cy_add1_with(e)                      :  625 loops, best of 3: 1.51 µs per loop
+
+Various timings using a Python class::
+
+    sage: e = IncreasingArraysPy()(range(size))
+    sage: # random
+    ....: for p in cmd: print("{0:36} : ".format(p), end=""); timeit(p)
+                                         :
+    e.__copy__()                         :  625 loops, best of 3: 869 ns per loop
+    copy(e)                              :  625 loops, best of 3: 2.13 µs per loop
+    e.clone()                            :  625 loops, best of 3: 1.86 µs per loop
+    e.__class__(e.parent(), e._get_list()) :  625 loops, best of 3: 7.52 µs per loop
+    e.__class__(e.parent(), e[:])        :  625 loops, best of 3: 7.27 µs per loop
+    e.check()                            :  625 loops, best of 3: 4.02 µs per loop
+                                         :
+    add1_internal(e)                     :  625 loops, best of 3: 9.34 µs per loop
+    add1_immutable(e)                    :  625 loops, best of 3: 9.91 µs per loop
+    add1_mutable(e)                      :  625 loops, best of 3: 12.6 µs per loop
+    add1_with(e)                         :  625 loops, best of 3: 15.9 µs per loop
+                                         :
+    cy_add1_internal(e)                  :  625 loops, best of 3: 7.13 µs per loop
+    cy_add1_immutable(e)                 :  625 loops, best of 3: 6.95 µs per loop
+    cy_add1_mutable(e)                   :  625 loops, best of 3: 14.1 µs per loop
+    cy_add1_with(e)                      :  625 loops, best of 3: 17.5 µs per loop
+"""
+# ****************************************************************************
+#  Copyright (C) 2009-2010 Florent Hivert <Florent.Hivert@univ-rouen.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.structure.list_clone import ClonableArray
+from sage.structure.list_clone_demo import IncreasingArrays
+
+
+class IncreasingArraysPy(IncreasingArrays):
+
+    class Element(ClonableArray):
+        """
+        A small class for testing :class:`ClonableArray`: Increasing Lists.
+
+        TESTS::
+
+            sage: from sage.structure.list_clone_timings import IncreasingArraysPy
+            sage: TestSuite(IncreasingArraysPy()([1,2,3])).run()
+        """
+
+        def check(self):
+            """
+            Check that ``self`` is increasing.
+
+            EXAMPLES::
+
+                sage: from sage.structure.list_clone_timings import IncreasingArraysPy
+                sage: IncreasingArraysPy()([1,2,3]) # indirect doctest
+                [1, 2, 3]
+                sage: IncreasingArraysPy()([3,2,1]) # indirect doctest
+                Traceback (most recent call last):
+                ...
+                ValueError: Lists is not increasing
+            """
+            for i in range(len(self)-1):
+                if self[i] >= self[i+1]:
+                    raise ValueError("Lists is not increasing")
+
+
+#####################################################################
+#                         Timings functions                         #
+#####################################################################
+def add1_internal(bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings import *
+        sage: add1_internal(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    blo = bla.__copy__()
+    lst = blo._get_list()
+    for i in range(len(blo)):
+        lst[i] += 1
+    blo.set_immutable()
+    blo.check()
+    return blo
+
+
+def add1_immutable(bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings import *
+        sage: add1_immutable(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    lbla = bla[:]
+    for i in range(len(lbla)):
+        lbla[i] += 1
+    return bla.__class__(bla.parent(), lbla)
+
+
+def add1_mutable(bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings import *
+        sage: add1_mutable(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    blo = bla.__copy__()
+    for i in range(len(blo)):
+        blo[i] += 1
+    blo.set_immutable()
+    blo.check()
+    return blo
+
+
+def add1_with(bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings import *
+        sage: add1_with(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    with bla.clone() as blo:
+        for i in range(len(blo)):
+            blo[i] += 1
+    return blo

sage/structure/list_clone_timings_cy.pyx

@@ -0,0 +1,86 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Cython Functions for Timing Clone Protocol
+"""
+# ***************************************************************************
+#  Copyright (C) 2009-2010 Florent Hivert <Florent.Hivert@univ-rouen.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+from sage.structure.list_clone cimport ClonableArray
+
+
+#####################################################################
+######                    Timings functions                    ######
+#####################################################################
+cpdef ClonableArray cy_add1_internal(ClonableArray bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings_cy import *
+        sage: from sage.structure.list_clone_timings import *
+        sage: cy_add1_internal(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    cdef int i
+    cdef list lst
+    cdef ClonableArray blo
+    blo = bla.__copy__()
+    lst = blo._get_list()
+    for i in range(len(lst)): lst[i] += 1
+    blo.set_immutable()
+    blo.check()
+    return blo
+
+
+cpdef ClonableArray cy_add1_immutable(ClonableArray bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings import *
+        sage: from sage.structure.list_clone_timings_cy import *
+        sage: cy_add1_immutable(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    cdef int i
+    cdef list lbla
+    lbla = bla[:]
+    for i in range(len(lbla)): lbla[i] += 1
+    return bla.__class__(bla._parent, lbla)
+
+cpdef ClonableArray cy_add1_mutable(ClonableArray bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings import *
+        sage: from sage.structure.list_clone_timings_cy import *
+        sage: cy_add1_mutable(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    cdef int i
+    cdef ClonableArray blo
+    blo = bla.__copy__()
+    for i in range(len(blo)):
+        blo._setitem(i, blo._getitem(i)+1)
+    blo.set_immutable()
+    blo.check()
+    return blo
+
+
+cpdef ClonableArray cy_add1_with(ClonableArray bla):
+    """
+    TESTS::
+
+        sage: from sage.structure.list_clone_timings import *
+        sage: from sage.structure.list_clone_timings_cy import *
+        sage: cy_add1_with(IncreasingArrays()([1,4,5]))
+        [2, 5, 6]
+    """
+    cdef int i
+    cdef ClonableArray blo
+    with bla.__copy__() as blo:
+        for i in range(len(blo)):
+            blo._setitem(i, blo._getitem(i)+1)
+    return blo

sage/structure/mutability.pxd

@@ -0,0 +1,21 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Mutability -- Pyrex Implementation
+"""
+
+##########################################################################
+#
+#   Sage: Open Source Mathematical Software
+#
+#       Copyright (C) 2006 William Stein <wstein@ucsd.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+##########################################################################
+
+cdef class Mutability:
+    cdef public bint _is_immutable
+    cpdef _require_mutable(self)
+    cpdef _require_immutable(self)
+    cpdef bint is_immutable(self) noexcept
+    cpdef bint is_mutable(self) noexcept