'Refactored by Sourcery'

Author: Sourcery AI

MPQS.sage

@@ -69,8 +69,6 @@ def prebuilt_params(bits):
         return [900000, 150, 50 * 65536]
     if bits <= 490:
         return [1100000, 150, 75 * 65536]
-    if bits <= 512:
-        return [1300000, 150, 100 * 65536]
     return [1300000, 150, 100 * 65536]
 
 
@@ -113,10 +111,10 @@ def choose_multiplier(n, prime_list):
         if knmod8 == 5:
             scores[i] -= M_LN2;
             break;
-        if knmod8 == 3 or knmod8 == 7:
+        if knmod8 in [3, 7]:
             scores[i] -= 0.5 * M_LN2;
             break;
-        # even multipliers start with a handicap
+            # even multipliers start with a handicap
     num_multipliers = i;
 
     # for the rest of the small factor base primes 
@@ -131,7 +129,7 @@ def choose_multiplier(n, prime_list):
             knmodp = (curr_mult * modp) % prime
             # if prime i is actually in the factor base
             #   for k * n ... */
-            if (knmodp == 0 or legendre(knmodp, prime) == 1):
+            if knmodp == 0:
 
                 """ ...add its contribution. A prime p con-
                    tributes log(p) to 1 in p sieve values, plus
@@ -147,18 +145,31 @@ def choose_multiplier(n, prime_list):
                    the prime divides k*n. In that case there 
                    is only one root """
 
-                if (knmodp == 0):
-                    scores[j] -= contrib
-                else:
-                    scores[j] -= 2 * contrib
+                scores[j] -= contrib
+            elif legendre(knmodp, prime) == 1:
+
+                """ ...add its contribution. A prime p con-
+                   tributes log(p) to 1 in p sieve values, plus
+                   log(p) to 1 in p^2 sieve values, etc. The
+                   average contribution of all multiples of p 
+                   to a random sieve value is thus
+                   log(p) * (1/p + 1/p^2 + 1/p^3 + ...)
+                   = (log(p) / p) * 1 / (1 - (1/p)) 
+                   = log(p) / (p-1)
+                   This contribution occurs once for each
+                   square root used for sieving. There are two
+                   roots for each factor base prime, unless
+                   the prime divides k*n. In that case there 
+                   is only one root """
 
+                scores[j] -= contrib if (knmodp == 0) else 2 * contrib
     # use the multiplier that generates the best score 
 
     best_score = 1000.0
     best_mult = 1
 
     #print(scores)
-   
+
     for i in range(0, num_multipliers):
         score = scores[i];
         if (score < best_score):
@@ -212,15 +223,14 @@ def trial_division(n, P):
     l = len(P)
     i = 0
     for p in P:
-        if r >= p:
-            if r % p == 0:
-                pw = 0
-                while r % p == 0:
-                    pw += 1
-                    r //= p
-                a.append((int(p),int(pw)))
-        else:
+        if r < p:
             break
+        if r % p == 0:
+            pw = 0
+            while r % p == 0:
+                pw += 1
+                r //= p
+            a.append((int(p),int(pw)))
     return a,r,n
 
 
@@ -234,10 +244,7 @@ def merge_powers(ppws):
             d[p] = pw
         else:
             d[p] += pw
-    tmp2 = []
-    for p in d:
-       tmp2.append((p,d[p]))
-    return tmp2
+    return list(d.items())
 
 
 def filter_out_even_powers(ppws):
@@ -250,11 +257,7 @@ def filter_out_even_powers(ppws):
             d[p] = pw
         else:
             d[p] += pw
-    tmp2 = []
-    for p in d:
-        if d[p] & 1 != 0: # only keep odd powers
-            tmp2.append(p)
-    return tmp2
+    return [p for p, value in d.items() if value & 1 != 0]
 
 
 def trial_division_minus_even_powers(n, P):
@@ -297,13 +300,12 @@ def is_power_logprime(n, log_primes):
     Given the precomputed logs of a set of primes 
     we can test if a number n is a perfect power of that prime.
     """
-    ispow = False
     for p in log_primes:
         a = log(n) / p
         b = int(a)
         if a == b:
             iwpow = True
-    return ispow
+    return False
 
 
 def minifactor4(x, P, smooth_base):
@@ -337,7 +339,7 @@ class Poly:
         #self.counter = 0
         self.early_factors = []
 
-        if A == None and B == None and C == None:
+        if A is None and B is None and C is None:
             self.create()
         else:
             print("given poly parameters: %d %d %d" % (A,B,C))
@@ -401,15 +403,15 @@ class Poly:
         Code borrowed https://github.com/cramppet/quadratic-sieve/blob/master/QS.py
         """        
         A = self.A
-        B = self.B
         C = self.C
         n = self.n
         p = self.root_A
         if A > 1:
             g = 1
