snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/snap/t3mlite/linalg.py

@@ -1,9 +1,12 @@
 """
-The linear algebra needed for t3m.  Build on top of PARI.  
+The linear algebra needed for t3m.  Build on top of PARI.
 """
 
 from snappy.pari import pari
 
+PariGen = type(pari(0))
+
+
 def is_iterable(obj):
     try:
         iter(obj)
@@ -11,9 +14,22 @@ def is_iterable(obj):
     except TypeError:
         return False
 
+
+def is_pari_col_vector(obj):
+    return isinstance(obj, PariGen) and obj.type() == 't_COL'
+
+
+def is_pari_row_vector(obj):
+    return isinstance(obj, PariGen) and obj.type() == 't_VEC'
+
+
+def is_pari_matrix(obj):
+    return isinstance(obj, PariGen) and obj.type() == 't_MAT'
+
+
 class Vector:
     """
-    >>> v = Vector(3, range(3, 6)); v 
+    >>> v = Vector(3, range(3, 6)); v
     [3, 4, 5]
     >>> len(v)
     3
@@ -36,18 +52,38 @@ class Vector:
     4
     >>> abs(w)
     [2, 2, 6]
+
+    Internally, a Vector is a PARI *column* vector:
+
+    >>> w.pari.type()
+    't_COL'
     """
-    def __init__(self, n, entries=None):
-        if entries is None:
-            if is_iterable(n):
-                entries = n
-                n = len(entries)
-            else:
-                entries = n*[0]
-        assert n == len(entries)
-        self.pari = pari.vector(n, entries)
+    def __init__(self, n=None, entries=None, pari_vector=None):
+        if n is not None:
+            if entries is None:
+                if is_iterable(n):
+                    entries = n
+                    n = len(entries)
+                else:
+                    entries = n*[0]
+            assert n == len(entries)
+            pari_vector = pari.vector(n, entries).Col()
+        self.pari = pari_vector
 
     def __getitem__(self, i):
+        """
+        >>> v = Vector([1, 2, 3, 4])
+        >>> v[1]
+        2
+        >>> v[-1]
+        4
+        >>> v[1:-1]
+        [2, 3]
+        """
+        if isinstance(i, slice):
+            return self.__class__(list(self.pari)[i])
+        if i < 0:
+            i = i % len(self)
         return self.pari[i]
 
     def __setitem__(self, i, value):
@@ -57,7 +93,7 @@ class Vector:
         return int(self.pari.length())
 
     def __repr__(self):
-        return repr(self.pari)
+        return repr(self.pari)[:-1]
 
     def __eq__(self, other):
         """
@@ -71,7 +107,7 @@ class Vector:
         if isinstance(other, Vector):
             return self.pari == other.pari
         if other == 0:
-            return set([e == 0 for e in self]) == set([True])
+            return all(e == 0 for e in self)
         raise NotImplementedError
 
     def __ne__(self, other):
@@ -87,26 +123,29 @@ class Vector:
 
     def __add__(self, other):
         if isinstance(other, Vector):
-            return Vector(self.pari + other.pari)
+            return self.__class__(pari_vector=self.pari + other.pari)
         raise NotImplementedError
 
     def __rmul__(self, other):
-        return Vector([other*s for s in self])
+        return self.__class__(pari_vector=other * self.pari)
+
+    def __truediv__(self, other):
+        return self.__class__(pari_vector=self.pari / other)
 
     def __mul__(self, other):
         if isinstance(other, Vector):
-            if len(self) != len(other):
+            if self.pari.length() != other.pari.length():
                 raise ValueError("Vectors have different lengths")
-            return sum( [other[i]*s for i, s in enumerate(self)] )
+            return self.pari.Vec() * other.pari
         raise NotImplementedError
 
     def __sub__(self, other):
         if isinstance(other, Vector):
-            return Vector(self.pari -  other.pari)
+            return self.__class__(pari_vector=self.pari - other.pari)
         raise NotImplementedError
 
     def __abs__(self):
-        return Vector([abs(s) for s in self])
+        return self.__class__([abs(s) for s in self])
 
     def __neg__(self):
         return (-1)*self
@@ -132,20 +171,25 @@ class Matrix:
     >>> Matrix([[1,0,1], [2,3,4]])
     [1, 0, 1; 2, 3, 4]
     """
-    def __init__(self, nrows, ncols=None, entries=None):
-        if ncols==None:
-            nice_entries = nrows
-            try:
-                ncols = len(nrows[0])
-                nrows = len(nrows)
-            except TypeError:
-                ncols = nrows.ncols()
-                nrows = nrows.nrows()
-            entries = [e for row in nice_entries for e in row] 
-        if entries is None:
-            entries = (nrows*ncols)*[0]
-        assert len(entries) == nrows*ncols
-        self.pari = pari.matrix(nrows, ncols, entries)
+
+    _vector_class = Vector
+
+    def __init__(self, nrows=None, ncols=None, entries=None, pari_matrix=None):
+        if nrows is not None:
+            if ncols is None:
+                nice_entries = nrows
+                try:
+                    ncols = len(nrows[0])
+                    nrows = len(nrows)
+                except TypeError:
+                    ncols = nrows.ncols()
+                    nrows = nrows.nrows()
+                entries = [e for row in nice_entries for e in row]
+            if entries is None:
+                entries = (nrows*ncols)*[0]
+            assert len(entries) == nrows*ncols
+            pari_matrix = pari.matrix(nrows, ncols, entries)
+        self.pari = pari_matrix
 
     def nrows(self):
         return self.pari.nrows()
