remove unused get_mantice_complement() function

Inherited Counter from BasicRegister.

bitutilities.py

@@ -1,4 +1,6 @@
 from collections import deque
+from typing import Tuple, List, Any
+
 from typing_extensions import Self
 from lib.prettytable import PrettyTable
 
@@ -10,8 +12,8 @@ class BasicRegister:
     :param deque[bool] memory: The bits stored inside the register.
     """
 
-    def __init__(self, memory: list[bool]):
-        self.memory: deque[bool] = deque(memory)
+    def __init__(self, memory: deque[bool]):
+        self.memory: deque[bool] = memory
 
     def __repr__(self) -> str:
         return "".join([str(int(value)) for value in self.memory])
@@ -33,18 +35,18 @@ class BasicRegister:
         """
         current_memory_size: int = len(self.memory)
         return BasicRegister(
-            [False] * max(resulting_size - current_memory_size, 0) + list(self.memory)[-resulting_size:]
+            deque([False] * max(resulting_size - current_memory_size, 0) + list(self.memory)[-resulting_size:])
         )
 
-    def reverse(self):
+    def negate(self):
         """
-        Performs a logical negation on the register.
+        Performs 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
+        Shifts the register to the left 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.
@@ -71,7 +73,7 @@ class BasicRegister:
         return shifted_bits
 
 
-class Counter:
+class Counter(BasicRegister):
     """
     The Counter represents a hardware register specifically designed for countdowns.
 
@@ -79,7 +81,9 @@ class Counter:
     """
 
     def __init__(self, value: int):
-        self.memory: deque[bool] = deque([i == "1" for i in bin(value)[2:]])
+        # memory: deque[bool] = deque([i == "1" for i in bin(value)[2:]])
+        super().__init__(deque([i == "1" for i in bin(value)[2:]]))
+        # self.memory: deque[bool] = deque([i == "1" for i in bin(value)[2:]])
 
     def __repr__(self) -> str:
         return "".join([str(int(value)) for value in self.memory])
@@ -91,13 +95,13 @@ class Counter:
         return len(self.memory)
 
     def decrement(self):
-        self.memory = binary_subtraction(self, BasicRegister([False] * (len(self.memory) - 1) + [True])).memory
+        self.memory = binary_subtraction(self, BasicRegister(deque([False] * (len(self.memory) - 1) + [True]))).memory
 
     def non_zero(self) -> bool:
         return any(self.memory)
 
 
-def get_memory(variable_name: str) -> list[bool]:
+def get_memory(variable_name: str) -> deque[bool]:
     """
     Reads user input to be used as a memory array.
 
@@ -110,7 +114,7 @@ def get_memory(variable_name: str) -> list[bool]:
         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]
+            return deque([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!")
 
@@ -125,7 +129,7 @@ def binary_sum_with_carry(first_term: BasicRegister, second_term: BasicRegister)
     :return: Register containing the sum and the carry-out bit.
     :rtype: tuple[BasicRegister, int]
     """
-    result_term = BasicRegister([False] * len(first_term))
+    result_term = BasicRegister(deque([False] * len(first_term)))
 
     carry = False
     for i in range(len(first_term) - 1, -1, -1):
@@ -159,39 +163,41 @@ def binary_subtraction(minuend: BasicRegister, subtrahend: BasicRegister) -> Bas
     :return: Register containing the difference.
     :rtype: BasicRegister
     """
-    subtrahend.reverse()
+    subtrahend = BasicRegister(subtrahend.memory)
+    subtrahend.negate()
 
     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]))
+        return binary_sum(difference, BasicRegister(deque([False] * (len(difference) - 1) + [True])))
     else:
-        difference.reverse()
+        difference.negate()
         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 binary_subtraction_second_complement(minuend: BasicRegister, subtrahend: BasicRegister) \
+        -> tuple[BasicRegister, bool]:
+    """
+    Subtracts the second term from the first in binary using seconds' complement.
+
+    :param BasicRegister minuend: Register to subtract from.
+    :param BasicRegister subtrahend: Register to subtract by.
+
+    :return: Register containing the difference.
+    :rtype: BasicRegister
+    """
+    subtrahend = BasicRegister(subtrahend.memory)
+    subtrahend.negate()
+
+    subtrahend = binary_sum(*align_registers(subtrahend, BasicRegister([True])))
+
+    difference: BasicRegister
+    final_carry: bool
+    difference, final_carry = binary_sum_with_carry(minuend, subtrahend)
+
+    return difference, final_carry
 
 
 def align_registers(*registers: BasicRegister) -> tuple[BasicRegister, ...]:
@@ -214,12 +220,13 @@ def format_device_state_table(table) -> str:
     for block in table[1:]:
         for line in block[:-1]:
             pt.add_row(line)
-        pt.add_row(block[-1], divider = True)
+        pt.add_row(block[-1], divider=True)
 
     return pt.get_string()
 
 