+            ainv = 1
+            B = self.B
             while g == 1:
                 p = next_prime(p)
-                ainv = 1
                 if A != 1:
                     g, inv, _ = gcdext(A, p)
                     if g != 1:
@@ -442,9 +444,8 @@ class Poly:
         """
         Return the string representation of the constructed polynomial
         """
-        m = "F(X) = %d X ^ 2 + %d X + %d with minima: %d" % (self.A, self.B, self.C, self.minima) 
-        m = m.replace("+ -","- ")
-        return m
+        m = "F(X) = %d X ^ 2 + %d X + %d with minima: %d" % (self.A, self.B, self.C, self.minima)
+        return m.replace("+ -","- ")
 
 
     def __add__(self, other):
@@ -486,9 +487,7 @@ class Poly:
         """
         Hashes unique values of the polynomial to construct an python internal id.
         """
-        h = hash("%d-%d-%d" % (self.A,self.B,self.C))
-        #print("hash: %s" % h)
-        return h
+        return hash("%d-%d-%d" % (self.A,self.B,self.C))
 
 
     def __eq__(self, other):

PisanoPeriod.py

@@ -23,14 +23,10 @@ def _fib_res(self,n,p):
         """ fibonacci sequence nth item modulo p """
         if n == 0:
             return (0, 1)
-        else:
-            a, b = self._fib_res(n >> 1,p)
-            c = mod((mod(a, p) * mod(((b << 1) - a), p)), p)
-            d = mod((powmod(a, 2, p) + powmod(b, 2, p)), p)
-            if n & 1 == 0: 
-                return (c, d)
-            else:
-                return (d, mod((c + d), p))
+        a, b = self._fib_res(n >> 1,p)
+        c = mod((mod(a, p) * mod(((b << 1) - a), p)), p)
+        d = mod((powmod(a, 2, p) + powmod(b, 2, p)), p)
+        return (c, d) if n & 1 == 0 else (d, mod((c + d), p))
 
 
     def get_n_mod_d(self,n,d, use = 'mersenne'):
@@ -45,9 +41,7 @@ def get_n_mod_d(self,n,d, use = 'mersenne'):
 
     def ranged_period(self, N, start, stop, look_up_dest):
         print("ranged_period (%d,%d) start" % (start,stop))
-        tmp_look_up = {}
-        for x in range(start, stop):
-            tmp_look_up[self.get_n_mod_d(x, N)] = x
+        tmp_look_up = {self.get_n_mod_d(x, N): x for x in range(start, stop)}
         look_up_dest.update(tmp_look_up)
         #look_up_dest |= tmp_look_up
         print("ranged_period (%d,%d) end" % (start,stop))
@@ -56,24 +50,22 @@ def ranged_period(self, N, start, stop, look_up_dest):
 
     def get_period_bigint(self, N, min_accept, xdiff, verbose = False):            
         search_len = int(pow(N, (1.0 / 6) / 100))
-        
-        if search_len < min_accept:
-            search_len = min_accept
-  
+
+        search_len = max(search_len, min_accept)
         if self.verbose:
             print('Search_len: %d, log2(N): %d' % (search_len,int(log2(N))))
-        
+
         starttime = time.time()
-        diff = xdiff 
+        diff = xdiff
         p_len = int((len(str(N)) + diff) >> 1) + 1
-        begin = N - int('9'*p_len) 
+        begin = N - int('9'*p_len)
         if begin <= 0:
             begin = 1
         end = N + int('9' * p_len)
-    
+
         if self.verbose:    
             print('Search begin: %d, end: %d'%(begin, end))
-        
+
         if self.multitasked and search_len > 1000:
             C = cpu_count() * 2
             search_work = search_len // C
@@ -84,10 +76,10 @@ def get_period_bigint(self, N, min_accept, xdiff, verbose = False):
             if self.verbose:
                 print("Precompute LUT with %d tasks..." % C)
 
-            inputs = []
-            for x in range(0, search_len, search_work):
-                inputs += [(N, x, x + search_work, look_up)]
-
+            inputs = [
+                (N, x, x + search_work, look_up)
+                for x in range(0, search_len, search_work)
+            ]
             workpool = Pool(C)
 
             with workpool:
@@ -103,10 +95,10 @@ def get_period_bigint(self, N, min_accept, xdiff, verbose = False):
         if self.verbose:
             print("LUT creation ended size: %d..." % len(look_up))
             print("Searching...")
-        
 
-        while True:       
-            randi = random.randint(begin,end)            
+
+        while True:   
+            randi = random.randint(begin,end)
             res = self.get_n_mod_d(randi, N)
             if res > 0:
                 #print(res, res in look_up)
