Documented all methods and functions.

Added carry return (VERY NOT SURE IF IT WORKS CORRECTLY).

bitutilities.py

@@ -1,35 +1,73 @@
 from collections import deque
+from typing_extensions import Self
 
 
 class BasicRegister:
-    """The BasicRegister represents a hardware register capable of manipulating multiple bits at a time.
+    """
+    The BasicRegister represents a hardware register capable of manipulating multiple bits at a time.
 
     :param deque[bool] memory: The bits stored inside the register.
     """
 
     def __init__(self, memory: list[bool]):
-        """Constructor method"""
         self.memory: deque[bool] = deque(memory)
 
+    def __repr__(self) -> str:
+        return f"Memory: {[int(value) for value in  self.memory]}"
+
     def __str__(self) -> str:
         return f"Memory: {[int(value) for value in  self.memory]}"
 
+    def __len__(self) -> int:
+        return len(self.memory)
+
+    def adjusted_by_size(self, resulting_size: int) -> Self:
+        """
+        Adjusts a register to a given size.
+
+        :param int resulting_size: The size of the resulting register.
+
+        :return: A register of a specified size.
+        :rtype: BasicRegister
+        """
+        current_memory_size: int = len(self.memory)
+        return BasicRegister(
+            [False] * max(resulting_size - current_memory_size, 0) + list(self.memory)[-resulting_size:]
+        )
+
     def reverse(self):
+        """
+        Performs a logical negation on the register.
+        """
         self.memory = deque([not value for value in self.memory])
 
-    def left_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> deque[bool]:
-        self.memory.extend([digit_to_fill] * steps_shifted)
-        shifted_radices: deque[bool] = deque([self.memory.popleft() for _i in range(steps_shifted)])
-        return shifted_radices
+    def left_shift(self, shift_in_value: bool = False, bits_shifted: int = 1) -> deque[bool]:
+        """
+        Shifts the register to the left by a specified number of steps
 
-    def right_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> deque[bool]:
-        self.memory.extendleft([digit_to_fill] * steps_shifted)
-        shifted_radices: deque[bool] = deque([self.memory.pop() for _i in range(steps_shifted)])
-        return shifted_radices
+        :param bool shift_in_value: The value that shifts inside the freed space.
+        :param int bits_shifted: The number of bits by which the register is shifted.
 
-    def adjust_size(self, s: int) -> None:
-        current_memory_size: int = len(self.memory)
-        return BasicRegister([False] * max(s - current_memory_size, 0) + list(self.memory)[-current_memory_size:])
+        :return: The bits shifted outside the register.
+        :rtype: deque[bool]
+        """
+        self.memory.extend([shift_in_value] * bits_shifted)
+        shifted_bits: deque[bool] = deque([self.memory.popleft() for _i in range(bits_shifted)])
+        return shifted_bits
+
+    def right_shift(self, shift_in_value: bool = False, bits_shifted: int = 1) -> deque[bool]:
+        """
+        Shifts the register to the right by a specified number of steps
+
+        :param bool shift_in_value: The value that shifts inside the freed space.
+        :param int bits_shifted: The number of bits by which the register is shifted.
+
+        :return: The bits shifted outside the register.
+        :rtype: deque[bool]
+        """
+        self.memory.extendleft([shift_in_value] * bits_shifted)
+        shifted_bits: deque[bool] = deque([self.memory.pop() for _i in range(bits_shifted)])
+        return shifted_bits
 
 
 def get_memory(variable_name: str) -> list[bool]:
@@ -50,37 +88,97 @@ def get_memory(variable_name: str) -> list[bool]:
             print(f"[ERROR] The {variable_name} may contain only 1-s and 0-s!")
 
 
-def sum(a_original: BasicRegister, b_original: BasicRegister) -> BasicRegister:
+def binary_sum_with_carry(first_term: BasicRegister, second_term: BasicRegister) -> tuple[BasicRegister, int]:
     """
-    Sums two registers' values.
+    Sums two registers' values and keeps the carry-out.
 
-    :param BasicRegister a: First register.
-    :param BasicRegister b: Second register.
+    :param BasicRegister first_term: First register.
+    :param BasicRegister second_term: Second register.
 
