passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/matrix/matrix0.pxd

@@ -3,15 +3,15 @@
 Generic matrices
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2006 William Stein <wstein@gmail.com>
 #
 # 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.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 cimport sage.structure.element
 cimport sage.structure.mutability

sage/matrix/matrix0.pyx

@@ -91,6 +91,7 @@ cdef class Matrix(sage.structure.element.Matrix):
 
     ::
 
+        sage: # needs sage.libs.singular
         sage: Q.<i,j,k> = QuaternionAlgebra(QQ, -1,-1)
         sage: matrix(Q,2,1,[1,2])
         [1]
@@ -532,7 +533,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             sage: A.is_mutable()
             False
         """
-        return not(self._is_immutable)
+        return not self._is_immutable
 
     ###########################################################
     # Entry access
@@ -3793,7 +3794,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             [1]
         """
         cdef list L = []
-        cdef int i
+        cdef Py_ssize_t i
 
         for i from 0 <= i < self._ncols:
             if i not in d:
@@ -3855,7 +3856,8 @@ cdef class Matrix(sage.structure.element.Matrix):
         """
         cdef dict d = {}
         cdef list queue = list(range(self._ncols))
-        cdef int l, sign, i
+        cdef int l
+        cdef Py_ssize_t sign, i
 
         if skew:
             # testing the diagonal entries to be zero
@@ -5141,9 +5143,9 @@ cdef class Matrix(sage.structure.element.Matrix):
             fac = o1.factor()
             S = sum((pi - 1) * pi**(ei - 1) for pi, ei in fac)
             if fac[0] == (2, 1):
-                impossible_order = not(S <= n + 1)
+                impossible_order = S > n + 1
             else:
-                impossible_order = not(S <= n)
+                impossible_order = S > n
             if impossible_order:
                 return Infinity
 

sage/matrix/matrix1.pyx

@@ -10,15 +10,15 @@ TESTS::
     sage: TestSuite(A).run()
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2005, 2006 William Stein <wstein@gmail.com>
 #
 # 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.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from cpython.sequence cimport PySequence_Fast
 
@@ -56,9 +56,9 @@ cdef class Matrix(Matrix0):
         for i from 0 <= i < nr:
             tmp = []
             for j from 0 <= j < nc:
-                tmp.append(w[i*nc + j]._pari_init_())
-            v.append( ','.join(tmp))
-        return 'Mat([%s])'%(';'.join(v))
+                tmp.append(w[i * nc + j]._pari_init_())
+            v.append(','.join(tmp))
+        return 'Mat([%s])' % (';'.join(v))
 
     def __pari__(self):
         """
@@ -136,11 +136,12 @@ cdef class Matrix(Matrix0):
         for i from 0 <= i < self._nrows:
             tmp = []
             for j from 0 <= j < self._ncols:
-                tmp.append(self.get_unsafe(i,j)._gap_init_())
-            v.append( '[%s]'%(','.join(tmp)) )
+                tmp.append(self.get_unsafe(i, j)._gap_init_())
+            v.append('[%s]' % (','.join(tmp)))
         # It is needed to multiply with 'One(...)', because
         # otherwise the result would not be a gap matrix
-        return '[%s]*One(%s)'%(','.join(v),sage.interfaces.gap.gap(self.base_ring()).name())
+        return '[%s]*One(%s)' % (','.join(v),
+                                 sage.interfaces.gap.gap(self.base_ring()).name())
 
     def _libgap_(self):
         """
@@ -262,9 +263,9 @@ cdef class Matrix(Matrix0):
         for i from 0 <= i < self._nrows:
             tmp = []
             for j from 0 <= j < self._ncols:
-                tmp.append(self.get_unsafe(i,j)._maxima_init_())
-            v.append( '[%s]'%(','.join(tmp)) )
-        return 'matrix(%s)'%(','.join(v))
+                tmp.append(self.get_unsafe(i, j)._maxima_init_())
+            v.append('[%s]' % (','.join(tmp)))
+        return 'matrix(%s)' % (','.join(v))
 
     def _mathematica_init_(self):
         """
@@ -421,7 +422,7 @@ cdef class Matrix(Matrix0):
             0+1r5 3
         """
         P = polymake(self.parent())
-        return polymake.new_object(P, [ list(r) for r in self.rows(copy=False) ])
+        return polymake.new_object(P, [list(r) for r in self.rows(copy=False)])
 
     def _singular_(self, singular=None):
         """
