'Refactored by Sourcery'

FormalDerivative.py

@@ -1,5 +1,5 @@
 def FormalDerivative(Fx):
- return [(x[0] * x[1], x[1] - 1) for x in Fx if (x[1]-1) > -1]
+ return [(x[0] * x[1], x[1] - 1) for x in Fx if x[1] > 0]
 
 
 def polyrep(Fx):

binGCD.py

@@ -12,15 +12,9 @@ def gcd(a, b):
  if b == 0:
  return a
  if a & 1 == 1:
- if b & 1 == 0:
- return gcd(a, b >> 1)
- else:
- return gcd(abs(a - b), min(a, b))
+ return gcd(a, b >> 1) if b & 1 == 0 else gcd(abs(a - b), min(a, b))
  else:
- if b & 1 == 1:
- return gcd(a >> 1, b)
- else:
- return 2 * gcd(a >> 1, b >> 1)
+ return gcd(a >> 1, b) if b & 1 == 1 else 2 * gcd(a >> 1, b >> 1)
 
 
 def test():

dft.py

@@ -27,10 +27,7 @@ def Fk(signal, k):
 
 def nyquist_norm(histogram):
  N = len(histogram)
- tmp = []
- for n in range(0, N / 2):
- tmp.append(histogram[n] * 2)
- return tmp
+ return [histogram[n] * 2 for n in range(0, N / 2)]
 
 
 print nyquist_norm(dft_slow(signal))

dx.py

@@ -7,8 +7,7 @@
 
 
 def __df(f, x, h):
- r = (f(x + h / 2) - f(x - h / 2)) / h
- return r
+ return (f(x + h / 2) - f(x - h / 2)) / h
 
 
 def derivative(f):

e.py

@@ -11,18 +11,14 @@
 
 def direct_e():
  x = 6444429920 + 0.22 # or int(0x1801e3260,16) + 0.22
- ret = (1 + (1.0 / x)) ** x
- return ret
+ return (1 + (1.0 / x)) ** x
 
 
 # taylor aproximation of e
 
 
 def taylor_e():
- accum = 0
- for n in xrange(0, 15):
- accum += 1.0 / (math.factorial(n))
- return accum
+ return sum(1.0 / (math.factorial(n)) for n in xrange(0, 15))
 
 
 # by limits definition:
@@ -49,7 +45,7 @@ def test():
 pi = math.pi
 
 def exp(n, precision=100):
- return sum([(n ** x) / math.factorial(x) for x in range(0, precision)])
+  return sum((n ** x) / math.factorial(x) for x in range(0, precision))
 
 def test_exp():
  print(exp(0))

fft.py

@@ -4,14 +4,13 @@
 pi_i = (-2j) * complex(gmpy2.const_pi())
 
 def fft(X):
- if (N:=len(X)) == 1: 
+ if (N:=len(X)) == 1:
  return X
- else:
- N2 = N >> 1
- E = fft(X[::2])
- O = fft(X[1::2])
- for k in range(0, N2):
- q = exp((pi_i * k) / N ) * O[k]
- X[k] = E[k] + q
- X[k + N2] = E[k] - q
+ N2 = N >> 1
+ E = fft(X[::2])
+ O = fft(X[1::2])
+ for k in range(0, N2):
+ q = exp((pi_i * k) / N ) * O[k]
+ X[k] = E[k] + q
+ X[k + N2] = E[k] - q
  return X

legendre_symbol.py

@@ -17,7 +17,7 @@ def factor(n0):
  while n % i == 0:
  n = n // i
  factors.append(i)
- if len(factors) == 0:
+ if not factors:
  factors = [n]
  print("factor(%d)=%s" % (n0, str(factors)))
  return factors
@@ -42,7 +42,7 @@ def legendre_naive(p, q):
 def legendre_prop0(p, q):
  print("legendre_prop0(%d|%d)" % (p, q))
  phi = (p - 1) * (q - 1)