-    :return: Register containing the result.
-    :rtype: BasicRegister
+    :return: Register containing the sum and the carry-out bit.
+    :rtype: tuple[BasicRegister, int]
     """
-    size_a = len(a_original.memory)
-    size_b = len(b_original.memory)
-
-    required_size = max(size_a, size_b)
-
-    if size_a != size_b:
-        a = a_original.adjust_size(required_size)
-        b = b_original.adjust_size(required_size)
-    else:
-        a = a_original
-        b = b_original
-
-    c = BasicRegister([False] * required_size)
+    result_term = BasicRegister([False] * len(first_term))
 
     carry = False
-    for i in range(size_a - 1, 0, -1):
-        current_bit_sum = a.memory[i] + b.memory[i] + carry
+    for i in range(len(first_term) - 1, 0, -1):
+        current_bit_sum = first_term.memory[i] + second_term.memory[i] + carry
         carry = bool(current_bit_sum & 2)
-        c.memory[i] = bool(current_bit_sum & 1)
+        result_term.memory[i] = bool(current_bit_sum & 1)
 
-    final_bit_sum = a.memory[0] + b.memory[0] + carry
-    c.memory[0] = bool(final_bit_sum & 1)
+    final_bit_sum = first_term.memory[0] + second_term.memory[0] + carry
+    final_carry = bool(final_bit_sum & 2)
+    result_term.memory[0] = bool(final_bit_sum & 1)
 
-    return c
+    return result_term, final_carry
+
+
+def binary_sum(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+    """
+    Sums two terms containing binary numbers.
+
+    :param BasicRegister first_term: First register to add.
+    :param BasicRegister second_term: Second register to add.
+
+    :return: Register containing the sum.
+    :rtype: BasicRegister
+    """
+    return binary_sum_with_carry(first_term, second_term)[0]
+
+
+def binary_subtraction(minuend: BasicRegister, subtrahend: BasicRegister) -> BasicRegister:
+    """
+    Subtracts the second term from the first in binary using ones' complement.
+
+    :param BasicRegister minuend: Register to subtract from.
+    :param BasicRegister subtrahend: Register to subtract by.
+
+    :return: Register containing the difference.
+    :rtype: BasicRegister
+    """
+    subtrahend.reverse()
+
+    difference: BasicRegister
+    final_carry: bool
+    difference, final_carry = binary_sum_with_carry(minuend, subtrahend)
+
+    if final_carry:
+        return binary_sum(difference, BasicRegister([False] * (len(difference) - 1) + [True]))
+    else:
+        difference.reverse()
+        return difference
+
+
+# def align_registers(first_register: BasicRegister, second_register: BasicRegister) \
+#         -> tuple[BasicRegister, BasicRegister]:
+#     """
+#     Aligns two registers by the length of the bigger one.
+#
+#     :param BasicRegister first_register:
+#     :param BasicRegister second_register:
+#
+#     :return:
+#     :rtype: tuple[BasicRegister, BasicRegister]
+#     """
+#     first_size = len(first_register)
+#     second_size = len(second_register)
+#
+#     required_size = max(first_size, second_size)
+#
+#     if first_size != second_size:
+#         return first_register.adjusted_by_size(required_size), second_register.adjusted_by_size(required_size)
+#     else:
+#         return first_register, second_register
+
+
+def align_registers(*args: BasicRegister) -> tuple[BasicRegister, ...]:
+    """
+    Aligns registers by the length of the bigger one.
+
+    :param args: Basic registers to align.
+
+    :return: Aligned registers.
+    :rtype: tuple[BasicRegister, ...]
+    """
+    required_size: int = max(map(len, args))
+    return tuple(reg.adjusted_by_size(required_size) for reg in args)

main.py

@@ -1,28 +1,32 @@
-from bitutilities import *
-import timeit
+import bitutilities as bu
+
+
+def input_handler(first_register: bu.BasicRegister, second_register: bu.BasicRegister):
+    first_register, second_register = bu.align_registers(first_register, second_register)
+
+    print()
+    print(first_register)
+    print(second_register)
+
+    while True:
+        print()
+        match input("Choose the operation:\n[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit\n>>> "):
+            case "a":
+                print(f"Sum:\n{bu.binary_sum(first_register, second_register)}")
+            case "s":
+                print(f"Subtraction:\n{bu.binary_subtraction(first_register, second_register)}")
+            case "m":
+                pass
+            case "d":
+                pass
+            case "q":
+                exit()
+            case _:
+                print("Not an available operation, try again.")
 
 
 if __name__ == '__main__':
-    reg: BasicRegister = BasicRegister(get_memory("memory"))
-    # print(type(reg))
+    reg: bu.BasicRegister = bu.BasicRegister(bu.get_memory("memory"))
+    reg2: bu.BasicRegister = bu.BasicRegister(bu.get_memory("more memory"))
 
-    print("\nRegister:")
-    print(reg)
-
-    print("\nReversed:")
-    reg.reverse()
-    print(reg)
-
-    print("\nShifted left:")
-    print([int(value) for value in reg.left_shift()])
-    print(reg)
-
-    print("\nShifted right:")
-    print([int(value) for value in reg.right_shift()])
-    print(reg)
-
-    reg2: BasicRegister = BasicRegister(get_memory("more memory"))
-
-    reg3: BasicRegister = sum(reg, reg2)
-
-    print(reg3)
+    input_handler(reg, reg2)