-def binary_multiplication_method_1(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+def binary_multiplication_method_1(first_term: BasicRegister, second_term: BasicRegister) \
+        -> tuple[BasicRegister, list[list[str]]]:
     """
     Multiplies two terms containing binary numbers using first method.
 
@@ -232,7 +239,7 @@ def binary_multiplication_method_1(first_term: BasicRegister, second_term: Basic
     first_term, second_term = align_registers(first_term, second_term)
     n: int = len(first_term)
 
-    rg1 = BasicRegister([False] * n)
+    rg1 = BasicRegister(deque([False] * n))
     rg2 = BasicRegister(first_term.memory)
     rg3 = BasicRegister(second_term.memory)
     ct = Counter(n)
@@ -255,13 +262,13 @@ def binary_multiplication_method_1(first_term: BasicRegister, second_term: Basic
         rg1.right_shift()
         ct.decrement()
 
-        print(ct.memory)
-
         data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, ct, "RG2 := RG1[1].r(RG2)\nRG1 := 0.r(RG1)\nCT := CT - 1"])))
 
-    return BasicRegister(list(rg1.memory) + list(rg2.memory)), data_table
+    return BasicRegister(rg1.memory + rg2.memory), data_table
 
-def binary_multiplication_method_2(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+
+def binary_multiplication_method_2(first_term: BasicRegister, second_term: BasicRegister) \
+        -> tuple[BasicRegister, list[list[str]]]:
     """
     Multiplies two terms containing binary numbers using second method.
 
@@ -274,14 +281,13 @@ def binary_multiplication_method_2(first_term: BasicRegister, second_term: Basic
     first_term, second_term = align_registers(first_term, second_term)
     n: int = len(first_term)
 
-    rg1 = BasicRegister([False] * (2*n))
+    rg1 = BasicRegister(deque([False] * (2*n)))
     rg2 = BasicRegister(first_term.memory)
-    rg3 = BasicRegister([False] * n + list(second_term.memory))
+    rg3 = BasicRegister(deque([False] * n + list(second_term.memory)))
 
     i = 0
-    data_table = [["iter", "RG1", "RG2", "RG3", "MicroOperations"]]
+    data_table = [["iter", "RG1", "RG2", "RG3", "MicroOperations"], []]
 
-    data_table.append([])
     data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "-"])))
 
     while any(rg2.memory):
@@ -299,7 +305,9 @@ def binary_multiplication_method_2(first_term: BasicRegister, second_term: Basic
 
     return rg1, data_table
 
-def binary_multiplication_method_3(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+
+def binary_multiplication_method_3(first_term: BasicRegister, second_term: BasicRegister) \
+        -> tuple[BasicRegister, list[list[str]]]:
     """
     Multiplies two terms containing binary numbers using third method.
 
@@ -314,9 +322,9 @@ def binary_multiplication_method_3(first_term: BasicRegister, second_term: Basic
 
     data_table = [["iter", "RG2", "RG1", "RG3", "CT", "MicroOperations"]]
 
-    rg1 = BasicRegister([False] * n)
-    rg2 = BasicRegister(list(first_term.memory) + [False])
-    rg3 = BasicRegister([False] * (n+1) + list(second_term.memory))
+    rg1 = BasicRegister(deque([False] * n))
+    rg2 = BasicRegister(first_term.memory + deque([False]))
+    rg3 = BasicRegister(deque([False] * (n+1)) + second_term.memory)
     ct = Counter(n)
 
     i = 0
@@ -329,8 +337,8 @@ def binary_multiplication_method_3(first_term: BasicRegister, second_term: Basic
 
         if rg2.memory[0]:
             result: list[bool] = list(binary_sum(BasicRegister(rg2.memory + rg1.memory), rg3).memory)
-            rg2 = BasicRegister(result[:n+1])
-            rg1 = BasicRegister(result[n+1:])
+            rg2 = BasicRegister(deque(result[:n+1]))
+            rg1 = BasicRegister(deque(result[n+1:]))
             data_table[-1].append(list(map(str, [i, rg2, rg1, rg3, ct, "RG2.RG1 := RG2.RG1 + RG3"])))
 
         rg2.left_shift(rg1.memory[0])
@@ -339,9 +347,11 @@ def binary_multiplication_method_3(first_term: BasicRegister, second_term: Basic
 
         data_table[-1].append(list(map(str, [i, rg2, rg1, rg3, ct, "RG2.RG1 := l(RG2.RG1).0\nCT := CT - 1"])))
 
-    return BasicRegister((list(rg2.memory) + list(rg1.memory))[:-1]), data_table
+    return BasicRegister(deque(list(rg2.memory + rg1.memory)[:-1])), data_table
 
-def binary_multiplication_method_4(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+
+def binary_multiplication_method_4(first_term: BasicRegister, second_term: BasicRegister) \
+        -> tuple[BasicRegister, list[list[str]]]:
     """
     Multiplies two terms containing binary numbers using fourth method.
 
@@ -354,9 +364,9 @@ def binary_multiplication_method_4(first_term: BasicRegister, second_term: Basic
     first_term, second_term = align_registers(first_term, second_term)
     n: int = len(first_term)
 
-    rg1 = BasicRegister([False] * (2*n+1))
+    rg1 = BasicRegister(deque([False] * (2*n+1)))
     rg2 = BasicRegister(first_term.memory)
-    rg3 = BasicRegister([False] + list(second_term.memory) + [False] * n)
+    rg3 = BasicRegister(deque([False]) + second_term.memory + deque([False] * n))
 
     data_table = [["iter", "RG1", "RG2", "RG3", "MicroOperations"]]
 
@@ -377,4 +387,89 @@ def binary_multiplication_method_4(first_term: BasicRegister, second_term: Basic
 
         data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "RG2 := l(RG2).0\nRG3 := 0.r(RG3)"])))
 