@@ -435,7 +436,8 @@ cdef class Matrix(Matrix0):
         except (NotImplementedError, AttributeError):
             raise TypeError("Cannot coerce to Singular")
 
-        return singular.matrix(self.nrows(),self.ncols(),singular(self.list()))
+        return singular.matrix(self.nrows(), self.ncols(),
+                               singular(self.list()))
 
     def _macaulay2_(self, macaulay2=None):
         """
@@ -505,9 +507,9 @@ cdef class Matrix(Matrix0):
         for i from 0 <= i < nr:
             tmp = []
             for j from 0 <= j < nc:
-                tmp.append(w[i*nc + j]._pari_init_())
-            v.append( ','.join(tmp))
-        return '[%s]'%(';'.join(v))
+                tmp.append(w[i * nc + j]._pari_init_())
+            v.append(','.join(tmp))
+        return '[%s]' % (';'.join(v))
 
     def _scilab_(self, scilab=None):
         """
@@ -658,7 +660,8 @@ cdef class Matrix(Matrix0):
             entries.sort()
             # We hand-format the keys to get rid of the space that would
             # normally follow the comma
-            entries = [(sib.name('(%d,%d)'%k), sib(v, 2)) for k,v in entries]
+            entries = [(sib.name('(%d,%d)' % k), sib(v, 2))
+                       for k, v in entries]
             return sib.name('matrix')(self.base_ring(),
                                       sib.int(self.nrows()),
                                       sib.int(self.ncols()),
@@ -737,12 +740,39 @@ cdef class Matrix(Matrix0):
         """
         import numpy
         A = numpy.matrix(self.list(), dtype=dtype, copy=copy)
-        return numpy.resize(A,(self.nrows(), self.ncols()))
+        return numpy.resize(A, (self.nrows(), self.ncols()))
+
+    def _mpmath_(self, prec=None, rounding=None):
+        """
+        Return a ``mpmath`` matrix.
+
+        INPUT: See :meth:`sage.structure.element.Element._mpmath_`.
+
+        EXAMPLES::
+
+            sage: # needs mpmath sage.symbolic
+            sage: m = matrix(SR, 2, 2, [1, 2, 3, pi])
+            sage: from mpmath import mp
+            sage: mp.dps = 30
+            sage: mp.matrix(m)  # not tested (doesn't work yet)
+            sage: m._mpmath_(mp.prec)
+            matrix(
+            [['1.0', '2.0'],
+             ['3.0', '3.14159265358979323846264338328']])
+        """
+        if prec is None:
+            R = self.base_ring()
+            try:
+                prec = R.precision()
+            except AttributeError:
+                prec = 53
+        from mpmath import mp
+        return mp.matrix([[item._mpmath_(prec, rounding) for item in row] for row in self])
 
     # Define the magic "__array__" function so that numpy.array(m) can convert
     # a matrix m to a numpy array.
     # See http://docs.scipy.org/doc/numpy/user/c-info.how-to-extend.html#converting-an-arbitrary-sequence-object
-    __array__=numpy
+    __array__ = numpy
 
     ###################################################
     # Construction functions
@@ -1020,14 +1050,16 @@ cdef class Matrix(Matrix0):
             raise ValueError(msg.format(copy))
         x = self.fetch('columns')
         if x is not None:
-            if copy: return list(x)
+            if copy:
+                return list(x)
             return x
         if self.is_sparse():
             columns = self.sparse_columns(copy=copy)
         else:
             columns = self.dense_columns(copy=copy)
         self.cache('columns', columns)
-        if copy: return list(columns)
+        if copy:
+            return list(columns)
         return columns
 
     def rows(self, copy=True):
@@ -1076,14 +1108,16 @@ cdef class Matrix(Matrix0):
             raise ValueError(msg.format(copy))
         x = self.fetch('rows')
         if x is not None:
-            if copy: return list(x)
+            if copy:
+                return list(x)
             return x
         if self.is_sparse():
             rows = self.sparse_rows(copy=copy)
         else:
             rows = self.dense_rows(copy=copy)
         self.cache('rows', rows)
-        if copy: return list(rows)
+        if copy:
+            return list(rows)
         return rows
 
     def dense_columns(self, copy=True):
@@ -1132,7 +1166,8 @@ cdef class Matrix(Matrix0):
         """
         x = self.fetch('dense_columns')
         if x is not None:
-            if copy: return list(x)
+            if copy:
+                return list(x)
             return x
         cdef Py_ssize_t i
         A = self if self.is_dense() else self.dense_matrix()
@@ -1186,7 +1221,8 @@ cdef class Matrix(Matrix0):
         """
         x = self.fetch('dense_rows')
         if x is not None:
-            if copy: return list(x)
+            if copy:
+                return list(x)
             return x
 
         cdef Py_ssize_t i
@@ -1242,7 +1278,8 @@ cdef class Matrix(Matrix0):
         """
         x = self.fetch('sparse_columns')
         if x is not None:
-            if copy: return list(x)
+            if copy:
+                return list(x)
             return x
 
         cdef Py_ssize_t i, j
@@ -1324,7 +1361,8 @@ cdef class Matrix(Matrix0):
         """
         x = self.fetch('sparse_rows')
         if x is not None:
-            if copy: return list(x)
+            if copy:
+                return list(x)
             return x
 
         cdef Py_ssize_t i, j
@@ -1475,7 +1513,7 @@ cdef class Matrix(Matrix0):
             return self.rows(copy=False)[i]
         cdef Py_ssize_t j
         V = self.row_ambient_module()
-        tmp = [self.get_unsafe(i,j) for j in range(self._ncols)]
+        tmp = [self.get_unsafe(i, j) for j in range(self._ncols)]
         return V(tmp, coerce=False, copy=False, check=False)
 
     ###########################################################################
@@ -1724,12 +1762,12 @@ cdef class Matrix(Matrix0):
                 bottom = bottom.row()
             else:
                 raise TypeError('a matrix must be stacked with '
-                        'another matrix or a vector')
+                                'another matrix or a vector')
             other = <Matrix?>bottom
 
         if self._ncols != other._ncols:
             raise TypeError("number of columns must be the same, not %s and %s" %
-                    (self.ncols(), bottom.ncols()) )
+                            (self.ncols(), bottom.ncols()))
 
         top_ring = self._base_ring
         bottom_ring = other._base_ring
@@ -1768,10 +1806,10 @@ cdef class Matrix(Matrix0):
         cdef Py_ssize_t nr = self._nrows
         for r in range(self._nrows):
             for c in range(self._ncols):
-                Z.set_unsafe(r, c, self.get_unsafe(r,c))
+                Z.set_unsafe(r, c, self.get_unsafe(r, c))
         for r in range(other._nrows):
             for c in range(other._ncols):
-                Z.set_unsafe(r+nr, c, other.get_unsafe(r,c))
+                Z.set_unsafe(r + nr, c, other.get_unsafe(r, c))
 
         return Z
 
@@ -1950,29 +1988,29 @@ cdef class Matrix(Matrix0):
                 right = right.column()
             else:
                 raise TypeError("a matrix must be augmented with another matrix, "
-                    "or a vector")
+                                "or a vector")
 
         cdef Matrix other
         other = right
 
         if self._nrows != other._nrows:
             raise TypeError('number of rows must be the same, '
-                '{0} != {1}'.format(self._nrows, other._nrows))
+                            '{0} != {1}'.format(self._nrows, other._nrows))
         if not (self._base_ring is other.base_ring()):
             other = other.change_ring(self._base_ring)
 
         cdef Matrix Z
-        Z = self.new_matrix(ncols = self._ncols + other._ncols)
+        Z = self.new_matrix(ncols=self._ncols + other._ncols)
 
         cdef Py_ssize_t r, c
         for r from 0 <= r < self._nrows:
             for c from 0 <= c < self._ncols:
-                Z.set_unsafe(r,c, self.get_unsafe(r,c))
+                Z.set_unsafe(r, c, self.get_unsafe(r, c))
         nc = self.ncols()
 
         for r from 0 <= r < other._nrows:
             for c from 0 <= c < other._ncols:
-                Z.set_unsafe(r, c+nc, other.get_unsafe(r,c))
+                Z.set_unsafe(r, c + nc, other.get_unsafe(r, c))
 
         if subdivide:
             Z._subdivide_on_augment(self, other)
@@ -2235,7 +2273,7 @@ cdef class Matrix(Matrix0):
         return A
 
     def submatrix(self, Py_ssize_t row=0, Py_ssize_t col=0,
-                        Py_ssize_t nrows=-1, Py_ssize_t ncols=-1):
+                  Py_ssize_t nrows=-1, Py_ssize_t ncols=-1):
         """
         Return the matrix constructed from ``self`` using the specified
         range of rows and columns.
@@ -2290,7 +2328,8 @@ cdef class Matrix(Matrix0):
             nrows = self._nrows - row
         if ncols == -1:
             ncols = self._ncols - col
-        return self.matrix_from_rows_and_columns(range(row, row+nrows), range(col, col+ncols))
+        return self.matrix_from_rows_and_columns(range(row, row + nrows),
+                                                 range(col, col + ncols))
 
     def set_row(self, row, v):
         r"""
@@ -2356,7 +2395,7 @@ cdef class Matrix(Matrix0):
             raise ValueError(msg.format(self._ncols, len(v)))
         if (row < 0) or (row >= self._nrows):
             msg = "row number must be between 0 and {0} (inclusive), not {1}"
-            raise ValueError(msg.format(self._nrows-1, row))
+            raise ValueError(msg.format(self._nrows - 1, row))
 
         try:
             for j in range(self._ncols):
@@ -2430,7 +2469,7 @@ cdef class Matrix(Matrix0):
             raise ValueError(msg.format(self._nrows, len(v)))
         if (col < 0) or (col >= self._ncols):
             msg = "column number must be between 0 and {0} (inclusive), not {1}"
-            raise ValueError(msg.format(self._ncols-1, col))
+            raise ValueError(msg.format(self._ncols - 1, col))
 
         try:
             for i in range(self._nrows):
@@ -2614,7 +2653,7 @@ cdef class Matrix(Matrix0):
             return self
         cdef Matrix A
         A = self.new_matrix(self._nrows, self._ncols, self,
-                coerce=False, sparse=False)
+                            coerce=False, sparse=False)
         if self._subdivisions is not None:
             A.subdivide(self.subdivisions())
         return A
@@ -2658,7 +2697,7 @@ cdef class Matrix(Matrix0):
         if self.is_sparse():
             return self
         A = self.new_matrix(self._nrows, self._ncols, self,
-                coerce=False, sparse=True)
+                            coerce=False, sparse=True)
         if self._subdivisions is not None:
             A.subdivide(self.subdivisions())
         return A
@@ -2689,10 +2728,10 @@ cdef class Matrix(Matrix0):
 
             sage: M = MatrixSpace(QQ, 3, implementation='generic')
             sage: m = M.an_element()
-            sage: m.matrix_space()
+            sage: m.matrix_space()                                                      # needs sage.libs.flint
             Full MatrixSpace of 3 by 3 dense matrices over Rational Field
              (using Matrix_generic_dense)
-            sage: m.matrix_space(nrows=2, ncols=12)
+            sage: m.matrix_space(nrows=2, ncols=12)                                     # needs sage.libs.flint
             Full MatrixSpace of 2 by 12 dense matrices over Rational Field
              (using Matrix_generic_dense)
             sage: m.matrix_space(nrows=2, sparse=True)
@@ -2773,10 +2812,10 @@ cdef class Matrix(Matrix0):
 
             sage: M = MatrixSpace(ZZ, 2, 3, implementation='generic')
             sage: m = M.an_element()
-            sage: m.new_matrix().parent()
+            sage: m.new_matrix().parent()                                               # needs sage.libs.flint
             Full MatrixSpace of 2 by 3 dense matrices over Integer Ring
              (using Matrix_generic_dense)
-            sage: m.new_matrix(3,3).parent()
+            sage: m.new_matrix(3,3).parent()                                            # needs sage.libs.flint
             Full MatrixSpace of 3 by 3 dense matrices over Integer Ring
              (using Matrix_generic_dense)
             sage: m.new_matrix(3,3, sparse=True).parent()

sage/matrix/matrix2.pxd

@@ -3,15 +3,15 @@
 Generic matrices
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2006 William Stein <wstein@gmail.com>
 #
 # 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.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.matrix.matrix1 cimport Matrix as Matrix1