algorithm/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2026-03-13 09:50:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add pep8-naming to pre-commit hooks and fixes incorrect naming conventions (#7062)

Browse Source 
* ci(pre-commit): Add pep8-naming to `pre-commit` hooks (#7038)

* refactor: Fix naming conventions (#7038)

* Update arithmetic_analysis/lu_decomposition.py

Co-authored-by: Christian Clauss <cclauss@me.com>

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* refactor(lu_decomposition): Replace `NDArray` with `ArrayLike` (#7038)

* chore: Fix naming conventions in doctests (#7038)

* fix: Temporarily disable project euler problem 104 (#7069)

* chore: Fix naming conventions in doctests (#7038)

Co-authored-by: Christian Clauss <cclauss@me.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Caeden
2022-10-12 23:54:20 +01:00
committed by GitHub
parent e2cd982b11
commit 07e991d553
140 changed files with 1552 additions and 1536 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
maths/binomial_coefficient.py
View File

@@ -5,16 +5,16 @@ def binomial_coefficient(n, r):
>>> binomial_coefficient(10, 5)
252
"""
C = [0 for i in range(r + 1)]
c = [0 for i in range(r + 1)]
# nc0 = 1
C[0] = 1
c[0] = 1
for i in range(1, n + 1):
# to compute current row from previous row.
j = min(i, r)
while j > 0:
C[j] += C[j - 1]
c[j] += c[j - 1]
j -= 1
return C[r]
return c[r]
print(binomial_coefficient(n=10, r=5))

4
maths/carmichael_number.py
View File

@@ -30,7 +30,7 @@ def power(x: int, y: int, mod: int) -> int:
return temp
def isCarmichaelNumber(n: int) -> bool:
def is_carmichael_number(n: int) -> bool:
b = 2
while b < n:
if gcd(b, n) == 1 and power(b, n - 1, n) != 1:
@@ -41,7 +41,7 @@ def isCarmichaelNumber(n: int) -> bool:
if __name__ == "__main__":
number = int(input("Enter number: ").strip())
if isCarmichaelNumber(number):
if is_carmichael_number(number):
print(f"{number} is a Carmichael Number.")
else:
print(f"{number} is not a Carmichael Number.")

6
maths/decimal_isolate.py
View File

@@ -4,7 +4,7 @@ https://stackoverflow.com/questions/3886402/how-to-get-numbers-after-decimal-poi
"""
def decimal_isolate(number, digitAmount):
def decimal_isolate(number, digit_amount):
"""
Isolates the decimal part of a number.
@@ -28,8 +28,8 @@ def decimal_isolate(number, digitAmount):
>>> decimal_isolate(-14.123, 3)
-0.123
"""
if digitAmount > 0:
return round(number - int(number), digitAmount)
if digit_amount > 0:
return round(number - int(number), digit_amount)
return number - int(number)

6
maths/euler_method.py
View File

@@ -29,12 +29,12 @@ def explicit_euler(
>>> y[-1]
144.77277243257308
"""
N = int(np.ceil((x_end - x0) / step_size))
y = np.zeros((N + 1,))
n = int(np.ceil((x_end - x0) / step_size))
y = np.zeros((n + 1,))
y[0] = y0
x = x0
for k in range(N):
for k in range(n):
y[k + 1] = y[k] + step_size * ode_func(x, y[k])
x += step_size

6
maths/euler_modified.py
View File

@@ -33,12 +33,12 @@ def euler_modified(
>>> y[-1]
0.5525976431951775
"""
N = int(np.ceil((x_end - x0) / step_size))
y = np.zeros((N + 1,))
n = int(np.ceil((x_end - x0) / step_size))
y = np.zeros((n + 1,))
y[0] = y0
x = x0
for k in range(N):
for k in range(n):
y_get = y[k] + step_size * ode_func(x, y[k])
y[k + 1] = y[k] + (
(step_size / 2) * (ode_func(x, y[k]) + ode_func(x + step_size, y_get))

6
maths/hardy_ramanujanalgo.py
View File

@@ -4,9 +4,9 @@
import math
def exactPrimeFactorCount(n):
def exact_prime_factor_count(n):
"""
>>> exactPrimeFactorCount(51242183)
>>> exact_prime_factor_count(51242183)
3
"""
count = 0
@@ -36,7 +36,7 @@ def exactPrimeFactorCount(n):
if __name__ == "__main__":
n = 51242183
print(f"The number of distinct prime factors is/are {exactPrimeFactorCount(n)}")
print(f"The number of distinct prime factors is/are {exact_prime_factor_count(n)}")
print(f"The value of log(log(n)) is {math.log(math.log(n)):.4f}")
"""

48
maths/jaccard_similarity.py
View File

@@ -14,7 +14,7 @@ Jaccard similarity is widely used with MinHashing.
"""
def jaccard_similariy(setA, setB, alternativeUnion=False):
def jaccard_similariy(set_a, set_b, alternative_union=False):
"""
Finds the jaccard similarity between two sets.
Essentially, its intersection over union.
@@ -24,8 +24,8 @@ def jaccard_similariy(setA, setB, alternativeUnion=False):
of a set with itself be 1/2 instead of 1. [MMDS 2nd Edition, Page 77]
Parameters:
:setA (set,list,tuple): A non-empty set/list
:setB (set,list,tuple): A non-empty set/list
:set_a (set,list,tuple): A non-empty set/list
:set_b (set,list,tuple): A non-empty set/list
:alternativeUnion (boolean): If True, use sum of number of
items as union
@@ -33,48 +33,48 @@ def jaccard_similariy(setA, setB, alternativeUnion=False):
(float) The jaccard similarity between the two sets.
Examples:
>>> setA = {'a', 'b', 'c', 'd', 'e'}
>>> setB = {'c', 'd', 'e', 'f', 'h', 'i'}
>>> jaccard_similariy(setA,setB)
>>> set_a = {'a', 'b', 'c', 'd', 'e'}
>>> set_b = {'c', 'd', 'e', 'f', 'h', 'i'}
>>> jaccard_similariy(set_a, set_b)
0.375
>>> jaccard_similariy(setA,setA)
>>> jaccard_similariy(set_a, set_a)
1.0
>>> jaccard_similariy(setA,setA,True)
>>> jaccard_similariy(set_a, set_a, True)
0.5
>>> setA = ['a', 'b', 'c', 'd', 'e']
>>> setB = ('c', 'd', 'e', 'f', 'h', 'i')
>>> jaccard_similariy(setA,setB)
>>> set_a = ['a', 'b', 'c', 'd', 'e']
>>> set_b = ('c', 'd', 'e', 'f', 'h', 'i')
>>> jaccard_similariy(set_a, set_b)
0.375
"""
if isinstance(setA, set) and isinstance(setB, set):
if isinstance(set_a, set) and isinstance(set_b, set):
intersection = len(setA.intersection(setB))
intersection = len(set_a.intersection(set_b))
if alternativeUnion:
union = len(setA) + len(setB)
if alternative_union:
union = len(set_a) + len(set_b)
else:
union = len(setA.union(setB))
union = len(set_a.union(set_b))
return intersection / union
if isinstance(setA, (list, tuple)) and isinstance(setB, (list, tuple)):
if isinstance(set_a, (list, tuple)) and isinstance(set_b, (list, tuple)):
intersection = [element for element in setA if element in setB]
intersection = [element for element in set_a if element in set_b]
if alternativeUnion:
union = len(setA) + len(setB)
if alternative_union:
union = len(set_a) + len(set_b)
else:
union = setA + [element for element in setB if element not in setA]
union = set_a + [element for element in set_b if element not in set_a]
return len(intersection) / len(union)
if __name__ == "__main__":
setA = {"a", "b", "c", "d", "e"}
setB = {"c", "d", "e", "f", "h", "i"}
print(jaccard_similariy(setA, setB))
set_a = {"a", "b", "c", "d", "e"}
set_b = {"c", "d", "e", "f", "h", "i"}
print(jaccard_similariy(set_a, set_b))

6
maths/krishnamurthy_number.py
View File

@@ -33,12 +33,12 @@ def krishnamurthy(number: int) -> bool:
True
"""
factSum = 0
fact_sum = 0
duplicate = number
while duplicate > 0:
duplicate, digit = divmod(duplicate, 10)
factSum += factorial(digit)
return factSum == number
fact_sum += factorial(digit)
return fact_sum == number
if __name__ == "__main__":

6
maths/kth_lexicographic_permutation.py
View File

@@ -1,17 +1,17 @@
def kthPermutation(k, n):
def kth_permutation(k, n):
"""
Finds k'th lexicographic permutation (in increasing order) of
0,1,2,...n-1 in O(n^2) time.
Examples:
First permutation is always 0,1,2,...n
>>> kthPermutation(0,5)
>>> kth_permutation(0,5)
[0, 1, 2, 3, 4]
The order of permutation of 0,1,2,3 is [0,1,2,3], [0,1,3,2], [0,2,1,3],
[0,2,3,1], [0,3,1,2], [0,3,2,1], [1,0,2,3], [1,0,3,2], [1,2,0,3],
[1,2,3,0], [1,3,0,2]
>>> kthPermutation(10,4)
>>> kth_permutation(10,4)
[1, 3, 0, 2]
"""
# Factorails from 1! to (n-1)!

4
maths/lucas_lehmer_primality_test.py
View File

@@ -30,9 +30,9 @@ def lucas_lehmer_test(p: int) -> bool:
return True
s = 4
M = (1 << p) - 1
m = (1 << p) - 1
for i in range(p - 2):
s = ((s * s) - 2) % M
s = ((s * s) - 2) % m
return s == 0

140
maths/primelib.py
View File

@@ -8,27 +8,27 @@ prime numbers and whole numbers.
Overview:
isPrime(number)
sieveEr(N)
getPrimeNumbers(N)
primeFactorization(number)
greatestPrimeFactor(number)
smallestPrimeFactor(number)
getPrime(n)
getPrimesBetween(pNumber1, pNumber2)
is_prime(number)
sieve_er(N)
get_prime_numbers(N)
prime_factorization(number)
greatest_prime_factor(number)
smallest_prime_factor(number)
get_prime(n)
get_primes_between(pNumber1, pNumber2)
----
isEven(number)
isOdd(number)
is_even(number)
is_odd(number)
gcd(number1, number2) // greatest common divisor
kgV(number1, number2) // least common multiple
getDivisors(number) // all divisors of 'number' inclusive 1, number
isPerfectNumber(number)
kg_v(number1, number2) // least common multiple
get_divisors(number) // all divisors of 'number' inclusive 1, number
is_perfect_number(number)
NEW-FUNCTIONS
simplifyFraction(numerator, denominator)
simplify_fraction(numerator, denominator)
factorial (n) // n!
fib (n) // calculate the n-th fibonacci term.
@@ -75,7 +75,7 @@ def is_prime(number: int) -> bool:
# ------------------------------------------
def sieveEr(N):
def sieve_er(n):
"""
input: positive integer 'N' > 2
returns a list of prime numbers from 2 up to N.
@@ -86,23 +86,23 @@ def sieveEr(N):
"""
# precondition
assert isinstance(N, int) and (N > 2), "'N' must been an int and > 2"
assert isinstance(n, int) and (n > 2), "'N' must been an int and > 2"
# beginList: contains all natural numbers from 2 up to N
beginList = [x for x in range(2, N + 1)]
begin_list = [x for x in range(2, n + 1)]
ans = [] # this list will be returns.
# actual sieve of erathostenes
for i in range(len(beginList)):
for i in range(len(begin_list)):
for j in range(i + 1, len(beginList)):
for j in range(i + 1, len(begin_list)):
if (beginList[i] != 0) and (beginList[j] % beginList[i] == 0):
beginList[j] = 0
if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
begin_list[j] = 0
# filters actual prime numbers.
ans = [x for x in beginList if x != 0]
ans = [x for x in begin_list if x != 0]
# precondition
assert isinstance(ans, list), "'ans' must been from type list"
@@ -113,7 +113,7 @@ def sieveEr(N):
# --------------------------------
def getPrimeNumbers(N):
def get_prime_numbers(n):
"""
input: positive integer 'N' > 2
returns a list of prime numbers from 2 up to N (inclusive)
@@ -121,13 +121,13 @@ def getPrimeNumbers(N):
"""
# precondition
assert isinstance(N, int) and (N > 2), "'N' must been an int and > 2"
assert isinstance(n, int) and (n > 2), "'N' must been an int and > 2"
ans = []
# iterates over all numbers between 2 up to N+1
# if a number is prime then appends to list 'ans'
for number in range(2, N + 1):
for number in range(2, n + 1):
if is_prime(number):
@@ -142,7 +142,7 @@ def getPrimeNumbers(N):
# -----------------------------------------
def primeFactorization(number):
def prime_factorization(number):
"""
input: positive integer 'number'
returns a list of the prime number factors of 'number'
@@ -186,7 +186,7 @@ def primeFactorization(number):
# -----------------------------------------
def greatestPrimeFactor(number):
def greatest_prime_factor(number):
"""
input: positive integer 'number' >= 0
returns the greatest prime number factor of 'number'
@@ -200,9 +200,9 @@ def greatestPrimeFactor(number):
ans = 0
# prime factorization of 'number'
primeFactors = primeFactorization(number)
prime_factors = prime_factorization(number)
ans = max(primeFactors)
ans = max(prime_factors)
# precondition
assert isinstance(ans, int), "'ans' must been from type int"
@@ -213,7 +213,7 @@ def greatestPrimeFactor(number):
# ----------------------------------------------
def smallestPrimeFactor(number):
def smallest_prime_factor(number):
"""
input: integer 'number' >= 0
returns the smallest prime number factor of 'number'
@@ -227,9 +227,9 @@ def smallestPrimeFactor(number):
ans = 0
# prime factorization of 'number'
primeFactors = primeFactorization(number)
prime_factors = prime_factorization(number)
ans = min(primeFactors)
ans = min(prime_factors)
# precondition
assert isinstance(ans, int), "'ans' must been from type int"
@@ -240,7 +240,7 @@ def smallestPrimeFactor(number):
# ----------------------
def isEven(number):
def is_even(number):
"""
input: integer 'number'
returns true if 'number' is even, otherwise false.
@@ -256,7 +256,7 @@ def isEven(number):
# ------------------------
def isOdd(number):
def is_odd(number):
"""
input: integer 'number'
returns true if 'number' is odd, otherwise false.
@@ -281,14 +281,14 @@ def goldbach(number):
# precondition
assert (
isinstance(number, int) and (number > 2) and isEven(number)
isinstance(number, int) and (number > 2) and is_even(number)
), "'number' must been an int, even and > 2"
ans = [] # this list will returned
# creates a list of prime numbers between 2 up to 'number'
primeNumbers = getPrimeNumbers(number)
lenPN = len(primeNumbers)
prime_numbers = get_prime_numbers(number)
len_pn = len(prime_numbers)
# run variable for while-loops.
i = 0
@@ -297,16 +297,16 @@ def goldbach(number):
# exit variable. for break up the loops
loop = True
while i < lenPN and loop:
while i < len_pn and loop:
j = i + 1
while j < lenPN and loop:
while j < len_pn and loop:
if primeNumbers[i] + primeNumbers[j] == number:
if prime_numbers[i] + prime_numbers[j] == number:
loop = False
ans.append(primeNumbers[i])
ans.append(primeNumbers[j])
ans.append(prime_numbers[i])
ans.append(prime_numbers[j])
j += 1
@@ -361,7 +361,7 @@ def gcd(number1, number2):
# ----------------------------------------------------
def kgV(number1, number2):
def kg_v(number1, number2):
"""
Least common multiple
input: two positive integer 'number1' and 'number2'
@@ -382,13 +382,13 @@ def kgV(number1, number2):
if number1 > 1 and number2 > 1:
# builds the prime factorization of 'number1' and 'number2'
primeFac1 = primeFactorization(number1)
primeFac2 = primeFactorization(number2)
prime_fac_1 = prime_factorization(number1)
prime_fac_2 = prime_factorization(number2)
elif number1 == 1 or number2 == 1:
primeFac1 = []
primeFac2 = []
prime_fac_1 = []
prime_fac_2 = []
ans = max(number1, number2)
count1 = 0
@@ -397,21 +397,21 @@ def kgV(number1, number2):
done = [] # captured numbers int both 'primeFac1' and 'primeFac2'
# iterates through primeFac1
for n in primeFac1:
for n in prime_fac_1:
if n not in done:
if n in primeFac2:
if n in prime_fac_2:
count1 = primeFac1.count(n)
count2 = primeFac2.count(n)
count1 = prime_fac_1.count(n)
count2 = prime_fac_2.count(n)
for i in range(max(count1, count2)):
ans *= n
else:
count1 = primeFac1.count(n)
count1 = prime_fac_1.count(n)
for i in range(count1):
ans *= n
@@ -419,11 +419,11 @@ def kgV(number1, number2):
done.append(n)
# iterates through primeFac2
for n in primeFac2:
for n in prime_fac_2:
if n not in done:
count2 = primeFac2.count(n)
count2 = prime_fac_2.count(n)
for i in range(count2):
ans *= n
@@ -441,7 +441,7 @@ def kgV(number1, number2):
# ----------------------------------
def getPrime(n):
def get_prime(n):
"""
Gets the n-th prime number.
input: positive integer 'n' >= 0
@@ -476,7 +476,7 @@ def getPrime(n):
# ---------------------------------------------------
def getPrimesBetween(pNumber1, pNumber2):
def get_primes_between(p_number_1, p_number_2):
"""
input: prime numbers 'pNumber1' and 'pNumber2'
pNumber1 < pNumber2
@@ -486,10 +486,10 @@ def getPrimesBetween(pNumber1, pNumber2):
# precondition
assert (
is_prime(pNumber1) and is_prime(pNumber2) and (pNumber1 < pNumber2)
is_prime(p_number_1) and is_prime(p_number_2) and (p_number_1 < p_number_2)
), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"
number = pNumber1 + 1 # jump to the next number
number = p_number_1 + 1 # jump to the next number
ans = [] # this list will be returns.
@@ -498,7 +498,7 @@ def getPrimesBetween(pNumber1, pNumber2):
while not is_prime(number):
number += 1
while number < pNumber2:
while number < p_number_2:
ans.append(number)
@@ -510,7 +510,9 @@ def getPrimesBetween(pNumber1, pNumber2):
# precondition
assert (
isinstance(ans, list) and ans[0] != pNumber1 and ans[len(ans) - 1] != pNumber2
isinstance(ans, list)
and ans[0] != p_number_1
and ans[len(ans) - 1] != p_number_2
), "'ans' must been a list without the arguments"
# 'ans' contains not 'pNumber1' and 'pNumber2' !
@@ -520,7 +522,7 @@ def getPrimesBetween(pNumber1, pNumber2):
# ----------------------------------------------------
def getDivisors(n):
def get_divisors(n):
"""
input: positive integer 'n' >= 1
returns all divisors of n (inclusive 1 and 'n')
@@ -545,7 +547,7 @@ def getDivisors(n):
# ----------------------------------------------------
def isPerfectNumber(number):
def is_perfect_number(number):
"""
input: positive integer 'number' > 1
returns true if 'number' is a perfect number otherwise false.
@@ -556,7 +558,7 @@ def isPerfectNumber(number):
number > 1
), "'number' must been an int and >= 1"
divisors = getDivisors(number)
divisors = get_divisors(number)
# precondition
assert (
@@ -572,7 +574,7 @@ def isPerfectNumber(number):
# ------------------------------------------------------------
def simplifyFraction(numerator, denominator):
def simplify_fraction(numerator, denominator):
"""
input: two integer 'numerator' and 'denominator'
assumes: 'denominator' != 0
@@ -587,16 +589,16 @@ def simplifyFraction(numerator, denominator):
), "The arguments must been from type int and 'denominator' != 0"
# build the greatest common divisor of numerator and denominator.
gcdOfFraction = gcd(abs(numerator), abs(denominator))
gcd_of_fraction = gcd(abs(numerator), abs(denominator))
# precondition
assert (
isinstance(gcdOfFraction, int)
and (numerator % gcdOfFraction == 0)
and (denominator % gcdOfFraction == 0)
isinstance(gcd_of_fraction, int)
and (numerator % gcd_of_fraction == 0)
and (denominator % gcd_of_fraction == 0)
), "Error in function gcd(...,...)"
return (numerator // gcdOfFraction, denominator // gcdOfFraction)
return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)
# -----------------------------------------------------------------

20
maths/qr_decomposition.py
View File

@@ -1,7 +1,7 @@
import numpy as np
def qr_householder(A):
def qr_householder(a):
"""Return a QR-decomposition of the matrix A using Householder reflection.
The QR-decomposition decomposes the matrix A of shape (m, n) into an
@@ -37,14 +37,14 @@ def qr_householder(A):
>>> np.allclose(np.triu(R), R)
True
"""
m, n = A.shape
m, n = a.shape
t = min(m, n)
Q = np.eye(m)
R = A.copy()
q = np.eye(m)
r = a.copy()
for k in range(t - 1):
# select a column of modified matrix A':
x = R[k:, [k]]
x = r[k:, [k]]
# construct first basis vector
e1 = np.zeros_like(x)
e1[0] = 1.0
@@ -55,14 +55,14 @@ def qr_householder(A):
v /= np.linalg.norm(v)
# construct the Householder matrix
Q_k = np.eye(m - k) - 2.0 * v @ v.T
q_k = np.eye(m - k) - 2.0 * v @ v.T
# pad with ones and zeros as necessary
Q_k = np.block([[np.eye(k), np.zeros((k, m - k))], [np.zeros((m - k, k)), Q_k]])
q_k = np.block([[np.eye(k), np.zeros((k, m - k))], [np.zeros((m - k, k)), q_k]])
Q = Q @ Q_k.T
R = Q_k @ R
q = q @ q_k.T
r = q_k @ r
return Q, R
return q, r
if __name__ == "__main__":

72
maths/radix2_fft.py
View File

@@ -49,10 +49,10 @@ class FFT:
A*B = 0*x^(-0+0j) + 1*x^(2+0j) + 2*x^(3+0j) + 3*x^(8+0j) + 4*x^(6+0j) + 5*x^(8+0j)
"""
def __init__(self, polyA=None, polyB=None):
def __init__(self, poly_a=None, poly_b=None):
# Input as list
self.polyA = list(polyA or [0])[:]
self.polyB = list(polyB or [0])[:]
self.polyA = list(poly_a or [0])[:]
self.polyB = list(poly_b or [0])[:]
# Remove leading zero coefficients
while self.polyA[-1] == 0:
@@ -64,22 +64,22 @@ class FFT:
self.len_B = len(self.polyB)
# Add 0 to make lengths equal a power of 2
self.C_max_length = int(
self.c_max_length = int(
2 ** np.ceil(np.log2(len(self.polyA) + len(self.polyB) - 1))
)
while len(self.polyA) < self.C_max_length:
while len(self.polyA) < self.c_max_length:
self.polyA.append(0)
while len(self.polyB) < self.C_max_length:
while len(self.polyB) < self.c_max_length:
self.polyB.append(0)
# A complex root used for the fourier transform
self.root = complex(mpmath.root(x=1, n=self.C_max_length, k=1))
self.root = complex(mpmath.root(x=1, n=self.c_max_length, k=1))
# The product
self.product = self.__multiply()
# Discrete fourier transform of A and B
def __DFT(self, which):
def __dft(self, which):
if which == "A":
dft = [[x] for x in self.polyA]
else:
@@ -88,20 +88,20 @@ class FFT:
if len(dft) <= 1:
return dft[0]
#
next_ncol = self.C_max_length // 2
next_ncol = self.c_max_length // 2
while next_ncol > 0:
new_dft = [[] for i in range(next_ncol)]
root = self.root**next_ncol
# First half of next step
current_root = 1
for j in range(self.C_max_length // (next_ncol * 2)):
for j in range(self.c_max_length // (next_ncol * 2)):
for i in range(next_ncol):
new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j])
current_root *= root
# Second half of next step
current_root = 1
for j in range(self.C_max_length // (next_ncol * 2)):
for j in range(self.c_max_length // (next_ncol * 2)):
for i in range(next_ncol):
new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j])
current_root *= root
@@ -112,65 +112,65 @@ class FFT:
# multiply the DFTs of A and B and find A*B
def __multiply(self):
dftA = self.__DFT("A")
dftB = self.__DFT("B")
inverseC = [[dftA[i] * dftB[i] for i in range(self.C_max_length)]]
del dftA
del dftB
dft_a = self.__dft("A")
dft_b = self.__dft("B")
inverce_c = [[dft_a[i] * dft_b[i] for i in range(self.c_max_length)]]
del dft_a
del dft_b
# Corner Case
if len(inverseC[0]) <= 1:
return inverseC[0]
if len(inverce_c[0]) <= 1:
return inverce_c[0]
# Inverse DFT
next_ncol = 2
while next_ncol <= self.C_max_length:
new_inverseC = [[] for i in range(next_ncol)]
while next_ncol <= self.c_max_length:
new_inverse_c = [[] for i in range(next_ncol)]
root = self.root ** (next_ncol // 2)
current_root = 1
# First half of next step
for j in range(self.C_max_length // next_ncol):
for j in range(self.c_max_length // next_ncol):
for i in range(next_ncol // 2):
# Even positions
new_inverseC[i].append(
new_inverse_c[i].append(
(
inverseC[i][j]
+ inverseC[i][j + self.C_max_length // next_ncol]
inverce_c[i][j]
+ inverce_c[i][j + self.c_max_length // next_ncol]
)
/ 2
)
# Odd positions
new_inverseC[i + next_ncol // 2].append(
new_inverse_c[i + next_ncol // 2].append(
(
inverseC[i][j]
- inverseC[i][j + self.C_max_length // next_ncol]
inverce_c[i][j]
- inverce_c[i][j + self.c_max_length // next_ncol]
)
/ (2 * current_root)
)
current_root *= root
# Update
inverseC = new_inverseC
inverce_c = new_inverse_c
next_ncol *= 2
# Unpack
inverseC = [round(x[0].real, 8) + round(x[0].imag, 8) * 1j for x in inverseC]
inverce_c = [round(x[0].real, 8) + round(x[0].imag, 8) * 1j for x in inverce_c]
# Remove leading 0's
while inverseC[-1] == 0:
inverseC.pop()
return inverseC
while inverce_c[-1] == 0:
inverce_c.pop()
return inverce_c
# Overwrite __str__ for print(); Shows A, B and A*B
def __str__(self):
A = "A = " + " + ".join(
a = "A = " + " + ".join(
f"{coef}*x^{i}" for coef, i in enumerate(self.polyA[: self.len_A])
)
B = "B = " + " + ".join(
b = "B = " + " + ".join(
f"{coef}*x^{i}" for coef, i in enumerate(self.polyB[: self.len_B])
)
C = "A*B = " + " + ".join(
c = "A*B = " + " + ".join(
f"{coef}*x^{i}" for coef, i in enumerate(self.product)
)
return "\n".join((A, B, C))
return "\n".join((a, b, c))
# Unit tests

6
maths/runge_kutta.py
View File

@@ -22,12 +22,12 @@ def runge_kutta(f, y0, x0, h, x_end):
>>> y[-1]
148.41315904125113
"""
N = int(np.ceil((x_end - x0) / h))
y = np.zeros((N + 1,))
n = int(np.ceil((x_end - x0) / h))
y = np.zeros((n + 1,))
y[0] = y0
x = x0
for k in range(N):
for k in range(n):
k1 = f(x, y[k])
k2 = f(x + 0.5 * h, y[k] + 0.5 * h * k1)
k3 = f(x + 0.5 * h, y[k] + 0.5 * h * k2)

6
maths/softmax.py
View File

@@ -41,13 +41,13 @@ def softmax(vector):
# Calculate e^x for each x in your vector where e is Euler's
# number (approximately 2.718)
exponentVector = np.exp(vector)
exponent_vector = np.exp(vector)
# Add up the all the exponentials
sumOfExponents = np.sum(exponentVector)
sum_of_exponents = np.sum(exponent_vector)
# Divide every exponent by the sum of all exponents
softmax_vector = exponentVector / sumOfExponents
softmax_vector = exponent_vector / sum_of_exponents
return softmax_vector