@@ -155,7 +199,31 @@ class Matrix:
 
     def column(self, j):
         pari_col = self.pari[j]
-        return Vector(pari_col)
+        return self._vector_class(pari_vector=pari_col)
+
+    def row(self, i):
+        """
+        >>> A = Matrix(3, 2, range(6))
+        >>> A.row(1)
+        [2, 3]
+        """
+        return self._vector_class([self[i, j] for j in range(self.ncols())])
+
+    def columns(self):
+        """
+        >>> A = Matrix(3, 2, range(6))
+        >>> A.columns()
+        [[0, 2, 4], [1, 3, 5]]
+        """
+        return [self.column(j) for j in range(self.ncols())]
+
+    def rows(self):
+        """
+        >>> A = Matrix(3, 2, range(6))
+        >>> A.rows()
+        [[0, 1], [2, 3], [4, 5]]
+        """
+        return [self.row(i) for i in range(self.nrows())]
 
     def entries(self):
         ans = []
@@ -170,12 +238,12 @@ class Matrix:
         >>> A.dot(range(4, 8))
         [38, 126, 214]
         """
-        if len(vec) != self.ncols():
-            raise ValueError
         if not isinstance(vec, Vector):
-            vec = Vector(vec)
-        ans = self.pari * vec.pari.Col()
-        return Vector(ans)
+            vec = self._vector_class(vec)
+        if vec.pari.length() != self.pari.ncols():
+            raise ValueError('Vector size does not match matrix')
+        ans = self.pari * vec.pari
+        return self._vector_class(pari_vector=ans)
 
     def solve(self, b):
         """
@@ -188,21 +256,32 @@ class Matrix:
         >>> B.solve([5, 23, 41, 59])
         [4, 5]
         """
+        ncols, nrows = self.ncols(), self.nrows()
         if not isinstance(b, Vector):
-            b = Vector(b)
+            b = self._vector_class(b)
 
-        if self.nrows() == self.ncols():
-            ans = Vector(self.pari.matsolve(b.pari.Col()))
-        elif self.nrows() > self.ncols():
-            if self.rank() != self.ncols():
+        if nrows == ncols:
+            v = self.pari.matsolve(b.pari)
+            ans = self._vector_class(pari_vector=v)
+        elif nrows > ncols:
+            if self.rank() != ncols:
                 raise ValueError
             ker = self.pari.mattranspose().matker()
-            M = Matrix(list(self.pari) + list(ker))
-            M.pari = M.pari.mattranspose()
-            ans = Vector(list(M.solve(b))[:self.ncols()])
+            M = self.pari.concat(ker)
+            v = M.matsolve(b.pari)
+            ans = self._vector_class(list(v)[:ncols])
         assert self.dot(ans) == b
-        return ans    
+        return ans
 
+    def solve_right(self, b):
+        """
+        Return a vector v for which A v = b.
+
+        >>> A = Matrix(2, 2, range(4))
+        >>> A.solve_right([6, 8])
+        [-5, 6]
+        """
+        return self.solve(b)
 
     def rank(self):
         """
@@ -233,6 +312,30 @@ class Matrix:
         a, b = self.nrows(), self.ncols()
         return [self[i, j] for i in range(a) for j in range(b)]
 
+    def transpose(self):
+        """
+        >>> A = Matrix(2, 3, range(6))
+        >>> B = Matrix([[0, 3], [1, 4], [2, 5]])
+        >>> A.transpose() == B and B.transpose() == A
+        True
+        """
+        return self.__class__(pari_matrix=self.pari.mattranspose())
+
+    def inverse(self):
+        """
+        >>> A = Matrix([[1, 2], [3, 4]])
+        >>> A * A.inverse()
+        [1, 0; 0, 1]
+        """
+        a, b = self.nrows(), self.ncols()
+        if a != b:
+            raise ValueError('An invertible matrix must be square')
+
+        return self.__class__(pari_matrix=self.pari.matsolve(pari.matid(a)))
+
+    def det(self):
+        return self.pari.matdet()
+
     def __repr__(self):
         return repr(self.pari)
 
@@ -245,7 +348,7 @@ class Matrix:
             return self.pari[ij]
         except TypeError:
             pari_row = self.pari.mattranspose()[ij]
-            return Vector(pari_row.length(), pari_row)
+            return self._vector_class(pari_row)
 
     def __mul__(self, other):
         """
@@ -257,12 +360,9 @@ class Matrix:
         [20, 74]
         """
         if isinstance(other, Matrix):
-            if other.nrows() != self.ncols():
+            if other.pari.nrows() != self.pari.ncols():
                 raise ValueError('Matrix sizes do not allow for multiplication')
-            pari_ans = self.pari * other.pari
-            ans = Matrix(pari_ans.nrows(), pari_ans.ncols())
-            ans.pari = pari_ans
-            return ans
+            return self.__class__(pari_matrix=self.pari * other.pari)
         if is_iterable(other):
             return self.dot(other)
 
@@ -297,8 +397,9 @@ class Matrix:
         """
         return not self.__eq__(other)
 
+
 def gcd(a, b):
-    a, b= abs(a), abs(b)
+    a, b = abs(a), abs(b)
     if a == 0:
         if b == 0:
             raise ValueError("gcd(0,0) undefined.")
@@ -312,6 +413,7 @@ def gcd(a, b):
         if (a == 0):
             return b
 
+
 if __name__ == '__main__':
     import doctest
-    doctest.testmod()
+    print(doctest.testmod())