kryptools 0.6__tar.gz → 0.8__tar.gz

{kryptools-0.6 → kryptools-0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.6
+Version: 0.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
@@ -27,7 +27,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

{kryptools-0.6 → kryptools-0.8}/README.md

@@ -12,7 +12,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

{kryptools-0.6 → kryptools-0.8}/kryptools/Zmod.py

@@ -106,6 +106,9 @@ class ZmodPoint:
     def __neg__(self) -> "ZmodPoint":
         return self.__class__(-self.x, self.ring)
 
+    def __pos__(self) -> "ZmodPoint":
+        return self
+
     def __sub__(self, other: "ZmodPoint") -> "ZmodPoint":
         if isinstance(other, self.__class__):
             if self.ring != other.ring:
@@ -151,6 +154,9 @@ class ZmodPoint:
             return self.__class__(pow(self.x, scalar, self.ring.n), self.ring)
         return NotImplemented
 
+    def __abs__(self) -> int:
+        return abs(self.sharp())
+
     def sharp(self):
         "Returns a symmetric (w.r.t. 0) representative."
         tmp = (self.ring.n - 1) // 2

{kryptools-0.6 → kryptools-0.8}/kryptools/factor.py

@@ -88,7 +88,7 @@ def factorint(n: int, verbose: int = 0) -> list:
         D = isqrt(B2)
         primes = sieve_eratosthenes(B1 - 1 + ((B2 - B1 + 1) // (2 * D) + 1) * 2 * D)
         pm1_parameters = _pm1_parameters(10 * B1, B2, primes = primes)
-        ecm_parameters = tuple([num_curves] + list(_ecm_parameters(B1, B2, D, primes = primes)))
+        ecm_parameters = tuple([B1, B2, num_curves] + list(_ecm_parameters(B1, B2, D, primes = primes)))
 
         methods = {_factor_fermat: "fm", factor_pm1: "pm1", factor_ecm: "ecm"}  #, factor_qs: "qs"}
         while remaining_factors:

{kryptools-0.6 → kryptools-0.8}/kryptools/factor_ecm.py

@@ -57,7 +57,7 @@ def _ecm_parameters(B1: int, B2: int = None, D: int = None, primes: tuple = None
     else:
         B2 += B2 & 1
     if not D:
-        D = isqrt(B2)
+        D = min(isqrt(B2), B1 // 2 - 1)
     if not primes:
         primes = sieve_eratosthenes(B1 - 1 + ((B2 - B1 + 1) // (2 * D) + 1) * 2 * D)
 
@@ -71,7 +71,7 @@ def _ecm_parameters(B1: int, B2: int = None, D: int = None, primes: tuple = None
     r = B1 - 1
     stage_two_deltas[r] = []
     for p in primes:
-        if p <= r:
+        if p < r:
             continue
         if p <= r + 2 * D:
             stage_two_deltas[r].append((p - r) // 2)
@@ -88,7 +88,7 @@ def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm
     "Factors a number n using Lentsta's ECM method."    
 
     if ecm_parameters:
-        curves, D, stage_one, stage_two_deltas = ecm_parameters
+        B1, B2, curves, D, stage_one, stage_two_deltas = ecm_parameters
     else:
         D, stage_one, stage_two_deltas = _ecm_parameters(B1, B2)
 

{kryptools-0.6 → kryptools-0.8}/kryptools/la.py

@@ -99,12 +99,12 @@ class Matrix:
         return self.matrix == other.matrix
 
     def map(self, func):
-        "Apply a function to all elements in place"
+        "Apply a function to all elements in place."
         for row in self.matrix:
             row[:] = map(func, row)
 
     def applyfunc(self, func):
-        "Apply a function to all elements"
+        "Apply a function to all elements."
         tmp = self[:,:]
         tmp.map(func)
         return tmp
@@ -268,7 +268,7 @@ class Matrix:
             zero = 0 * self[0]
         except:
             zero = 0
-        return Matrix([[ zero for j in range(n)] for i in range(m) ])
+        return Matrix([[ 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"
@@ -288,11 +288,11 @@ class Matrix:
         return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])
 
 
-def zeros(m: int, n: int = None) -> "Matrix":
+def zeros(m: int, n: int = None, zero = 0) -> "Matrix":
     "Returns a zero matrix of the given dimension"
     if not n:
         n = m
-    return Matrix([[ 0 for j in range(n)] for i in range(m) ])
+    return Matrix([[ zero for j in range(n) ] for i in range(m) ])
 
 def eye(m:int, n: int = None) -> "Matrix":
     "Returns an identity matrix of the given dimension"

{kryptools-0.6 → kryptools-0.8}/kryptools/poly.py

@@ -10,17 +10,17 @@ class Poly:
     
     Example:
     
-    To define a polynomial as alist of coefficients use
+    To define a polynomial as a list of coefficients use
     >>> Poly([1, 2, 3])
     3 x^2 + 2 x + 1
     """
 
     def __init__(self, coeff: list, ring = None, modulus: list = None):
-        for i in range(len(coeff) - 1, 0, -1):
-            if coeff[i]:
+        self.coeff = list(coeff)
+        for i in range(len(self.coeff) - 1, 0, -1):
+            if self.coeff[i]:
                 break
-            coeff.pop(i)
-        self.coeff = coeff
+            self.coeff.pop(i)
         self.modulus = modulus
         if ring:
             self.map(ring)
@@ -86,14 +86,18 @@ class Poly:
     def __bool__(self):
         return bool(self.degree()) or bool(self.coeff[0])
 
-    def degree(self):
+    def degree(self) -> int:
         "Return the degree."
         return len(self.coeff) - 1
 
     def map(self, func):
-        "Apply a given function to all coefficients."
+        "Apply a given function to all coefficients in place."
         self.coeff = list(map(func, self.coeff))
 
+    def applyfunc(self, func) -> "Poly":
+        "Apply a function to all coefficients."
+        return self.__class__(list(map(func, self.coeff)), modulus=self.modulus)
+
     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])
 
@@ -129,6 +133,9 @@ class Poly:
     def __neg__(self) -> "Poly":
         return Poly([-s for s in self.coeff], modulus=self.modulus)
 
+    def __pos__(self) -> "Poly":
+        return self
+
     def __sub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
             if self._check_type(other):
@@ -196,23 +203,36 @@ class Poly:
             raise NotImplementedError("Cannot invert polynomials without modulus.")
         return other * self.inv()
 
-    def __pow__(self, i: int) -> "Poly":
-        if not isinstance(i, int):
+    def __pow__(self, j: int) -> "Poly":
+        if not isinstance(j, int):
             return NotImplemented
         zero = 0 * self.coeff[0]
         one = zero + 1
         res = self.__class__([one], modulus=self.modulus)
-        if i < 0:
+        if j < 0:
             if not self.modulus:
                 raise NotImplementedError("Cannot divide polynomials without modulus.")
             tmp = self.inv()
-            i *= -1
+            j *= -1
         else:
             tmp = self
-        for _ in range(i):
-            res *= tmp
+        while j > 0:
+            # If j is odd, multiply
+            if j & 1:
+                res *= tmp
+            # Now square
+            j = j >> 1  # j= j//2
+            tmp *= tmp
         return res
 
+    def max(self) -> int:
+        "Maximum of the absolute value of all coefficients."
+        return max([abs(c) for c in self.coeff])
+
+    def sum(self) -> int:
+        "Sum of the absolute value of all coefficients."
+        return sum([abs(c) for c in self.coeff])
+
     def __floordiv__(self, other: "Poly") -> "Poly":
         return self.divmod(other)[0]
 

{kryptools-0.6 → kryptools-0.8}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.6
+Version: 0.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
@@ -27,7 +27,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

{kryptools-0.6 → kryptools-0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryptools"
-version = "0.6"
+version = "0.8"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]