add sum function for addition of two registers

revert Delete 'bitutilities.py'

bitutilities.py

@@ -1,3 +1,37 @@
+from collections import deque
+
+
+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]):
+        """Constructor method"""
+        self.memory: deque[bool] = deque(memory)
+
+    def __str__(self) -> str:
+        return f"Memory: {[int(value) for value in  self.memory]}"
+
+    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 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:])
+
+
 def get_memory(variable_name: str) -> list[bool]:
     """
     Reads user input to be used as a memory array.
@@ -16,30 +50,37 @@ def get_memory(variable_name: str) -> list[bool]:
             print(f"[ERROR] The {variable_name} may contain only 1-s and 0-s!")
 
 
-class BasicRegister:
-    """The BasicRegister represents a hardware register capable of manipulating multiple bits at a time.
-
-    :param list[bool] memory: The bits stored inside the register.
+def sum(a_original: BasicRegister, b_original: BasicRegister) -> BasicRegister:
     """
+    Sums two registers' values.
 
-    def __init__(self, memory: list[bool]):
-        """Constructor method"""
-        self.memory: list[bool] = memory
+    :param BasicRegister a: First register.
+    :param BasicRegister b: Second register.
 
-    def __str__(self) -> str:
-        return f"Memory: {[int(value) for value in  self.memory]}"
+    :return: Register containing the result.
+    :rtype: BasicRegister
+    """
+    size_a = len(a_original.memory)
+    size_b = len(b_original.memory)
 
-    def reverse(self):
-        self.memory = [not value for value in self.memory]
+    required_size = max(size_a, size_b)
 
-    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
+    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
 
-    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
+    c = BasicRegister([False] * required_size)
+
+    carry = False
+    for i in range(size_a - 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
+    c.memory[0] = bool(final_bit_sum & 1)
+
+    return c

main.py

@@ -1,13 +1,28 @@
 from bitutilities import *
+import timeit
 
 
 if __name__ == '__main__':
     reg: BasicRegister = BasicRegister(get_memory("memory"))
+    # print(type(reg))
 
+    print("\nRegister:")
     print(reg)
 
-    print(reg.left_shift())
+    print("\nReversed:")
+    reg.reverse()
     print(reg)
 
-    print(reg.right_shift())
+    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)