- _pow = pow(int(-1), int(phi // 4))
+ _pow = pow(-1, int(phi // 4))
  return _pow * legendre_naive(q, p)
 
 
@@ -79,18 +79,17 @@ def _legendre(p, q):
  ret = legendre_naive(q, p)
  if p1 == 2:
  ret = legendre_prop1(p1, q)
- else:
- if p1 > 2:
- fp1 = factor(p1)[::-1]
- tmp = 1
- for f in fp1:
- # while tmp2 > 1:
- if f == 2:
- tmp *= legendre_prop1(f, q)
- else:
- tmp *= _legendre(q, f)
- # tmp = legendre_prop2(p1,q)
- ret = tmp
+ elif p1 > 2:
+ fp1 = factor(p1)[::-1]
+ tmp = 1
+ for f in fp1:
+ # while tmp2 > 1:
+ if f == 2:
+ tmp *= legendre_prop1(f, q)
+ else:
+ tmp *= _legendre(q, f)
+ # tmp = legendre_prop2(p1,q)
+ ret = tmp
  print("<legendre(%d|%d) r=%d -> %d" % (p, q, r, ret))
  return ret
 

math_rels.py

@@ -11,17 +11,11 @@ def sgn(x):
 
 
 def max(a, b):
- if b > a:
- return b
- else:
- return a
+ return max(b, a)
 
 
 def min(a, b):
- if b < a:
- return b
- else:
- return a
+ return min(b, a)
 
 
 def close(a, b, e):

mean.py

@@ -5,9 +5,7 @@
 # AM => GM => HM
 # arithmetric mean
 def AM(data):
- accum = 0
- for i in range(0, len(data) - 1):
- accum += data[i]
+ accum = sum(data[i] for i in range(0, len(data) - 1))
  return accum / len(data)
 
 
@@ -21,7 +19,5 @@ def GM(data):
 
 # harmonic mean
 def HM(data):
- accum = 0
- for i in range(0, len(data) - 1):
- accum += 1 / data[i]
+ accum = sum(1 / data[i] for i in range(0, len(data) - 1))
  return len(data) * (accum ** -1)

newton_method.py

@@ -15,13 +15,13 @@ def newtons_method(
  epsilon, # Do not divide by a number smaller than this
  max_iterations, # The maximum number of iterations to execute
  ):
- for i in range(max_iterations):
- y = f(x0)
- yprime = f_prime(x0)
- if abs(yprime) < epsilon: # Stop if the denominator is too small
-  break
- x1 = x0 - y / yprime # Do Newton's computation
- if abs(x1 - x0) <= tolerance: # Stop when the result is within the desired tolerance
-  return x1 # x1 is a solution within tolerance and maximum number of iterations
- x0 = x1 # Update x0 to start the process again
- return None
+ for _ in range(max_iterations):
+ y = f(x0)
+ yprime = f_prime(x0)
+ if abs(yprime) < epsilon: # Stop if the denominator is too small
+  break
+ x1 = x0 - y / yprime # Do Newton's computation
+ if abs(x1 - x0) <= tolerance: # Stop when the result is within the desired tolerance
+  return x1 # x1 is a solution within tolerance and maximum number of iterations
+ x0 = x1 # Update x0 to start the process again
+ return None

polysolv.py

@@ -32,10 +32,7 @@ def poly_synthetic_div(P, Q):
  R = [0] * lP
 
  for i in range(0, lP):
- if i == 0:
- R[i] = P[i]
- else:
- R[i] = P[i] + Q * R[i - 1]
+ R[i] = P[i] if i == 0 else P[i] + Q * R[i - 1]
  return R
 
 
@@ -57,8 +54,7 @@ def get_rationals(poly, grade):
  tmp.append(div)
  tmp2 = []
  for r in set(sorted(tmp)):
- tmp2.append(r)
- tmp2.append(-r)
+ tmp2.extend((r, -r))
  return tmp2
 
 

ramanujan_sum.py

@@ -6,11 +6,7 @@
 ipi2 = (2j) * complex(gmpy2.const_pi())
 
 def c(q,n):
- sum_ = 0
  nipi2 = ipi2 * n
- for a in range(1, q+1):
- if gcd(a,q) == 1:
- sum_ += exp(nipi2 * (a/q))
- return sum_
+ return sum(exp(nipi2 * (a/q)) for a in range(1, q+1) if gcd(a,q) == 1)
 
 print([c(1,n).real for n in range(1, 31)])

redc.py

@@ -74,7 +74,7 @@ def test():
  from functools import reduce
  p = 2
  TMP=[]
- for i in range(1,210):
+ for _ in range(1,210):
  p = int(gmpy2.next_prime(p))
  TMP.append(MontgomeryReducer(p,gmpy=gmpy2))
  C = reduce(mul,TMP)

ruffini.py

@@ -7,11 +7,7 @@
 
 # tells if a n is prime or not
 def isPrime(n):
- for i in range(2, int(n ** 0.5) + 1):
- if n % i == 0:
- return False
-
- return True
+ return all(n % i != 0 for i in range(2, int(n ** 0.5) + 1))
 
 
 # finds the prime factors of n
@@ -29,16 +25,14 @@ def factors(n):
  if isPrime(num):
  factor.append(num)
  break
- factor = sorted(factor)
- return factor
+ return sorted(factor)
 
 
 # add the negative factors to try
 def addnegatives(D):
  nD = []
  for i in D:
- nD.append(-abs(i))
- nD.append(abs(i))
+ nD.extend((-abs(i), abs(i)))
  return nD
 
 
@@ -52,7 +46,7 @@ def ruffini_step(P, D):
  tmpPoli.append(P[j])
  else:
  tmpPoli.append(P[j] + (D[i] * tmpPoli[j - 1]))
- if tmpPoli[len(tmpPoli) - 1] == 0:
+ if tmpPoli[-1] == 0:
  return [D[i], tmpPoli]
 
 

seqmult.py

@@ -9,7 +9,7 @@ def SeqMult(s):
  if l % 2 != 0:
  s += [1]
  l += 1
- s = list(map(mul, s[0 : l // 2], s[l // 2 :]))
+ s = list(map(mul, s[:l // 2], s[l // 2 :]))
  l = len(s)
  return s[0]
 

sieve.py

@@ -2,25 +2,15 @@
 
 
 def sieve_Erathostenes(n):
- sieves = []
- primes = []
-
- # initialize
- for l in range(0, n):
- sieves.append(True)
-
+ sieves = [True for _ in range(0, n)]
  # sieving
  for i in range(2, int(math.sqrt(n))):
  if sieves[i] == True:
  for j in range(0, n):
  h = (i ** 2) + (j * i)
  if h < n:
  sieves[h] = False
- # filtering
- for k in range(2, n):
- if sieves[k] == True:
- primes.append(k)
- return primes
+ return [k for k in range(2, n) if sieves[k] == True]
 
 
 print sieve_Erathostenes(121)

sign.py

@@ -5,18 +5,12 @@
 
 # absolute value of x
 def _abs(x):
- if x >= 0:
- return x
- else:
- return -x
+ return x if x >= 0 else -x
 
 
 # sign of x returns: [-1,1]
 def sign(x):
- if x == 0:
- return 0
- else:
- return x / _abs(x)
+ return 0 if x == 0 else x / _abs(x)
 
 
 def almostEqual(a, b, epsilon):

test_inv.py

@@ -7,15 +7,13 @@ def compute_modinv_1_n(n, p):
  https://codeforces.com/blog/entry/83075
  """
  inv = [0, 1]
- for i in range(2, n):
- inv.append((p - p // i) * inv[p % i] % p)
+ inv.extend((p - p // i) * inv[p % i] % p for i in range(2, n))
  return inv
 
 @timing
 def compute_modinv_gmpy_1_n(n, p):
  inv = [0]
- for i in range(1, n):
- inv.append(int(invert(i, p)))
+ inv.extend(int(invert(i, p)) for i in range(1, n))
  return inv
 
 

vectors.py

@@ -54,10 +54,7 @@ def normalize(vec):
 
 
 def magnitude(vec):
- res = 0
- for n in range(0, len(vec)):
- res += vec[n] * vec[n]
-
+ res = sum(vec[n] * vec[n] for n in range(0, len(vec)))
  return math.sqrt(res)