passagemath-modules 10.6.31rc3__cp314-cp314-musllinux_1_2_x86_64.whl

sage/homology/koszul_complex.py

@@ -0,0 +1,169 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Koszul Complexes
+"""
+########################################################################
+#       Copyright (C) 2014 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  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.unique_representation import UniqueRepresentation
+from sage.structure.parent import Parent
+from sage.combinat.combination import rank
+from sage.arith.misc import binomial
+from sage.rings.integer_ring import ZZ
+from sage.matrix.constructor import matrix
+from sage.homology.chain_complex import ChainComplex_class
+
+import itertools
+
+
+class KoszulComplex(ChainComplex_class, UniqueRepresentation):
+    r"""
+    A Koszul complex.
+
+    Let `R` be a ring and consider `x_1, x_2, \ldots, x_n \in R`. The
+    *Koszul complex* `K_*(x_1, \ldots, x_n)` is given by defining a
+    chain complex structure on the exterior algebra `\bigwedge^n R` with
+    the basis `e_{i_1} \wedge \cdots \wedge e_{i_a}`. The differential is
+    given by
+
+    .. MATH::
+
+        \partial(e_{i_1} \wedge \cdots \wedge e_{i_a}) =
+        \sum_{r=1}^a (-1)^{r-1} x_{i_r} e_{i_1} \wedge \cdots \wedge
+        \hat{e}_{i_r} \wedge \cdots \wedge e_{i_a},
+
+    where `\hat{e}_{i_r}` denotes the omitted factor.
+
+    Alternatively we can describe the Koszul complex by considering the
+    basic complex `K_{x_i}`
+
+    .. MATH::
+
+        0 \rightarrow R \xrightarrow{x_i} R \rightarrow 0.
+
+    Then the Koszul complex is given by
+    `K_*(x_1, \ldots, x_n) = \bigotimes_i K_{x_i}`.
+
+    INPUT:
+
+    - ``R`` -- the base ring
+    - ``elements`` -- tuple of elements of `R`
+
+    EXAMPLES::
+
+        sage: R.<x,y,z> = QQ[]
+        sage: K = KoszulComplex(R, [x,y])
+        sage: ascii_art(K)
+                                [-y]
+                    [x y]       [ x]
+         0 <-- C_0 <------ C_1 <----- C_2 <-- 0
+        sage: K = KoszulComplex(R, [x,y,z])
+        sage: ascii_art(K)
+                                  [-y -z  0]       [ z]
+                                  [ x  0 -z]       [-y]
+                    [x y z]       [ 0  x  y]       [ x]
+         0 <-- C_0 <-------- C_1 <----------- C_2 <----- C_3 <-- 0
+        sage: K = KoszulComplex(R, [x+y*z,x+y-z])
+        sage: ascii_art(K)
+                                                [-x - y + z]
+                    [  y*z + x x + y - z]       [   y*z + x]
+         0 <-- C_0 <---------------------- C_1 <------------- C_2 <-- 0
+
+    REFERENCES:
+
+    - :wikipedia:`Koszul_complex`
+    """
+    @staticmethod
+    def __classcall_private__(cls, R=None, elements=None):
+        """
+        Normalize input to ensure a unique representation.
+
+        TESTS::
+
+            sage: R.<x,y,z> = QQ[]
+            sage: K1 = KoszulComplex(R, [x,y,z])
+            sage: K2 = KoszulComplex(R, (x,y,z))
+            sage: K3 = KoszulComplex((x,y,z))
+            sage: K1 is K2 and K2 is K3
+            True
+
+        Check some corner cases::
+
+            sage: K1 = KoszulComplex(ZZ)
+            sage: K2 = KoszulComplex(())
+            sage: K3 = KoszulComplex(ZZ, [])
+            sage: K1 is K2 and K2 is K3
+            True
+            sage: K1 is KoszulComplex()
+            True
+        """
+        if elements is None:
+            if R is None:
+                R = ()
+            elements = R
+            if not elements:
+                R = ZZ  # default to ZZ as the base ring if no elements are given
+            elif isinstance(R, Parent):
+                elements = ()
+            else:
+                R = elements[0].parent()
+        elif R is None:  # elements is not None
+            R = elements[0].parent()
+        return super().__classcall__(cls, R, tuple(elements))
+
+    def __init__(self, R, elements):
+        """
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: R.<x,y,z> = QQ[]
+            sage: K = KoszulComplex(R, [x,y])
+            sage: TestSuite(K).run()
+        """
+        # Generate the differentials
+        self._elements = elements
+        n = len(elements)
+        I = list(range(n))
+        diff = {}
+        zero = R.zero()
+        for i in I:
+            M = matrix(R, binomial(n, i), binomial(n, i+1), zero)
+            j = 0
+            for comb in itertools.combinations(I, i+1):
+                for k, val in enumerate(comb):
+                    r = rank(comb[:k] + comb[k+1:], n, False)
+                    M[r, j] = (-1)**k * elements[val]
+                j += 1
+            M.set_immutable()
+            diff[i+1] = M
+        diff[0] = matrix(R, 0, 1, zero)
+        diff[0].set_immutable()
+        diff[n+1] = matrix(R, 1, 0, zero)
+        diff[n+1].set_immutable()
+        ChainComplex_class.__init__(self, ZZ, ZZ(-1), R, diff)
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: R.<x,y,z> = QQ[]
+            sage: KoszulComplex(R, [x,y,z])
+            Koszul complex defined by (x, y, z) over
+             Multivariate Polynomial Ring in x, y, z over Rational Field
+
+            sage: KoszulComplex(ZZ, [])
+            Trivial Koszul complex over Integer Ring
+        """
+        if not self._elements:
+            return "Trivial Koszul complex over {}".format(self.base_ring())
+        return "Koszul complex defined by {} over {}".format(self._elements, self.base_ring())

