Merge pull request #2 from daedalus/sourcery/master

Sourcery refactored master branch

Author: daedalus

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