Small improvements/extensions

Author: teschlg

Diff for: doc/kryptools.ipynb

@@ -1476,6 +1476,39 @@
     "U"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "e88ff7af-c3aa-4fdc-a83f-2f535df0b72c",
+   "metadata": {},
+   "source": [
+    "To get a random unimodular matrix use"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "694c25e5-d01f-4acf-ab57-69bffb0fb9a8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[ 1, -8, -9 ]\n",
+       "[ 0,  3,  4 ]\n",
+       "[ 4,  2,  9 ]"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from kryptools import random_unimodular_matrix\n",
+    "\n",
+    "random_unimodular_matrix(3, max_val = 9)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "c8427b8b-db49-4fa1-ba07-63382746bcca",
@@ -1494,7 +1527,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 46,
    "id": "d3c69787-da17-4cd3-b282-a68ee4d177e6",
    "metadata": {},
    "outputs": [
@@ -1504,7 +1537,7 @@
        "3 x^2 + 2 x + 1"
       ]
      },
-     "execution_count": 45,
+     "execution_count": 46,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1533,7 +1566,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 47,
    "id": "8d4c4b43-e593-407a-92f8-86b653a09c8a",
    "metadata": {},
    "outputs": [],
@@ -1567,7 +1600,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 48,
    "id": "bf50f802-93f5-4c79-b982-a208486f9a72",
    "metadata": {},
    "outputs": [
@@ -1578,7 +1611,7 @@
        "[ 27 x^3 + 74 x^2 + 45 x + 61, 17 x^3 + 36 x^2 + 17 x + 64 ]"
       ]
      },
-     "execution_count": 47,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1603,7 +1636,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 49,
    "id": "9e0ebbd3-0d4b-4e1b-b4dd-323b5a86dc23",
    "metadata": {},
    "outputs": [
@@ -1614,7 +1647,7 @@
        "[ 96 x^2 + x + 1 ]"
       ]
      },
-     "execution_count": 48,
+     "execution_count": 49,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1634,7 +1667,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 50,
    "id": "563280a9-27b9-4707-ae14-9aeef9bbe5a6",
    "metadata": {},
    "outputs": [
@@ -1645,7 +1678,7 @@
        "[             2 x ]"
       ]
      },
-     "execution_count": 49,
+     "execution_count": 50,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1666,7 +1699,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 51,
    "id": "fabcbecf-cf96-4211-a1e3-ad0f5a337a09",
    "metadata": {},
    "outputs": [
@@ -1677,7 +1710,7 @@
        "[ 47 x^3 + 30 x^2 + 42 x + 47 ]"
       ]
      },
-     "execution_count": 50,
+     "execution_count": 51,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1705,7 +1738,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": 52,
    "id": "9b566550-f23c-4fbc-8b7c-63bbee8e0c72",
    "metadata": {},
    "outputs": [
@@ -1744,7 +1777,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 53,
    "id": "55c29e0c-e0c2-409a-af23-6590fd9cc545",
    "metadata": {},
    "outputs": [
@@ -1754,7 +1787,7 @@
        "(113, 91)"
       ]
      },
-     "execution_count": 52,
+     "execution_count": 53,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1776,7 +1809,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 54,
    "id": "2a3d8e7d-71b3-4a93-b6cc-803f00432c56",
    "metadata": {},
    "outputs": [
@@ -1786,7 +1819,7 @@
        "129"
       ]
      },
-     "execution_count": 53,
+     "execution_count": 54,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1806,7 +1839,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": 55,
    "id": "bb93b5fc-99c9-4977-8299-9342b84e143d",
    "metadata": {},
    "outputs": [],
@@ -1826,7 +1859,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 56,
    "id": "41e18357-da42-4cd7-bd4e-1c3355f1c69d",
    "metadata": {},
    "outputs": [],
@@ -1849,7 +1882,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 57,
    "id": "af81d5f2-a524-4555-8e74-06a0c9a7ea08",
    "metadata": {},
    "outputs": [
@@ -1860,7 +1893,7 @@
        " 0x02449ef2ed30a8deb96e584a08c329adbf1be87ce40f1a0e7b4e86178682c41a9c)"
       ]
      },
-     "execution_count": 56,
+     "execution_count": 57,
      "metadata": {},
      "output_type": "execute_result"
     }

Diff for: kryptools/__init__.py

@@ -5,8 +5,8 @@
 from .dlp import dlog
 from .ec import EC_Weierstrass
 from .factor import factorint
-from .la import Matrix
-from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, lagrange_lr, lll
+from .la import Matrix, zeros, eye
+from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, lagrange_lr, lll, random_unimodular_matrix
 from .nt import cf, convergents, jacobi_symbol, sqrt_mod, euler_phi, order, carmichael_lambda
 from .poly import Poly
 from .primes import sieve_eratosthenes, isprime

Diff for: kryptools/la.py