-    return BasicRegister(list(rg1.memory)[:-1]), data_table
+    return BasicRegister(deque(list(rg1.memory)[:-1])), data_table
+
+def binary_division_method_1(first_term: BasicRegister, second_term: BasicRegister) \
+        -> tuple[BasicRegister, list[list[str]]]:
+    """
+    Divides first term by the second term containing binary numbers using first method.
+
+    :param: BasicRegister first_term: Register being divided.
+    :param: BasicRegister second_term: Register being divided by.
+
+    :return: Register containing the division result.
+    :rtype: BasicRegister
+    """
+
+    first_term, second_term = align_registers(first_term, second_term)
+    n: int = len(first_term)
+
+    rg1 = BasicRegister(deque([False, False]) + second_term.memory)
+    rg2 = BasicRegister(deque([False, False]) + first_term.memory)
+    rg3 = BasicRegister(deque([True] * (n+1)))
+
+    data_table = [["iter", "RG3", "RG2", "RG1", "MicroOperations"]]
+    i = 0
+
+    data_table.append([])
+    data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, "-"])))
+
+    while rg3.memory[0]:
+        i += 1
+        data_table.append([])
+
+        if rg2.memory[0]:
+            rg2 = binary_sum(rg2, rg1)
+            data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, "RG2 := RG2 + RG1"])))
+        else:
+            rg2, _ = binary_subtraction_second_complement(rg2, rg1)
+            data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, "RG2 := RG2 - RG1"])))
+
+        rg3.left_shift(not rg2.memory[0])
+        rg2.left_shift()
+        data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, f"RG3 := l(RG3).!RG2[{n+2}]\nRG2 := l(RG2).0"])))
+
+    return BasicRegister(deque(list(rg3.memory)[1:])), data_table
+
+def binary_division_method_2(first_term: BasicRegister, second_term: BasicRegister) \
+        -> tuple[BasicRegister, list[list[str]]]:
+    """
+    Divides first term by the second term containing binary numbers using second method.
+
+    :param: BasicRegister first_term: Register being divided.
+    :param: BasicRegister second_term: Register being divided by.
+
+    :return: Register containing the division result.
+    :rtype: BasicRegister
+    """
+
+    first_term, second_term = align_registers(first_term, second_term)
+    n: int = len(first_term)
+
+    rg1 = BasicRegister(deque([False]) + second_term.memory + deque([False]*n))
+    rg2 = BasicRegister(deque([False]) + first_term.memory + deque([False]*n))
+    rg3 = BasicRegister(deque([True] * (n+1)))
+
+    data_table = [["iter", "RG3", "RG2", "RG1", "MicroOperations"]]
+    i = 0
+    carry = False
+
+    data_table.append([])
+    data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, "-"])))
+
+    while rg3.memory[0]:
+        i += 1
+        data_table.append([])
+
+        if rg2.memory[0]:
+            rg2, carry = binary_sum_with_carry(rg2, rg1)
+            data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, "RG2 := RG2 + RG1"])))
+        else:
+            rg2, carry = binary_subtraction_second_complement(rg2, rg1)
+            data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, "RG2 := RG2 - RG1"])))
+
+        rg3.left_shift(carry)
+        rg1.right_shift()
+        data_table[-1].append(list(map(str, [i, rg3, rg2, rg1, f"RG3 := l(RG3).SM[p]\nRG1 := 0.r(RG1)"])))
+
+    return BasicRegister(deque(list(rg3.memory)[1:])), data_table

main.py

@@ -32,7 +32,13 @@ def input_handler(first_register: bu.BasicRegister, second_register: bu.BasicReg
                     case _:
                         print("Such method does not exist, try again.")
             case "d":
-                pass
+                match input("Choose method to use (1-2):\n>>> "):
+                    case "1":
+                        result, data_table = bu.binary_division_method_1(first_register, second_register)
+                        print(f"Division:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    case "2":
+                        result, data_table = bu.binary_division_method_2(first_register, second_register)
+                        print(f"Division:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
             case "q":
                 exit()
             case _: