Improved Formatting and Style of Math Algos (TheAlgorithms#960)

* Improved Formatting and Style

I improved formatting and style to make PyLama happier.

Linters used:

- mccabe
- pep257
- pydocstyle
- pep8
- pycodestyle
- pyflakes
- pylint
- isort

* Create volume.py

This script calculates the volumes of various shapes.

* Delete lucasSeries.py

* Revert "Delete lucasSeries.py"

This reverts commit 64c19f7.

* Update lucasSeries.py

Author: PatOnTheBack

maths/Binary_Exponentiation.py

@@ -1,25 +1,27 @@
-#Author : Junth Basnet
-#Time Complexity : O(logn)
+"""Binary Exponentiation."""
+
+# Author : Junth Basnet
+# Time Complexity : O(logn)
+
 
 def binary_exponentiation(a, n):
-    
+
     if (n == 0):
         return 1
-    
+
     elif (n % 2 == 1):
         return binary_exponentiation(a, n - 1) * a
-    
+
     else:
         b = binary_exponentiation(a, n / 2)
         return b * b
 
-    
+
 try:
-    base = int(input('Enter Base : '))
-    power = int(input("Enter Power : "))
+    BASE = int(input('Enter Base : '))
+    POWER = int(input("Enter Power : "))
 except ValueError:
-    print ("Invalid literal for integer")
+    print("Invalid literal for integer")
 
-result = binary_exponentiation(base, power)
-print("{}^({}) : {}".format(base, power, result))
-    
+RESULT = binary_exponentiation(BASE, POWER)
+print("{}^({}) : {}".format(BASE, POWER, RESULT))

maths/Find_Min.py

@@ -1,12 +1,17 @@
+"""Find Minimum Number in a List."""
+
+
 def main():
-    def findMin(x):
-        minNum = x[0]
+    """Find Minimum Number in a List."""
+    def find_min(x):
+        min_num = x[0]
         for i in x:
-            if minNum > i:
-                minNum = i
-        return minNum
+            if min_num > i:
+                min_num = i
+        return min_num
+
+    print(find_min([0, 1, 2, 3, 4, 5, -3, 24, -56]))  # = -56
 
-    print(findMin([0,1,2,3,4,5,-3,24,-56])) # = -56
 
 if __name__ == '__main__':
     main()

maths/Prime_Check.py

@@ -1,9 +1,13 @@
+"""Prime Check."""
+
 import math
 import unittest
 
 
-def primeCheck(number):
+def prime_check(number):
     """
+    Check to See if a Number is Prime.
+
     A number is prime if it has exactly two dividers: 1 and itself.
     """
     if number < 2:
@@ -24,31 +28,30 @@ def primeCheck(number):
 
 class Test(unittest.TestCase):
     def test_primes(self):
-        self.assertTrue(primeCheck(2))
-        self.assertTrue(primeCheck(3))
-        self.assertTrue(primeCheck(5))
-        self.assertTrue(primeCheck(7))
-        self.assertTrue(primeCheck(11))
-        self.assertTrue(primeCheck(13))
-        self.assertTrue(primeCheck(17))
-        self.assertTrue(primeCheck(19))
-        self.assertTrue(primeCheck(23))
-        self.assertTrue(primeCheck(29))
+        self.assertTrue(prime_check(2))
+        self.assertTrue(prime_check(3))
+        self.assertTrue(prime_check(5))
+        self.assertTrue(prime_check(7))
+        self.assertTrue(prime_check(11))
+        self.assertTrue(prime_check(13))
+        self.assertTrue(prime_check(17))
+        self.assertTrue(prime_check(19))
+        self.assertTrue(prime_check(23))
+        self.assertTrue(prime_check(29))
 
     def test_not_primes(self):
-        self.assertFalse(primeCheck(-19),
-                "Negative numbers are not prime.")
-        self.assertFalse(primeCheck(0),
-                "Zero doesn't have any divider, primes must have two")
-        self.assertFalse(primeCheck(1),
-                "One just have 1 divider, primes must have two.")
-        self.assertFalse(primeCheck(2 * 2))
-        self.assertFalse(primeCheck(2 * 3))
-        self.assertFalse(primeCheck(3 * 3))
-        self.assertFalse(primeCheck(3 * 5))
-        self.assertFalse(primeCheck(3 * 5 * 7))
+        self.assertFalse(prime_check(-19),
+                         "Negative numbers are not prime.")
+        self.assertFalse(prime_check(0),
+                         "Zero doesn't have any divider, primes must have two")
+        self.assertFalse(prime_check(1),
+                         "One just have 1 divider, primes must have two.")
+        self.assertFalse(prime_check(2 * 2))
+        self.assertFalse(prime_check(2 * 3))
+        self.assertFalse(prime_check(3 * 3))
+        self.assertFalse(prime_check(3 * 5))
+        self.assertFalse(prime_check(3 * 5 * 7))
 
 
 if __name__ == '__main__':
     unittest.main()
-

maths/abs.py

@@ -1,24 +1,25 @@
 """Absolute Value."""
 
 
-def absVal(num):
+def abs_val(num):
     """
     Find the absolute value of a number.
 
-    >>absVal(-5)
+    >>abs_val(-5)
     5
-    >>absVal(0)
+    >>abs_val(0)
     0
     """
     if num < 0:
         return -num
-    else:
-        return num
+
+    # Returns if number is not < 0
+    return num
 
 
 def main():
     """Print absolute value of -34."""
-    print(absVal(-34))  # = 34
+    print(abs_val(-34))  # = 34
 
 
 if __name__ == '__main__':

maths/extended_euclidean_algorithm.py

@@ -1,20 +1,38 @@
+"""
+Extended Euclidean Algorithm.
+
+Finds 2 numbers a and b such that it satisfies
+the equation am + bn = gcd(m, n) (a.k.a Bezout's Identity)
+"""
+
 # @Author: S. Sharma <silentcat>
 # @Date:   2019-02-25T12:08:53-06:00
 # @Email:  [email protected]
-# @Last modified by:   silentcat
-# @Last modified time: 2019-02-26T07:07:38-06:00
+# @Last modified by:   PatOnTheBack
+# @Last modified time: 2019-07-05
 
 import sys
 
-# Finds 2 numbers a and b such that it satisfies
-# the equation am + bn = gcd(m, n) (a.k.a Bezout's Identity)
+
 def extended_euclidean_algorithm(m, n):
-    a = 0; aprime = 1; b = 1; bprime = 0
-    q = 0; r = 0
+    """
+    Extended Euclidean Algorithm.
+
+    Finds 2 numbers a and b such that it satisfies
+    the equation am + bn = gcd(m, n) (a.k.a Bezout's Identity)
+    """
+    a = 0
+    a_prime = 1
+    b = 1
+    b_prime = 0
+    q = 0
+    r = 0
     if m > n:
-        c = m; d = n
+        c = m
+        d = n
     else:
-        c = n; d = m
+        c = n
+        d = m
 
     while True:
         q = int(c / d)
@@ -24,28 +42,31 @@ def extended_euclidean_algorithm(m, n):
         c = d
         d = r
 
-        t = aprime
-        aprime = a
-        a = t - q*a
+        t = a_prime
+        a_prime = a
+        a = t - q * a
 
-        t = bprime
-        bprime = b
-        b = t - q*b
+        t = b_prime
+        b_prime = b
+        b = t - q * b
 
     pair = None
     if m > n:
-        pair = (a,b)
+        pair = (a, b)
     else:
-        pair = (b,a)
+        pair = (b, a)
     return pair
 
+
 def main():
+    """Call Extended Euclidean Algorithm."""
     if len(sys.argv) < 3:
         print('2 integer arguments required')
         exit(1)
     m = int(sys.argv[1])
     n = int(sys.argv[2])
     print(extended_euclidean_algorithm(m, n))
 
+
 if __name__ == '__main__':
     main()

maths/fermat_little_theorem.py

@@ -5,13 +5,13 @@
 
 
 def binary_exponentiation(a, n, mod):
-    
+
     if (n == 0):
         return 1
-    
+
     elif (n % 2 == 1):
         return (binary_exponentiation(a, n - 1, mod) * a) % mod
-    
+
     else:
         b = binary_exponentiation(a, n / 2, mod)
         return (b * b) % mod

maths/greater_common_divisor.py

@@ -1,15 +1,25 @@
-# Greater Common Divisor - https://en.wikipedia.org/wiki/Greatest_common_divisor
+"""
+Greater Common Divisor.
+
+Wikipedia reference: https://en.wikipedia.org/wiki/Greatest_common_divisor
+"""
+
+
 def gcd(a, b):
+    """Calculate Greater Common Divisor (GCD)."""
     return b if a == 0 else gcd(b % a, a)
 
+
 def main():
+    """Call GCD Function."""
     try:
         nums = input("Enter two Integers separated by comma (,): ").split(',')
-        num1 = int(nums[0]); num2 = int(nums[1])
+        num_1 = int(nums[0])
+        num_2 = int(nums[1])
     except (IndexError, UnboundLocalError, ValueError):
         print("Wrong Input")
-    print(f"gcd({num1}, {num2}) = {gcd(num1, num2)}")
+    print(f"gcd({num_1}, {num_2}) = {gcd(num_1, num_2)}")
+
 
 if __name__ == '__main__':
     main()
-

maths/modular_exponential.py

@@ -1,20 +1,25 @@
-def modularExponential(base, power, mod):
-	if power < 0:
-		return -1
-	base %= mod
-	result = 1
+"""Modular Exponential."""
 
-	while power > 0:
-		if power & 1:
-			result = (result * base) % mod
-		power = power >> 1
-		base = (base * base) % mod
-	return result
+
+def modular_exponential(base, power, mod):
+    """Calculate Modular Exponential."""
+    if power < 0:
+        return -1
+    base %= mod
+    result = 1
+
+    while power > 0:
+        if power & 1:
+            result = (result * base) % mod
+        power = power >> 1
+        base = (base * base) % mod
+    return result
 
 
 def main():
-	print(modularExponential(3, 200, 13))
+    """Call Modular Exponential Function."""
+    print(modular_exponential(3, 200, 13))
 
 
 if __name__ == '__main__':
-	main()
+    main()