sage/homology/matrix_utils.py

@@ -0,0 +1,205 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Utility Functions for Matrices
+
+The actual computation of homology groups ends up being linear algebra
+with the differentials thought of as matrices. This module contains
+some utility functions for this purpose.
+"""
+########################################################################
+#       Copyright (C) 2013 John H. Palmieri <palmieri@math.washington.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  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/
+########################################################################
+
+# TODO: this module is a clear candidate for cythonizing. Need to
+# evaluate speed benefits.
+
+from sage.matrix.constructor import matrix
+
+
+def dhsw_snf(mat, verbose=False):
+    """
+    Preprocess a matrix using the "Elimination algorithm" described by
+    Dumas et al. [DHSW2003]_, and then call ``elementary_divisors`` on the
+    resulting (smaller) matrix.
+
+    .. NOTE::
+
+        'snf' stands for 'Smith Normal Form'.
+
+    INPUT:
+
+    - ``mat`` -- integer matrix, either sparse or dense
+
+    (They use the transpose of the matrix considered here, so they use
+    rows instead of columns.)
+
+    ALGORITHM:
+
+    Go through ``mat`` one column at a time.  For each
+    column, add multiples of previous columns to it until either
+
+    - it's zero, in which case it should be deleted.
+    - its first nonzero entry is 1 or -1, in which case it should be kept.
+    - its first nonzero entry is something else, in which case it is
+      deferred until the second pass.
+
+    Then do a second pass on the deferred columns.
+
+    At this point, the columns with 1 or -1 in the first entry
+    contribute to the rank of the matrix, and these can be counted and
+    then deleted (after using the 1 or -1 entry to clear out its row).
+    Suppose that there were `N` of these.
+
+    The resulting matrix should be much smaller; we then feed it
+    to Sage's ``elementary_divisors`` function, and prepend `N` 1s to
+    account for the rows deleted in the previous step.
+
+    EXAMPLES::
+
+        sage: from sage.homology.matrix_utils import dhsw_snf
+        sage: mat = matrix(ZZ, 3, 4, range(12))
+        sage: dhsw_snf(mat)                                                             # needs sage.libs.pari
+        [1, 4, 0]
+        sage: mat = random_matrix(ZZ, 20, 20, x=-1, y=2)
+        sage: mat.elementary_divisors() == dhsw_snf(mat)                                # needs sage.libs.pari
+        True
+    """
+    ring = mat.base_ring()
+    rows = mat.nrows()
+    cols = mat.ncols()
+    new_data = {}
+    new_mat = matrix(ring, rows, cols, new_data)
+    add_to_rank = 0
+    zero_cols = 0
+    if verbose:
+        print("old matrix: %s by %s" % (rows, cols))
+    # leading_positions: dictionary of lists indexed by row: if first
+    # nonzero entry in column c is in row r, then leading_positions[r]
+    # should contain c
+    leading_positions = {}
+    # pass 1:
+    if verbose:
+        print("starting pass 1")
+    for j in range(cols):
+        # new_col is a matrix with one column: sparse matrices seem to
+        # be less buggy than sparse vectors (#5184, #5185), and
+        # perhaps also faster.
+        new_col = mat.matrix_from_columns([j])
+        if new_col.is_zero():
+            zero_cols += 1
+        else:
+            check_leading = True
+            while check_leading:
+                i = new_col.nonzero_positions_in_column(0)[0]
+                entry = new_col[i, 0]
+                check_leading = False
+                if i in leading_positions:
+                    for c in leading_positions[i]:
+                        earlier = new_mat[i, c]
+                        # right now we don't check to see if entry divides
+                        # earlier, because we don't want to modify the
+                        # earlier columns of the matrix.  Deal with this
+                        # in pass 2.
+                        if entry and earlier.divides(entry):
+                            quo = entry.divide_knowing_divisible_by(earlier)
+                            new_col = new_col - quo * new_mat.matrix_from_columns([c])
+                            entry = 0
+                            if not new_col.is_zero():
+                                check_leading = True
+            if not new_col.is_zero():
+                new_mat.set_column(j-zero_cols, new_col.column(0))
+                i = new_col.nonzero_positions_in_column(0)[0]
+                if i in leading_positions:
+                    leading_positions[i].append(j-zero_cols)
+                else:
+                    leading_positions[i] = [j-zero_cols]
+            else:
+                zero_cols += 1
+    # pass 2:
+    # first eliminate the zero columns at the end
+    cols = cols - zero_cols
+    zero_cols = 0
+    new_mat = new_mat.matrix_from_columns(range(cols))
+    if verbose:
+        print("starting pass 2")
+    keep_columns = list(range(cols))
+    check_leading = True
+    while check_leading:
+        check_leading = False
+        new_leading = leading_positions.copy()
+        for i in leading_positions:
+            if len(leading_positions[i]) > 1:
+                j = leading_positions[i][0]
+                jth = new_mat[i, j]
+                for n in leading_positions[i][1:]:
+                    nth = new_mat[i, n]
+                    if jth.divides(nth):
+                        quo = nth.divide_knowing_divisible_by(jth)
+                        new_mat.add_multiple_of_column(n, j, -quo)
+                    elif nth.divides(jth):
+                        quo = jth.divide_knowing_divisible_by(nth)
+                        jth = nth
+                        new_mat.swap_columns(n, j)
+                        new_mat.add_multiple_of_column(n, j, -quo)
+                    else:
+                        g, r, s = jth.xgcd(nth)
+                        unit, A, B = r.xgcd(-s)  # unit ought to be 1 here
+                        jth_col = new_mat.column(j)
+                        nth_col = new_mat.column(n)
+                        new_mat.set_column(j, r*jth_col + s*nth_col)
+                        new_mat.set_column(n, B*jth_col + A*nth_col)
+                        nth = B*jth + A*nth
+                        jth = g
+                        # at this point, jth should divide nth
+                        quo = nth.divide_knowing_divisible_by(jth)
+                        new_mat.add_multiple_of_column(n, j, -quo)
+                    new_leading[i].remove(n)
+                    if new_mat.column(n).is_zero():
+                        keep_columns.remove(n)
+                        zero_cols += 1
+                    else:
+                        new_r = new_mat.column(n).nonzero_positions()[0]
+                        if new_r in new_leading:
+                            new_leading[new_r].append(n)
+                        else:
+                            new_leading[new_r] = [n]
+                        check_leading = True
+        leading_positions = new_leading
+    # pass 3: get rid of columns which start with 1 or -1
+    if verbose:
+        print("starting pass 3")
+    max_leading = 1
+    for i in leading_positions:
+        j = leading_positions[i][0]
+        entry = new_mat[i, j]
+        if entry.abs() == 1:
+            add_to_rank += 1
+            keep_columns.remove(j)
+            for c in new_mat.nonzero_positions_in_row(i):
+                if c in keep_columns:
+                    new_mat.add_multiple_of_column(c, j, -entry * new_mat[i, c])
+        else:
+            max_leading = max(max_leading, new_mat[i, j].abs())
+    # form the new matrix
+    if max_leading != 1:
+        new_mat = new_mat.matrix_from_columns(keep_columns)
+        if verbose:
+            print("new matrix: %s by %s" % (new_mat.nrows(), new_mat.ncols()))
+        if new_mat.is_sparse():
+            ed = [1]*add_to_rank + new_mat.dense_matrix().elementary_divisors()
+        else:
+            ed = [1]*add_to_rank + new_mat.elementary_divisors()
+    else:
+        if verbose:
+            print("new matrix: all pivots are 1 or -1")
+        ed = [1]*add_to_rank
+
+    if len(ed) < rows:
+        return ed + [0]*(rows - len(ed))
+    return ed[:rows]

sage/libs/all__sagemath_modules.py

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

sage/libs/gsl/__init__.py

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

sage/libs/gsl/airy.pxd

@@ -0,0 +1,56 @@
+# sage_setup: distribution = sagemath-modules
+# distutils: libraries = GSL_LIBRARIES
+# distutils: library_dirs = GSL_LIBDIR
+# distutils: include_dirs = GSL_INCDIR
+from sage.libs.gsl.types cimport *
+
+cdef extern from "gsl/gsl_sf_airy.h":
+
+  double  gsl_sf_airy_Ai(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Ai_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_Bi(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Bi_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_Ai_scaled(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Ai_scaled_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_Bi_scaled(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Bi_scaled_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_Ai_deriv(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Ai_deriv_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_Bi_deriv(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Bi_deriv_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_Ai_deriv_scaled(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Ai_deriv_scaled_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_Bi_deriv_scaled(double x, gsl_mode_t mode)
+
+  int  gsl_sf_airy_Bi_deriv_scaled_e(double x, gsl_mode_t mode, gsl_sf_result * result)
+
+  double  gsl_sf_airy_zero_Ai(unsigned int s)
+
+  int  gsl_sf_airy_zero_Ai_e(unsigned int s, gsl_sf_result * result)
+
+  double  gsl_sf_airy_zero_Bi(unsigned int s)
+
+  int  gsl_sf_airy_zero_Bi_e(unsigned int s, gsl_sf_result * result)
+
+  double  gsl_sf_airy_zero_Ai_deriv(unsigned int s)
+
+  int  gsl_sf_airy_zero_Ai_deriv_e(unsigned int s, gsl_sf_result * result)
+
+  double  gsl_sf_airy_zero_Bi_deriv(unsigned int s)
+
+  int  gsl_sf_airy_zero_Bi_deriv_e(unsigned int s, gsl_sf_result * result)
+

sage/libs/gsl/all.pxd

@@ -0,0 +1,66 @@
+# sage_setup: distribution = sagemath-modules
+from sage.libs.gsl.types cimport *
+
+from sage.libs.gsl.math cimport *
+from sage.libs.gsl.complex cimport *
+from sage.libs.gsl.poly cimport *
+from sage.libs.gsl.airy cimport *
+from sage.libs.gsl.bessel cimport *
+from sage.libs.gsl.clausen cimport *
+from sage.libs.gsl.coulomb cimport *
+from sage.libs.gsl.coupling cimport *
+from sage.libs.gsl.dawson cimport *
+from sage.libs.gsl.debye cimport *
+from sage.libs.gsl.dilog cimport *
+from sage.libs.gsl.elementary cimport *
+from sage.libs.gsl.ellint cimport *
+from sage.libs.gsl.elljac cimport *
+from sage.libs.gsl.erf cimport *
+from sage.libs.gsl.exp cimport *
+from sage.libs.gsl.expint cimport *
+from sage.libs.gsl.fermi_dirac cimport *
+from sage.libs.gsl.gamma cimport *
+from sage.libs.gsl.gegenbauer cimport *
+from sage.libs.gsl.hyperg cimport *
+from sage.libs.gsl.laguerre cimport *
+from sage.libs.gsl.lambert cimport *
+from sage.libs.gsl.legendre cimport *
+from sage.libs.gsl.log cimport *
+from sage.libs.gsl.pow_int cimport *
+from sage.libs.gsl.psi cimport *
+from sage.libs.gsl.synchrotron cimport *
+from sage.libs.gsl.transport cimport *
+from sage.libs.gsl.trig cimport *
+from sage.libs.gsl.wavelet cimport *
+from sage.libs.gsl.zeta cimport *
+
+from sage.libs.gsl.block cimport *
+from sage.libs.gsl.vector cimport *
+from sage.libs.gsl.vector_complex cimport *
+from sage.libs.gsl.matrix cimport *
+from sage.libs.gsl.matrix_complex cimport *
+
+from sage.libs.gsl.permutation cimport *
+from sage.libs.gsl.combination cimport *
+from sage.libs.gsl.sort cimport *
+
+from sage.libs.gsl.blas cimport *
+from sage.libs.gsl.linalg cimport *
+from sage.libs.gsl.eigen cimport *
+from sage.libs.gsl.fft cimport *
+from sage.libs.gsl.integration cimport *
+from sage.libs.gsl.rng cimport *
+from sage.libs.gsl.qrng cimport *
+from sage.libs.gsl.random cimport *
+from sage.libs.gsl.statistics cimport *
+from sage.libs.gsl.histogram cimport *
+from sage.libs.gsl.ntuple cimport *
+from sage.libs.gsl.monte cimport *
+from sage.libs.gsl.odeiv cimport *
+from sage.libs.gsl.interp cimport *
+from sage.libs.gsl.chebyshev cimport *
+from sage.libs.gsl.sum cimport *
+from sage.libs.gsl.roots cimport *
+from sage.libs.gsl.min cimport *
+from sage.libs.gsl.fit cimport *
+from sage.libs.gsl.errno cimport *

sage/libs/gsl/array.pxd

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-modules
+cdef class GSLDoubleArray:
+    cdef size_t n
+    cdef size_t stride
+    cdef double * data

sage/libs/gsl/array.pyx

@@ -0,0 +1,102 @@
+# sage_setup: distribution = sagemath-modules
+"""
+GSL arrays
+"""
+
+from cysignals.memory cimport sig_malloc, sig_free
+
+cdef class GSLDoubleArray:
+    """
+    EXAMPLES::
+
+        sage: a = WaveletTransform(128,'daubechies',4)
+        sage: for i in range(1, 11):
+        ....:     a[i] = 1
+        sage: a[:6:2]
+        [0.0, 1.0, 1.0]
+    """
+    def __init__(self, size_t n, size_t stride=1, data=None):
+        """
+        EXAMPLES::
+
+            sage: from sage.libs.gsl.array import GSLDoubleArray
+            sage: a = GSLDoubleArray(10)
+        """
+        cdef int i
+
+        self.n = n
+        self.stride = stride
+        self.data = <double *> sig_malloc(sizeof(double)*n)
+        if data is not None:
+            for i from 0 <= i < n:
+                self.data[i] = data[i]
+        else:
+            for i from 0 <= i < n:
+                self.data[i] = 0
+
+    def __dealloc__(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.libs.gsl.array import GSLDoubleArray
+            sage: a = GSLDoubleArray(10)
+            sage: del a
+        """
+        sig_free(self.data)
+
+    def __len__(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.libs.gsl.array import GSLDoubleArray
+            sage: a = GSLDoubleArray(10)
+            sage: len(a)
+            10
+        """
+        return self.n
+
+    def __repr__(self):
+        """
+        EXAMPLES::
+
+            sage: from sage.libs.gsl.array import GSLDoubleArray
+            sage: a = GSLDoubleArray(10)
+            sage: a
+            [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+        """
+        return str(list(self))
+
+    def __setitem__(self, size_t i, x):
+        """
+        EXAMPLES::
+
+            sage: from sage.libs.gsl.array import GSLDoubleArray
+            sage: a = GSLDoubleArray(10)
+            sage: a[5] = 3
+            sage: a
+            [0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0]
+        """
+        # just set real for now
+        if i < 0 or i >= self.n:
+            raise IndexError
+        self.data[i] = x
+
+    def __getitem__(self, i):
+        """
+        EXAMPLES::
+
+            sage: from sage.libs.gsl.array import GSLDoubleArray
+            sage: a = GSLDoubleArray(10)
+            sage: for i in range(10):
+            ....:     a[i] = i
+            sage: a[3:7]
+            [3.0, 4.0, 5.0, 6.0]
+        """
+        if isinstance(i, slice):
+            start, stop, step = i.indices(len(self))
+            # TODO -- make this actually fast.
+            return list(self)[start:stop:step]
+        else:
+            if i < 0 or i >= self.n:
+                raise IndexError
+            return self.data[i]