fix wrong carry bit output

bitutilities.py

@@ -36,38 +36,17 @@ class BasicRegister:
         )
 
     def reverse(self):
-        """
-        Performs a logical negation on the register.
-        """
         self.memory = deque([not value for value in self.memory])
 
-    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 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
 
-        :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.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 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]:
@@ -88,97 +67,43 @@ def get_memory(variable_name: str) -> list[bool]:
             print(f"[ERROR] The {variable_name} may contain only 1-s and 0-s!")
 
 
-def binary_sum_with_carry(first_term: BasicRegister, second_term: BasicRegister) -> tuple[BasicRegister, int]:
+def binary_sum(first_term: BasicRegister, second_term: BasicRegister, return_remainder: bool = False)\
+        -> BasicRegister | tuple[BasicRegister, int]:
     """
-    Sums two registers' values and keeps the carry-out.
+    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 and the carry-out bit.
-    :rtype: tuple[BasicRegister, int]
+    :return: Register containing the sum or the tuple containing the register and carried radix.
+    :rtype: BasicRegister | tuple[BasicRegister, int]
     """
-    result_term = BasicRegister([False] * len(first_term))
+    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(len(first_term) - 1, 0, -1):
-        current_bit_sum = first_term.memory[i] + second_term.memory[i] + carry
+    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)
-        result_term.memory[i] = bool(current_bit_sum & 1)
+        c.memory[i] = bool(current_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)
+    final_bit_sum = a.memory[0] + b.memory[0] + carry
+    carry = bool(final_bit_sum & 2)
+    c.memory[0] = bool(final_bit_sum & 1)
 
-    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]))
+    if return_remainder:
+        return c, carry
     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)
+        return c

main.py

@@ -1,32 +1,31 @@
 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.")
+import timeit
 
 
 if __name__ == '__main__':
     reg: bu.BasicRegister = bu.BasicRegister(bu.get_memory("memory"))
+
+    print()
+    print("Register 1:")
+    print(reg)
+
+    print()
     reg2: bu.BasicRegister = bu.BasicRegister(bu.get_memory("more memory"))
 
-    input_handler(reg, reg2)
+    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)