feat: Implemented Matrix Exponentiation Method

bit_manipulation/swaping_two_variables_without_using _temporary_variables.py

@@ -0,0 +1,68 @@
+def xor_swap(a: int, b: int) -> (int, int):
+    """
+    Swap two integers using bitwise XOR
+    without using a temporary variable.
+
+    This algorithm utilizes the properties
+    of the bitwise XOR operation to swap the values 
+    of two integers `a` and `b` without
+    the use of a temporary variable. XOR swap is a 
+    rarely used trick but showcases the power
+    of bit manipulation for efficient operations 
+    at the hardware level.
+
+    The steps involved are:
+    1. `a = a ^ b`
+    2. `b = a ^ b` (Now `b` holds the original value of `a`)
+    3. `a = a ^ b` (Now `a` holds the original value of `b`)
+
+    Although this technique can swap variables
+    without extra space, it is generally not 
+    recommended in production code because it is
+    less readable than using a temporary variable.
+
+    Args:
+        a (int): The first integer to be swapped.
+        b (int): The second integer to be swapped.
+
+    Returns:
+        (int, int): The swapped values of `a` and `b`.
+
+    Raises:
+        None
+
+    Example:
+        >>> xor_swap(5, 10)
+        (10, 5)
+        >>> xor_swap(0, 100)
+        (100, 0)
+        >>> xor_swap(-3, 9)
+        (9, -3)
+
+    Notes:
+        - Swapping using XOR can lead to confusion and
+        should generally be avoided in 
+        favor of more readable methods.
+        - This algorithm does not work if both `a` and `b`
+        refer to the same variable.
+
+    """
+    if a == b:
+        print("Both values are the same; no swap needed.")
+        return a, b
+
+    # print(f"Original a = {a}, b = {b}")
+    a = a ^ b  # Step 1
+    b = a ^ b  # Step 2: Now b is the original value of a
+    a = a ^ b  # Step 3: Now a is the original value of b
+    # print(f"Swapped a = {a}, b = {b}")
+    return a, b
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()
+    print(xor_swap(5, 10)) # (10, 5)
+    print(xor_swap(0, 100)) # (100, 0)
+    print(xor_swap(-3, 9))  # (9, -3)
+

bit_manipulation/tempCodeRunnerFile.py

@@ -0,0 +1 @@
+ # print(f"Swapped a = {a}, b = {b}")

maths/fibonacci.py

@@ -7,6 +7,8 @@
 
 NOTE 2: the Binet's formula function is much more limited in the size of inputs
 that it can handle due to the size limitations of Python floats
+NOTE 3: the matrix function is the fastest and most memory efficient for large n
+
 
 See benchmark numbers in __main__ for performance comparisons/
 https://en.wikipedia.org/wiki/Fibonacci_number for more information
@@ -230,6 +232,40 @@ def fib_binet(n: int) -> list[int]:
     return [round(phi**i / sqrt_5) for i in range(n + 1)]
 
 
+def fib_matrix(n: int) -> int:
+    # https://www.nayuki.io/page/fast-fibonacci-algorithms#:~:text=
+    # Summary:%20The%20two%20fast%20Fibonacci%20algorithms%20are%20matrix
+    def matrix_mult(a, b):
+        return [
+            [
+                a[0][0] * b[0][0] + a[0][1] * b[1][0],
+                a[0][0] * b[0][1] + a[0][1] * b[1][1],
+            ],
+            [
+                a[1][0] * b[0][0] + a[1][1] * b[1][0],
+                a[1][0] * b[0][1] + a[1][1] * b[1][1],
+            ],
+        ]
+
+    def matrix_pow(m, power):
+        result = [[1, 0], [0, 1]]  # Identity matrix
+        base = m
+        while power:
+            if power % 2 == 1:
+                result = matrix_mult(result, base)
+            base = matrix_mult(base, base)
+            power //= 2
+        return result
+
+    if n < 0:
+        raise ValueError("n is negative")
+    if n == 0:
+        return 0
+    m = [[1, 1], [1, 0]]
+    result = matrix_pow(m, n - 1)
+    return result[0][0]
+
+
 if __name__ == "__main__":
     from doctest import testmod
 
@@ -242,3 +278,4 @@ def fib_binet(n: int) -> list[int]:
     time_func(fib_memoization, num)  # 0.0100 ms
     time_func(fib_recursive_cached, num)  # 0.0153 ms
     time_func(fib_recursive, num)  # 257.0910 ms
+    time_func(fib_matrix, num)  # 0.0000 ms