passagemath-objects 10.8.1a3__cp314-cp314-win_amd64.whl

sage/groups/group.pyx

@@ -0,0 +1,296 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Base class for groups
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2005 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/
+# ****************************************************************************
+from sage.rings.infinity import infinity
+from sage.structure.parent cimport Parent
+
+
+cdef class Group(Parent):
+    """
+    Base class for all groups.
+
+    TESTS::
+
+        sage: from sage.groups.group import Group
+        sage: G = Group()
+        sage: TestSuite(G).run(skip = ["_test_an_element",\
+        ....:                          "_test_associativity",\
+        ....:                          "_test_elements",\
+        ....:                          "_test_elements_eq_reflexive",\
+        ....:                          "_test_elements_eq_symmetric",\
+        ....:                          "_test_elements_eq_transitive",\
+        ....:                          "_test_elements_neq",\
+        ....:                          "_test_inverse",\
+        ....:                          "_test_one",\
+        ....:                          "_test_pickling",\
+        ....:                          "_test_prod",\
+        ....:                          "_test_some_elements"])
+
+    Generic groups have very little functionality::
+
+        sage: 4 in G
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: cannot construct elements of <sage.groups.group.Group object at ...>
+    """
+    def __init__(self, base=None, category=None):
+        """
+        The Python constructor.
+
+        TESTS::
+
+            sage: from sage.groups.group import Group
+            sage: G = Group()
+            sage: G.category()
+            Category of groups
+            sage: G = Group(category=Groups()) # todo: do the same test with some subcategory of Groups when there will exist one
+            sage: G.category()
+            Category of groups
+            sage: G = Group(category=CommutativeAdditiveGroups())
+            Traceback (most recent call last):
+            ...
+            ValueError: (Category of commutative additive groups,) is not a subcategory of Category of groups
+            sage: G._repr_option('element_is_atomic')
+            False
+
+        Check for :issue:`8119`::
+
+            sage: # needs sage.groups
+            sage: G = SymmetricGroup(2)
+            sage: h = hash(G)
+            sage: G.rename('S2')
+            sage: h == hash(G)
+            True
+        """
+        from sage.categories.groups import Groups
+        if category is None:
+            category = Groups()
+        else:
+            if not isinstance(category, tuple):
+                category = (category,)
+            if not any(cat.is_subcategory(Groups()) for cat in category):
+                raise ValueError("%s is not a subcategory of %s" % (category, Groups()))
+        Parent.__init__(self, base=base, category=category)
+
+    def is_abelian(self) -> bool:
+        """
+        Test whether this group is abelian.
+
+        EXAMPLES::
+
+            sage: from sage.groups.group import Group
+            sage: G = Group()
+            sage: G.is_abelian()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+    def is_commutative(self) -> bool:
+        r"""
+        Test whether this group is commutative.
+
+        This is an alias for is_abelian, largely to make groups work
+        well with the Factorization class.
+
+        (Note for developers: Derived classes should override is_abelian, not
+        is_commutative.)
+
+        EXAMPLES::
+
+            sage: SL(2, 7).is_commutative()                                             # needs sage.libs.gap sage.modules sage.rings.finite_rings
+            False
+        """
+        return self.is_abelian()
+
+    def order(self):
+        """
+        Return the number of elements of this group.
+
+        This is either a positive integer or infinity.
+
+        EXAMPLES::
+
+            sage: from sage.groups.group import Group
+            sage: G = Group()
+            sage: G.order()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+
+        TESTS::
+
+            sage: H = SL(2, QQ)                                                         # needs sage.modules
+            sage: H.order()                                                             # needs sage.modules
+            +Infinity
+        """
+        try:
+            return self.cardinality()
+        except AttributeError:
+            raise NotImplementedError
+
+    def is_finite(self):
+        """
+        Return ``True`` if this group is finite.
+
+        EXAMPLES::
+
+            sage: from sage.groups.group import Group
+            sage: G = Group()
+            sage: G.is_finite()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        return self.order() != infinity
+
+    def is_trivial(self):
+        r"""
+        Return ``True`` if this group is the trivial group.
+
+        A group is trivial, if it consists only of the identity
+        element.
+
+        .. WARNING::
+
+            It is in principle undecidable whether a group is
+            trivial, for example, if the group is given by a finite
+            presentation.  Thus, this method may not terminate.
+
+        EXAMPLES::
+
+            sage: groups.presentation.Cyclic(1).is_trivial()                            # needs sage.groups
+            True
+
+            sage: # needs sage.groups
+            sage: G.<a,b> = FreeGroup('a, b')
+            sage: H = G / (a^2, b^3, a*b*~a*~b)
+            sage: H.is_trivial()
+            False
+
+        A non-trivial presentation of the trivial group::
+
+            sage: # needs sage.groups
+            sage: F.<a,b> = FreeGroup()
+            sage: J = F / ((~a)*b*a*(~b)^2, (~b)*a*b*(~a)^2)
+            sage: J.is_trivial()
+            True
+        """
+        return self.order() == 1
+
+    def is_multiplicative(self):
+        r"""
+        Return ``True`` if the group operation is given by ``*`` (rather than ``+``).
+
+        Override for additive groups.
+
+        EXAMPLES::
+
+            sage: from sage.groups.group import Group
+            sage: G = Group()
+            sage: G.is_multiplicative()
+            True
+        """
+        return True
+
+    def _an_element_(self):
+        """
+        Return an element.
+
+        OUTPUT: an element of the group
+
+        EXAMPLES::
+
+            sage: G = AbelianGroup([2,3,4,5])                                           # needs sage.modules
+            sage: G.an_element()                                                        # needs sage.modules
+            f0*f1*f2*f3
+        """
+        return self.prod(self.gens())
+
+    def quotient(self, H, **kwds):
+        """
+        Return the quotient of this group by the normal subgroup `H`.
+
+        EXAMPLES::
+
+            sage: from sage.groups.group import Group
+            sage: G = Group()
+            sage: G.quotient(G)
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+cdef class AbelianGroup(Group):
+    """
+    Generic abelian group.
+    """
+    def is_abelian(self) -> bool:
+        """
+        Return ``True``.
+
+        EXAMPLES::
+
+            sage: from sage.groups.group import AbelianGroup
+            sage: G = AbelianGroup()
+            sage: G.is_abelian()
+            True
+        """
+        return True
+
+cdef class FiniteGroup(Group):
+    """
+    Generic finite group.
+    """
+
+    def __init__(self, base=None, category=None):
+        """
+        The Python constructor.
+
+        TESTS::
+
+            sage: from sage.groups.group import FiniteGroup
+            sage: G = FiniteGroup()
+            sage: G.category()
+            Category of finite groups
+        """
+        from sage.categories.finite_groups import FiniteGroups
+        if category is None:
+            category = FiniteGroups()
+        else:
+            if not isinstance(category, tuple):
+                category = (category,)
+            if not any(cat.is_subcategory(FiniteGroups()) for cat in category):
+                raise ValueError("%s is not a subcategory of %s" % (category, FiniteGroups()))
+        Parent.__init__(self, base=base, category=category)
+
+    def is_finite(self):
+        """
+        Return ``True``.
+
+        EXAMPLES::
+
+            sage: from sage.groups.group import FiniteGroup
+            sage: G = FiniteGroup()
+            sage: G.is_finite()
+            True
+        """
+        return True

sage/groups/old.pxd

@@ -0,0 +1,14 @@
+# sage_setup: distribution = sagemath-objects
+cimport sage.structure.parent_gens
+
+cdef class Group(sage.structure.parent.Parent):
+    pass
+
+cdef class AbelianGroup(Group):
+    pass
+
+cdef class FiniteGroup(Group):
+    pass
+
+cdef class AlgebraicGroup(Group):
+    pass

sage/groups/old.pyx

@@ -0,0 +1,219 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Deprecated base class for groups
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2005 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/
+# ****************************************************************************
+
+doc = """
+Deprecated base class for all groups
+"""
+import sage.rings.integer_ring
+from sage.misc.superseded import deprecation
+
+
+cdef class Group(sage.structure.parent.Parent):
+    """
+    Generic group class.
+    """
+    def __init__(self, category=None):
+        """
+
+        TESTS::
+
+            sage: from sage.groups.old import Group
+            sage: G = Group()
+            doctest:warning...:
+            DeprecationWarning: do not use the old Group class
+            See https://github.com/sagemath/sage/issues/37449 for details.
+            sage: G.category()
+            Category of groups
+            sage: G = Group(category = Groups()) # todo: do the same test with some subcategory of Groups when there will exist one
+            sage: G.category()
+            Category of groups
+            sage: G = Group(category = CommutativeAdditiveGroups())
+            Traceback (most recent call last):
+            ...
+            AssertionError: Category of commutative additive groups is not a subcategory of Category of groups
+
+         Check for :issue:`8119`::
+
+            sage: # needs sage.groups
+            sage: G = SymmetricGroup(2)
+            sage: h = hash(G)
+            sage: G.rename('S2')
+            sage: h == hash(G)
+            True
+        """
+        deprecation(37449, 'do not use the old Group class')
+        from sage.categories.basic import Groups
+        if category is None:
+            category = Groups()
+        else:
+            assert category.is_subcategory(Groups()), "%s is not a subcategory of %s" % (category, Groups())
+
+        sage.structure.parent.Parent.__init__(self,
+                base=sage.rings.integer_ring.ZZ, category=category)
+
+    def __contains__(self, x):
+        r"""
+        Return ``True`` if coercion of ``x`` into ``self`` is defined.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import Group
+            sage: G = Group()
+            sage: 4 in G               #indirect doctest
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: cannot construct elements of <sage.groups.old.Group object at ...>
+        """
+        try:
+            self(x)
+        except TypeError:
+            return False
+        return True
+
+    def is_abelian(self):
+        """
+        Return ``True`` if this group is abelian.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import Group
+            sage: G = Group()
+            sage: G.is_abelian()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+    def is_commutative(self):
+        r"""
+        Return ``True`` if this group is commutative. This is an alias for
+        is_abelian, largely to make groups work well with the Factorization
+        class.
+
+        (Note for developers: Derived classes should override is_abelian, not
+        is_commutative.)
+
+        EXAMPLES::
+
+            sage: SL(2, 7).is_commutative()                                             # needs sage.libs.gap sage.modules
+            False
+        """
+        return self.is_abelian()
+
+    def order(self):
+        """
+        Return the number of elements of this group, which is either a
+        positive integer or infinity.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import Group
+            sage: G = Group()
+            sage: G.order()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+    def is_multiplicative(self):
+        r"""
+        Return ``True`` if the group operation is given by \* (rather than +).
+
+        Override for additive groups.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import Group
+            sage: G = Group()
+            sage: G.is_multiplicative()
+            True
+        """
+        return True
+
+    def random_element(self, bound=None):
+        """
+        Return a random element of this group.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import Group
+            sage: G = Group()
+            sage: G.random_element()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+    def quotient(self, H, **kwds):
+        """
+        Return the quotient of this group by the normal subgroup `H`.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import Group
+            sage: G = Group()
+            sage: G.quotient(G)
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+cdef class AbelianGroup(Group):
+    """
+    Generic abelian group.
+    """
+    def is_abelian(self):
+        """
+        Return True.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import AbelianGroup
+            sage: G = AbelianGroup()
+            sage: G.is_abelian()
+            True
+        """
+        return True
+
+cdef class FiniteGroup(Group):
+    """
+    Generic finite group.
+    """
+    def is_finite(self):
+        """
+        Return True.
+
+        EXAMPLES::
+
+            sage: from sage.groups.old import FiniteGroup
+            sage: G = FiniteGroup()
+            sage: G.is_finite()
+            True
+        """
+        return True
+
+cdef class AlgebraicGroup(Group):
+    """
+    Generic algebraic group.
+    """

sage/libs/all__sagemath_objects.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-objects
+# The presence of this file ensures that sage_setup for sagemath-objects
+# considers this directory as a namespace package

sage/libs/gmp/__init__.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-objects

sage/libs/gmp/all.pxd

@@ -0,0 +1,6 @@
+# sage_setup: distribution = sagemath-objects
+from sage.libs.gmp.types cimport *
+from sage.libs.gmp.random cimport *
+from sage.libs.gmp.mpz cimport *
+from sage.libs.gmp.mpq cimport *
+from sage.libs.gmp.pylong cimport *

sage/libs/gmp/binop.pxd

@@ -0,0 +1,23 @@
+# sage_setup: distribution = sagemath-objects
+r"""
+Fast binary operations for basic types
+"""
+
+from sage.libs.gmp.types cimport mpz_t, mpq_t
+from sage.libs.gmp.mpz cimport mpz_set, mpz_add, mpz_mul
+from sage.libs.gmp.mpq cimport mpq_canonicalize, mpq_numref, mpq_denref, mpq_add
+
+cdef inline void mpq_add_z(mpq_t res, mpq_t op1, mpz_t op2) noexcept:
+    mpz_mul(mpq_numref(res), mpq_denref(op1), op2)
+    mpz_add(mpq_numref(res), mpq_numref(res), mpq_numref(op1))
+    mpz_set(mpq_denref(res), mpq_denref(op1))
+
+cdef inline void mpq_div_zz(mpq_t res, mpz_t op1, mpz_t op2) noexcept:
+    mpz_set(mpq_numref(res), op1)
+    mpz_set(mpq_denref(res), op2)
+    mpq_canonicalize(res)
+
+cdef inline void mpq_mul_z(mpq_t res, mpq_t op1, mpz_t op2) noexcept:
+    # (A/B) * C = (C/B) * A
+    mpq_div_zz(res, op2, mpq_denref(op1))
+    mpz_mul(mpq_numref(res), mpq_numref(res), mpq_numref(op1))

sage/libs/gmp/misc.pxd

@@ -0,0 +1,8 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: libraries = gmp
+
+cdef extern from "gmp.h":
+    void mp_set_memory_functions(
+        void *(*) (size_t),
+        void *(*) (void *, size_t, size_t),
+        void (*) (void *, size_t))

sage/libs/gmp/mpf.pxd

@@ -0,0 +1,88 @@
+# sage_setup: distribution = sagemath-objects
+# distutils: libraries = gmp
+
+from sage.libs.gmp.types cimport *
+
+cdef extern from "gmp.h":
+
+    ### Floating-point Functions ###
+
+    # Initialization Functions
+    void mpf_set_default_prec (unsigned long int prec)
+    unsigned long int mpf_get_default_prec ()
+    void mpf_init (mpf_t x)
+    void mpf_init2 (mpf_t x, unsigned long int prec)
+    void mpf_clear (mpf_t x)
+    unsigned long int mpf_get_prec (mpf_t op)
+    void mpf_set_prec (mpf_t rop, unsigned long int prec)
+    void mpf_set_prec_raw (mpf_t rop, unsigned long int prec)
+
+    # Assignment Functions
+    void mpf_set (mpf_t rop, mpf_t op)
+    void mpf_set_ui (mpf_t rop, unsigned long int op)
+    void mpf_set_si (mpf_t rop, signed long int op)
+    void mpf_set_d (mpf_t rop, double op)
+    void mpf_set_z (mpf_t rop, mpz_t op)
+    void mpf_set_q (mpf_t rop, mpq_t op)
+    int mpf_set_str (mpf_t rop, char *str, int base)
+    void mpf_swap (mpf_t rop1, mpf_t rop2)
+
+    # Combined Initialization and Assignment Functions
+    void mpf_init_set (mpf_t rop, mpf_t op)
+    void mpf_init_set_ui (mpf_t rop, unsigned long int op)
+    void mpf_init_set_si (mpf_t rop, signed long int op)
+    void mpf_init_set_d (mpf_t rop, double op)
+    int mpf_init_set_str (mpf_t rop, char *str, int base)
+
+    # Conversion Functions
+    double mpf_get_d (mpf_t op)
+    double mpf_get_d_2exp (signed long int *exp, mpf_t op)
+    long mpf_get_si (mpf_t op)
+    unsigned long mpf_get_ui (mpf_t op)
+    char * mpf_get_str (char *str, mp_exp_t *expptr, int base, size_t n_digits, mpf_t op)
+
+    # Arithmetic Functions
+    void mpf_add (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_add_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_sub (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_ui_sub (mpf_t rop, unsigned long int op1, mpf_t op2)
+    void mpf_sub_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_mul (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_mul_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_div (mpf_t rop, mpf_t op1, mpf_t op2)
+    void mpf_ui_div (mpf_t rop, unsigned long int op1, mpf_t op2)
+    void mpf_div_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_sqrt (mpf_t rop, mpf_t op)
+    void mpf_sqrt_ui (mpf_t rop, unsigned long int op)
+    void mpf_pow_ui (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_neg (mpf_t rop, mpf_t op)
+    void mpf_abs (mpf_t rop, mpf_t op)
+    void mpf_mul_2exp (mpf_t rop, mpf_t op1, unsigned long int op2)
+    void mpf_div_2exp (mpf_t rop, mpf_t op1, unsigned long int op2)
+
+    # Comparison Functions
+    int mpf_cmp (mpf_t op1, mpf_t op2)
+    int mpf_cmp_d (mpf_t op1, double op2)
+    int mpf_cmp_ui (mpf_t op1, unsigned long int op2)
+    int mpf_cmp_si (mpf_t op1, signed long int op2)
+    int mpf_eq (mpf_t op1, mpf_t op2, unsigned long int op3)
+    void mpf_reldiff (mpf_t rop, mpf_t op1, mpf_t op2)
+    int mpf_sgn (mpf_t op)
+
+    # Input and Output Functions
+    # size_t mpf_out_str (file *stream, int base, size_t n_digits, mpf_t op)
+    # size_t mpf_inp_str (mpf_t rop, file *stream, int base)
+
+    # Miscellaneous Functions
+    void mpf_ceil (mpf_t rop, mpf_t op)
+    void mpf_floor (mpf_t rop, mpf_t op)
+    void mpf_trunc (mpf_t rop, mpf_t op)
+    bint mpf_integer_p (mpf_t op)
+    bint mpf_fits_ulong_p (mpf_t op)
+    bint mpf_fits_slong_p (mpf_t op)
+    bint mpf_fits_uint_p (mpf_t op)
+    bint mpf_fits_sint_p (mpf_t op)
+    bint mpf_fits_ushort_p (mpf_t op)
+    bint mpf_fits_sshort_p (mpf_t op)
+    void mpf_urandomb (mpf_t rop, gmp_randstate_t state, unsigned long int nbits)
+    void mpf_random2 (mpf_t rop, mp_size_t max_size, mp_exp_t exp)