@@ -2,7 +2,7 @@
 Linear algebra
 """
 
-from math import sqrt, prod
+from math import inf, sqrt, prod
 
 class Matrix:
     """
@@ -48,12 +48,18 @@ def __getitem__(self, item):
             i, j = item
             if isinstance(i, int) and isinstance(j, int):
                 return self.matrix[i][j]
-            rows = range(self.rows)[i]
             if isinstance(i, int):
-                rows = [ rows ]
-            cols = range(self.cols)[j]
+                rows = [ i ]
+            elif isinstance(i, list):
+                rows = i
+            else:
+                rows = range(self.rows)[i]
             if isinstance(j, int):
-                cols = [ cols ]
+                cols = [ j ]
+            elif isinstance(j, list):
+                cols = i
+            else:
+                cols = range(self.cols)[j]
             return Matrix([[self.matrix[i][j] for j in cols] for i in rows])
         i, j = divmod(item, self.cols)
         return self.matrix[i][j]
@@ -64,12 +70,18 @@ def __setitem__(self, item, value):
             if isinstance(i, int) and isinstance(j, int):
                 self.matrix[i][j] = value
                 return
-            rows = range(self.rows)[i]
             if isinstance(i, int):
-                rows = [ rows ]
-            cols = range(self.cols)[j]
+                rows = [ i ]
+            elif isinstance(i, list):
+                rows = i
+            else:
+                rows = range(self.rows)[i]
             if isinstance(j, int):
-                cols = [ cols ]
+                cols = [ j ]
+            elif isinstance(j, list):
+                cols = i
+            else:
+                cols = range(self.cols)[j]
             for i, ii in zip(cols,range(len(cols))):
                 for j, jj in zip(rows,range(len(rows))):
                     self.matrix[j][i] = value[jj,ii]
@@ -97,9 +109,17 @@ def norm2(self) -> float:
         "Squared Frobenius/Euclidean norm."
         return sum( sum(x*x for x in row) for row in self.matrix )
 
-    def norm(self) -> float:
-        "Frobenius/Euclidean norm."
-        return sqrt(self.norm2())
+    def norm(self, p: int = 2) -> float:
+        "p-norm of a matrix regarded as a vector."
+        if p == 2:
+            return sqrt(self.norm2())
+        if p == 1:
+            return sum( sum(abs(x) for x in row) for row in self.matrix )
+        if p == inf:
+            return max( max(abs(x) for x in row) for row in self.matrix )
+        tmp = sum( sum(abs(x)**p for x in row) for row in self.matrix )
+        return(tmp**(1/p))
+
 
     def dot(self, other) -> int:
         if self.rows == 1 and other.rows == 1 and self.cols == other.cols:
@@ -112,14 +132,16 @@ def transpose(self) -> "Matrix":
         return Matrix([list(i) for i in zip(*self.matrix)])
 
     def multiply(self, other) -> "Matrix":
-        if not isinstance(other, Matrix) or self.cols != other.rows:
+        if not isinstance(other, Matrix):
             return NotImplemented
-        result = [[0 for j in range(other.cols)] for i in range(self.rows)]
+        if self.cols != other.rows:
+            raise NotImplementedError("Matrix dimensions do not match!")
+        result = self.zeros(self.rows, other.cols)
         for i in range(self.rows):
             for j in range(other.cols):
                 for k in range(other.rows):
-                    result[i][j] += self.matrix[i][k] * other.matrix[k][j]
-        return Matrix(result)
+                    result.matrix[i][j] += self.matrix[i][k] * other.matrix[k][j]
+        return result
 
     def __add__(self, other) -> "Matrix":
         if isinstance(other, Matrix) and other.cols == self.cols and other.rows == self.rows:
@@ -211,13 +233,38 @@ def inv(self) -> "Matrix":
             raise ValueError("Matrix is not invertible!")
         return MM[:,n:]
 
+    def zeros(self, m: int = None, n: int = None):
+        if not m and not n:
+            n, m = self.cols, self.rows
+        elif not n:
+            n = m
+        zero = 0 * self[0]
+        return Matrix([[ zero for j in range(n)] for i in range(m) ])
+
+    def eye(self, m: int = None, n: int = None):
+        def delta(i, j):
+            if i == j:
+                return 1
+            return 0
+        if not m and not n:
+            n, m = self.cols, self.rows
+        elif not n:
+            n = m
+        zero = 0 * self[0]
+        one = 1 + zero
+        return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])
+
 
-def zeros(m:int, n: int) -> "Matrix":
+def zeros(m: int, n: int = None) -> "Matrix":
+    if not n:
+        n = m
     return Matrix([[ 0 for j in range(n)] for i in range(m) ])
 
-def eye(m:int, n: int) -> "Matrix":
+def eye(m:int, n: int = None) -> "Matrix":
     def delta(i, j):
         if i == j:
             return 1
         return 0
+    if not n:
+        n = m
     return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])