fix wrong carry bit output

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

BasicRegister.py

@@ -1,24 +0,0 @@
-
-
-class BasicRegister:
-
-    def __init__(self, memory: list[bool]):
-        self.memory: list[bool] = memory
-
-    def __str__(self) -> str:
-        return f"Memory: [{', '.join([str(int(value)) for value in  self.memory])}]"
-
-    def reverse(self):
-        self.memory = [not value for value in self.memory]
-
-    def left_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> list[bool]:
-        self.memory.extend([digit_to_fill] * steps_shifted)
-        shifted_radices: list[bool] = self.memory[:steps_shifted]
-        del self.memory[:steps_shifted]
-        return shifted_radices
-
-    def right_shift(self, digit_to_fill: bool = False, steps_shifted: int = 1) -> list[bool]:
-        self.memory[:0] = [digit_to_fill] * steps_shifted
-        shifted_radices: list[bool] = self.memory[-steps_shifted:]
-        del self.memory[-steps_shifted:]
-        return shifted_radices

bitutilities.py

@@ -0,0 +1,109 @@
+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.
+
+    :param deque[bool] memory: The bits stored inside the register.
+    """
+
+    def __init__(self, memory: list[bool]):
+        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):
+        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 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
+
+
+def get_memory(variable_name: str) -> list[bool]:
+    """
+    Reads user input to be used as a memory array.
+
+    :param str variable_name: The name to be displayed in the input line.
+
+    :return: A list of boolean values read from user.
+    :rtype: list[bool]
+    """
+    while True:
+        input_chars: list[str] = list(input(f"Enter {variable_name}: "))
+
+        if all(character in ["0", "1"] for character in input_chars):
+            return [True if character == "1" else False for character in input_chars]
+        else:
+            print(f"[ERROR] The {variable_name} may contain only 1-s and 0-s!")
+
+
+def binary_sum(first_term: BasicRegister, second_term: BasicRegister, return_remainder: bool = False)\
+        -> BasicRegister | tuple[BasicRegister, int]:
+    """
+    Sums two registers' values.
+
+    :param BasicRegister first_term: First register.
+    :param BasicRegister second_term: Second register.
+    :param bool return_remainder: True to return the tuple, False to return just the register.
+
+    :return: Register containing the sum or the tuple containing the register and carried radix.
+    :rtype: BasicRegister | tuple[BasicRegister, int]
+    """
+    size_a = len(first_term)
+    size_b = len(second_term)
+
+    required_size = max(size_a, size_b)
+
+    a = first_term
+    b = second_term
+
+    if size_a != size_b:
+        a = a.adjusted_by_size(required_size)
+        b = b.adjusted_by_size(required_size)
+
+    c = BasicRegister([False] * required_size)
+
+    carry = False
+    for i in range(required_size - 1, 0, -1):
+        current_bit_sum = a.memory[i] + b.memory[i] + carry
+        carry = bool(current_bit_sum & 2)
+        c.memory[i] = bool(current_bit_sum & 1)
+
+    final_bit_sum = a.memory[0] + b.memory[0] + carry
+    carry = bool(final_bit_sum & 2)
+    c.memory[0] = bool(final_bit_sum & 1)
+
+    if return_remainder:
+        return c, carry
+    else:
+        return c

main.py

@@ -1,23 +1,31 @@
-from BasicRegister import BasicRegister
-
-
-def get_memory(variable_name: str) -> list[bool]:
-    while True:
-        input_chars: list[str] = list(input(f"Enter {variable_name}: "))
-
-        if all(character in ["0", "1"] for character in input_chars):
-            return [True if character == "1" else False for character in input_chars]
-        else:
-            print(f"[ERROR] The {variable_name} may contain only 1-s and 0-s!")
+import bitutilities as bu
+import timeit
 
 
 if __name__ == '__main__':
-    reg: BasicRegister = BasicRegister(get_memory("memory"))
+    reg: bu.BasicRegister = bu.BasicRegister(bu.get_memory("memory"))
 
+    print()
+    print("Register 1:")
     print(reg)
 
-    print(reg.left_shift())
-    print(reg)
+    print()
+    reg2: bu.BasicRegister = bu.BasicRegister(bu.get_memory("more memory"))
 
-    print(reg.right_shift())
-    print(reg)
+    print()
+    print("Register 2:")
+    print(reg2)
+
+    print()
+    reg3: bu.BasicRegister = bu.binary_sum(reg, reg2)
+
+    print()
+    print("Sum:")
+    print(reg3)
+
+    carry_sum_test: tuple[bu.BasicRegister, int] = bu.binary_sum(reg, reg2, True)
+
+    print()
+    print("Sum & carry:")
+    # print(type(carry_sum_test))
+    print(carry_sum_test)