@@ -122,13 +114,15 @@ def get_period_bigint(self, N, min_accept, xdiff, verbose = False):
                         else:
                             if self.verbose:
                                 print('For N = %d\n Found res: %d, res_n: %d , T: %d\n but failed!' % (N, res, res_n, T))
-            else:
-                if randi & 1 == 0:
-                    T = randi
-                    td = int(time.time() - starttime)
-                    if self.verbose:
-                        print('First shot, For N = %d Found T:%d, randi: %d, time used %f secs.' % (N , T, randi, td))
-                    return td, T, randi
+            elif randi & 1 == 0:
+                td = int(time.time() - starttime)
+                T = randi
+                if self.verbose:
+                    print(
+                        'First shot, For N = %d Found T:%d, randi: %d, time used %f secs.'
+                        % (N, T, T, td)
+                    )
+                return td, T, T
 
 
     def _trivial_factorization_with_n_phi(self, N, T):
@@ -142,24 +136,16 @@ def _trivial_factorization_with_n_phi(self, N, T):
 
         if phi2m4d > 0:
             iphi2m4d = isqrt(phi2m4d)
-            p1.append(phi + iphi2m4d)
-            p1.append(phi - iphi2m4d)
-
+            p1.extend((phi + iphi2m4d, phi - iphi2m4d))
         if phi2p4d > 0:
             iphi2p4d = isqrt(phi2p4d)
-            p1.append(phi + iphi2p4d)
-            p1.append(phi - iphi2p4d)
-
+            p1.extend((phi + iphi2p4d, phi - iphi2p4d))
         if phi2m4d > 0:
             iphi2m4d = isqrt(phi2m4d)
-            p1.append(-phi + iphi2m4d)
-            p1.append(-phi - iphi2m4d)
-
+            p1.extend((-phi + iphi2m4d, -phi - iphi2m4d))
         if phi2p4d > 0:
             iphi2p4d = isqrt(phi2p4d)
-            p1.append(-phi + iphi2p4d)
-            p1.append(-phi - iphi2p4d)
-
+            p1.extend((-phi + iphi2p4d, -phi - iphi2p4d))
         for p in p1:
             g = gcd((p >> 1),N)
             if N > g > 1:
@@ -224,7 +210,7 @@ def test(Ns,B2=0):
         if P != None:
             phi = (P[0]-1) * (P[1]-1)
             print("phi(N): %d" % phi)
-            print("factors: %s" % str(P))
+            print(f"factors: {str(P)}")
             ff += 1
         td = time.time() - ti
         ttd = time.time() - tti
@@ -235,27 +221,27 @@ def test(Ns,B2=0):
 
 
 def test2():
-  Fib = Fibonacci()
-  N = 384237701921
-  B1s = [10**x for x in range(6,3,-1)]
-  B2s = [0,2,4,6,8]
-  n=1
-  tti = time.time()
-  for B1 in B1s:
-      for B2 in B2s:
-          ti = time.time()
-          print("Test: %d, N: %d, log2(N): %d, B1: %d, B2: %d" % (n, N,int(log2(N)),B1,B2))
-          P = Fib.factorization(N,B1,B2)
-          if P != None:
-              phi = (P[0]-1) * (P[1]-1)
-              print("phi(N): %d" % phi)
-              print("factors: %s" % str(P))
-              ff += 1
-          td = time.time() - ti
-          ttd = time.time() - tti
-          print("Runtime: %f\nFully factored:%d of %d" % (td,ff,l))
-          print("Runtime total: %f" % (ttd))
-          n += 1
+    Fib = Fibonacci()
+    N = 384237701921
+    B1s = [10**x for x in range(6,3,-1)]
+    B2s = [0,2,4,6,8]
+    n=1
+    tti = time.time()
+    for B1 in B1s:
+        for B2 in B2s:
+            ti = time.time()
+            print("Test: %d, N: %d, log2(N): %d, B1: %d, B2: %d" % (n, N,int(log2(N)),B1,B2))
+            P = Fib.factorization(N,B1,B2)
+            if P != None:
+                phi = (P[0]-1) * (P[1]-1)
+                print("phi(N): %d" % phi)
+                print(f"factors: {str(P)}")
+                ff += 1
+            td = time.time() - ti
+            ttd = time.time() - tti
+            print("Runtime: %f\nFully factored:%d of %d" % (td,ff,l))
+            print("Runtime total: %f" % (ttd))
+            n += 1
 
 
 def test3(N, B2 = 0):
@@ -291,7 +277,7 @@ def test4(l,B2=0):
         if P != None:
             phi = (P[0]-1) * (P[1]-1)
             print("phi(N): %d" % phi)
-            print("factors: %s" % str(P))
+            print(f"factors: {str(P)}")
             ff += 1
         td = time.time() - ti
         ttd = time.time() - tti