kryptools 0.9.7__tar.gz → 0.9.8__tar.gz

{kryptools-0.9.7 → kryptools-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.7
+Version: 0.9.8
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools
@@ -9,7 +9,7 @@ Project-URL: Docs, https://github.com/teschlg/kryptools/tree/main/doc
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -29,7 +29,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, Jacobi/Legendre symbol, Chinese Remainder Theorem, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests, generation of random safe/strong primes
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)

{kryptools-0.9.7 → kryptools-0.9.8}/README.md

@@ -14,7 +14,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, Jacobi/Legendre symbol, Chinese Remainder Theorem, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests, generation of random safe/strong primes
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)

{kryptools-0.9.7 → kryptools-0.9.8}/kryptools/Zmod.py

@@ -119,9 +119,7 @@ class ZmodPoint:
         return NotImplemented
 
     def __radd__(self, scalar: int) -> "ZmodPoint":
-        if isinstance(scalar, int):
-            return self.__class__(scalar + self.x, self.ring)
-        return NotImplemented
+        return self + scalar
 
     def __neg__(self) -> "ZmodPoint":
         return self.__class__(-self.x, self.ring)
@@ -139,9 +137,7 @@ class ZmodPoint:
         return NotImplemented
 
     def __rsub__(self, scalar: int) -> "ZmodPoint":
-        if isinstance(scalar, int):
-            return self.__class__(scalar - self.x, self.ring)
-        return NotImplemented
+        return (- self) + scalar
 
     def __mul__(self, other: "ZmodPoint") -> "ZmodPoint":
         if isinstance(other, self.__class__):
@@ -153,9 +149,7 @@ class ZmodPoint:
         return NotImplemented
 
     def __rmul__(self, scalar: int) -> "ZmodPoint":
-        if isinstance(scalar, int):
-            return self.__class__(scalar * self.x, self.ring)
-        return NotImplemented
+        return self * scalar
 
     def __truediv__(self, other: "ZmodPoint") -> "ZmodPoint":
         if isinstance(other, self.__class__):

{kryptools-0.9.7 → kryptools-0.9.8}/kryptools/__init__.py

