fix wrong carry bit output

bitutilities.py

@@ -67,57 +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]:
-    result_term = BasicRegister([False] * len(first_term))
-
-    carry = False
-    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)
-        result_term.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)
-
-    return result_term, final_carry
-
-
-def binary_sum(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+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]
     """
-    return binary_sum_with_carry(first_term, second_term)[0]
+    size_a = len(first_term)
+    size_b = len(second_term)
 
+    required_size = max(size_a, size_b)
 
-def binary_subtraction(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
-    second_term.reverse()
+    a = first_term
+    b = second_term
 
-    result: BasicRegister
-    final_carry: bool
-    result, final_carry = binary_sum_with_carry(first_term, second_term)
+    if size_a != size_b:
+        a = a.adjusted_by_size(required_size)
+        b = b.adjusted_by_size(required_size)
 
-    if final_carry:
-        return binary_sum(result, BasicRegister([False] * (len(result) - 1) + [True]))
+    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:
-        result.reverse()
-        return result
-
-
-def align_registers(first_register: BasicRegister, second_register: BasicRegister) \
-        -> 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
+        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)