@@ -2,6 +2,12 @@
 Implemenation of same basic algorithms used in cryptography.
 """
 
+__author__ = "Gerald Teschl"
+__copyright__ = "Copyright 2024, Gerald Teschl"
+__license__ = "MIT License"
+__version__ = "0.9.8"
+__email__ = "Gerald.Teschl@univie.ac.at"
+
 from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, order, crt
 from .primes import sieve_eratosthenes, prime_pi, is_prime, next_prime, previous_prime, random_prime, random_strongprime, is_safeprime, random_safeprime, is_blumprime, random_blumprime, miller_rabin_test, lucas_test
 from .factor import factorint, divisors

{kryptools-0.9.7 → kryptools-0.9.8}/kryptools/la.py

@@ -23,6 +23,9 @@ class Matrix:
         self.matrix = matrix
         self.cols = len(matrix[0])
         self.rows = len(matrix)
+        for i in range(1, self.rows):
+            if len(matrix[i]) != self.cols:
+                raise ValueError("All matrix rows must have equal length!")
         if ring:
             self.map(ring)
 
@@ -62,11 +65,11 @@ class Matrix:
                 cols = i
             else:
                 cols = range(self.cols)[j]
-            return Matrix([[self.matrix[i][j] for j in cols] for i in rows])
+            return self.__class__([[self.matrix[i][j] for j in cols] for i in rows])
         if isinstance(item, int):
             i, j = divmod(item, self.cols)
             return self.matrix[i][j]
-        return Matrix([self.matrix[k // self.cols][k % self.cols] for k in range(self.cols * self.rows)[item]])
+        return self.__class__([self.matrix[k // self.cols][k % self.cols] for k in range(self.cols * self.rows)[item]])
 
     def __setitem__(self, item, value):
         if isinstance(item, tuple):
@@ -89,15 +92,24 @@ class Matrix:
             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]
-            return
-        i, j = divmod(item, self.cols)
-        self.matrix[i][j] = value
+        elif isinstance(item, int):
+            i, j = divmod(item, self.cols)
+            self.matrix[i][j] = value
+        else:
+            for k in range(self.cols * self.rows)[item]:
+                i, j = divmod(k, self.cols)
+                self.matrix[i][j] = value[k]
 
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
-        return self.matrix == other.matrix
+        if self.rows != other.rows or self.cols != other.cols:
+            return False
+        return any([ self[i] == other[i] for i in range(self.rows * self.cols) ])
 
+    def __bool__(self):
+        return any([ bool(self[i]) for i in range(self.rows * self.cols) ])
+    
     def map(self, func):
         "Apply a function to all elements in place."
         for row in self.matrix:
@@ -156,14 +168,14 @@ class Matrix:
         if isinstance(other, Matrix):
             if other.cols != self.cols or other.rows != self.rows:
                 raise NotImplementedError("Matrix dimensions do not match!")
-            return Matrix([ [ x1 + y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
+            return self.__class__([ [ x1 + y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
         return NotImplemented
 
     def __sub__(self, other) -> "Matrix":
         if isinstance(other, Matrix):
             if other.cols != self.cols or other.rows != self.rows:
                 raise NotImplementedError("Matrix dimensions do not match!")
-            return Matrix([ [ x1 - y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
+            return self.__class__([ [ x1 - y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
         return NotImplemented
 
     def __neg__(self) -> "Matrix":
@@ -176,12 +188,12 @@ class Matrix:
         if isinstance(other, Matrix):
             return self.multiply(other)
         if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
-            return Matrix([ [item * other for item in row] for row in self.matrix ])
+            return self.__class__([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 
     def __rmul__(self, other) -> "Matrix":
         if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
-            return Matrix([ [item * other for item in row] for row in self.matrix ])
+            return self.__class__([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 
     def rref(self) -> "Matrix":
@@ -242,7 +254,7 @@ class Matrix:
         if self.rows != self.cols:
             raise ValueError("Matrix must be square!")
         n = self.cols
-        MM = Matrix([[0 for _ in range(2*n)] for _ in range(n)])
+        MM = self.__class__([[0 for _ in range(2*n)] for _ in range(n)])
         for i in range(n):
             MM[i,n+i] = 1
         MM[:,0:n] = self
@@ -271,7 +283,7 @@ class Matrix:
             zero = 0 * self[0]
         except:
             zero = 0
-        return Matrix([[ zero for j in range(n) ] for i in range(m) ])
+        return self.__class__([[ zero for j in range(n) ] for i in range(m) ])
 
     def eye(self, m: int = None, n: int = None):
         "Returns an identity matrix of the same dimension."
@@ -287,8 +299,11 @@ class Matrix:
             zero = 0 * self[0]
         except:
             zero = 0
-        one = 1 + zero
-        return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])
+        try:
+            one = zero**0
+        except:
+            one = 1
+        return self.__class__([[ delta(i, j) for j in range(n) ] for i in range(m) ])
 
 
 def zeros(m: int, n: int = None, zero = 0) -> "Matrix":

{kryptools-0.9.7 → kryptools-0.9.8}/kryptools/poly.py

@@ -55,8 +55,9 @@ class Poly:
                 return "x"
             return "x^" + str(i)
 
-        if len(self.coeff) == 1:
+        if not self:
             return str(self.coeff[0])
+        one = self.coeff[0]**0
         plus = ""
         tmp = ""
         coef_range = range(len(self.coeff))
@@ -66,12 +67,12 @@ class Poly:
             s = self.coeff[i]
             if not s:
                 continue
-            if not s - 1 and i != 0:
+            if not s - one and i != 0:
                 tmp += plus + prx(i)
                 plus = " + "
                 continue
             try:
-                if s == -1 and i != 0:
+                if not s + one and i != 0:
                     if plus:
                         plus = " "
                     tmp += plus + "- " + prx(i)
@@ -96,7 +97,7 @@ class Poly:
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
-        return self.coeff == other.coeff
+        return not bool(self - other)
 
     def __bool__(self):
         return bool(self.degree()) or bool(self.coeff[0])
@@ -116,7 +117,18 @@ class Poly:
     def _check_type(self, other):
         return isinstance(other, int) or (isinstance(other, Number) and isinstance(self.coeff[0], Number)) or type(other) == type(self.coeff[0])
 
+    def _guess_ring(self):
+        zero = 0 * self.coeff[0]
+        try:
+            ring = type(zero)
+            one = ring(1)
+        except:
+            ring = None
+            one = zero**0  # zero + 1
+        return zero, one, ring
+
     def __add__(self, other: "Poly") -> "Poly":
+        zero = 0 * self.coeff[0]
         if not isinstance(other, self.__class__):
             if self._check_type(other):
                 tmp = self.coeff[:]
@@ -125,11 +137,11 @@ class Poly:
             return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
-            scoeff = self.coeff + (lo - ls) * [0]
+            scoeff = self.coeff + (lo - ls) * [zero]
         else:
             scoeff = self.coeff
         if ls > lo:
-            ocoeff = other.coeff + (ls - lo) * [0]
+            ocoeff = other.coeff + (ls - lo) * [zero]
         else:
             ocoeff = other.coeff
         modulus = self.modulus
@@ -138,12 +150,7 @@ class Poly:
         return self.__class__([s + o for s, o in zip(scoeff, ocoeff)], modulus=modulus)
 
     def __radd__(self, other: "Poly") -> "Poly":
-        if not isinstance(other, self.__class__):
-            if self._check_type(other):
-                tmp = self.coeff[:]
-                tmp[0] += other
-                return self.__class__(tmp, modulus=self.modulus)
-        return NotImplemented
+        return self + other
 
     def __neg__(self) -> "Poly":
         return Poly([-s for s in self.coeff], modulus=self.modulus)
@@ -152,57 +159,33 @@ class Poly:
         return self
 
     def __sub__(self, other: "Poly") -> "Poly":
-        if not isinstance(other, self.__class__):
-            if self._check_type(other):
-                tmp = self.coeff[:]
-                tmp[0] -= other
-                return self.__class__(tmp, modulus=self.modulus)
-            return NotImplemented
-        ls, lo = len(self.coeff), len(other.coeff)
-        if ls < lo:
-            scoeff = self.coeff + (lo - ls) * [0]
-        else:
-            scoeff = self.coeff
-        if ls > lo:
-            ocoeff = other.coeff + (ls - lo) * [0]
-        else:
-            ocoeff = other.coeff
-        modulus = self.modulus
-        if not modulus and other.modulus:
-            modulus = other.modulus
-        return self.__class__([s - o for s, o in zip(scoeff, ocoeff)], modulus = modulus)
+        return self + (- other)
 
     def __rsub__(self, other: "Poly") -> "Poly":
-        if not isinstance(other, self.__class__):
-            if self._check_type(other):
-                tmp = self.coeff[:]
-                tmp[0] -= other
-                return self.__class__(tmp, modulus=self.modulus)
-        return NotImplemented
+        return (- self) + other
 
     def __mul__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
             if self._check_type(other):
                 return Poly([other * s for s in self.coeff], modulus = self.modulus)
             return NotImplemented
+        zero = 0 * self.coeff[0]
         ls, lo = len(self.coeff), len(other.coeff)
-        coeff = [0] * (ls + lo - 1)
+        coeff = [None] * (ls + lo - 1)
         for k in range(ls + lo - 1):
             coeff[k] = sum(
                 [
                     self.coeff[j] * other.coeff[k - j]
                     for j in range(max(0, k - lo + 1), min(ls, k + 1))
                 ]
-            )
+            , start = zero)
         modulus = self.modulus
         if not modulus and other.modulus:
             modulus = other.modulus
         return self.__class__(coeff, modulus = modulus)
 
     def __rmul__(self, other) -> "Poly":
-        if self._check_type(other):
-            return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
-        return NotImplemented
+        return self * other
 
     def __truediv__(self, other) -> "Poly":
         if self._check_type(other):
@@ -221,8 +204,7 @@ class Poly:
     def __pow__(self, j: int) -> "Poly":
         if not isinstance(j, int):
             return NotImplemented
-        zero = 0 * self.coeff[0]
-        one = zero + 1
+        one = self.coeff[0]**0
         res = self.__class__([one], modulus=self.modulus)
         if j < 0:
             if not self.modulus:
@@ -256,39 +238,39 @@ class Poly:
 
     def divmod(self, other: "Poly") -> ("Poly", "Poly"):
         "Polynom division with remainder."
+        zero, one, ring = self._guess_ring()
         if isinstance(other, list):
-            other = self.__class__(other)
+            other = self.__class__(other , ring = ring)
         elif not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot divide {self} and {other}.")
         if not other:
             raise ValueError(f"{other} must be nonzero.")
         sd, od = self.degree(), other.degree()
         if sd < od:
-            return self.__class__([0]), self
-        div = [0] * (sd - od + 1)
+            return self.__class__([zero]), self
+        div = [zero] * (sd - od + 1)
         lco = other.coeff[-1]
-        if bool(lco - 1):
-            tmp = 1 / lco
+        if bool(lco - one):
+            tmp = one / lco
             oth = [c * tmp for c in other.coeff]
             rem = [c * tmp for c in self.coeff]
         else:
             oth = other.coeff
-            rem = [c for c in self.coeff]
+            rem = [c * one for c in self.coeff] # "* 1" is here to make sure we get a copy
         for i in range(sd - od + 1):
-            tmp = rem[sd - i]
+            tmp = rem[sd - i] * one # "* 1" is here to make sure we get a copy
             div[sd - od - i] = tmp
             for j in range(od + 1):
                 rem[sd - i - j] -= tmp * oth[od - j]
-        if bool(lco - 1):
+        if bool(lco - one):
             rem = [c * lco for c in rem]
-        return self.__class__(div, modulus=self.modulus), self.__class__(
-            rem, modulus=self.modulus
-        )
+        return self.__class__(div, modulus=self.modulus), self.__class__(rem, modulus=self.modulus)
 
     def mod(self, other: "Poly") -> None:
         "Reduce with respect to a given polynomial."
+        one, ring = self._guess_ring()[1:]
         if isinstance(other, list):
-            other = self.__class__(other)
+            other = self.__class__(other , ring = ring)
         elif not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot divide {self} and {other}.")
         if not other:
@@ -297,13 +279,13 @@ class Poly:
         if sd < od:
             return self
         lco = other.coeff[-1]
-        if bool(lco - 1):
-            tmp = 1 / lco
+        if bool(lco - one):
+            tmp = one / lco
             oth = [c * tmp for c in other.coeff]
         else:
             oth = other.coeff
         for i in range(sd - od + 1):
-            tmp = self.coeff[sd - i]
+            tmp = self.coeff[sd - i] * one # "* 1" is here to make sure we get a copy
             for j in range(od + 1):
                 self.coeff[sd - i - j] -= tmp * oth[od - j]
         for i in range(len(self.coeff) - 1, 0, -1):
@@ -315,14 +297,13 @@ class Poly:
         "Inverse modulo a given polynomial."
         if not other:
             other = self.modulus
+        zero, one, ring = self._guess_ring()
         if isinstance(other, list):
-            other = self.__class__(other)
+            other = self.__class__(other , ring = ring)
         elif not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot invert {self} modulo {other}.")
         if not other:
             raise NotImplementedError(f"{other} must be nonzero.")
-        zero = 0 * self.coeff[0]
-        one = zero +1
         r0, r1 = other, self
         y0, y1 = self.__class__([zero], modulus=self.modulus), self.__class__([one], modulus=self.modulus)
         while r1:
@@ -331,7 +312,7 @@ class Poly:
             y0, y1 = y1, y0 - q * y1
         if r0.degree() != 0:
             raise ValueError(f"{self} is not invertible mod {other}.")
-        tmp = 1 / r0[0]
+        tmp = one / r0[0]
         for i in range(len(y0)):
             y0.coeff[i] *= tmp
         return y0

{kryptools-0.9.7 → kryptools-0.9.8}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.7
+Version: 0.9.8
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools
@@ -9,7 +9,7 @@ Project-URL: Docs, https://github.com/teschlg/kryptools/tree/main/doc
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -29,7 +29,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, Jacobi/Legendre symbol, Chinese Remainder Theorem, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests, generation of random safe/strong primes
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)

{kryptools-0.9.7 → kryptools-0.9.8}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "kryptools"
-version = "0.9.7"
+version = "0.9.8"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]
 description = "Implemenation of same basic algorithms used in cryptography."
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",