Trying to multiply.

Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "rust_tests"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[profile.dev.package."*"] # +
+opt-level = "z"     # Optimize library for size
+
+[profile.release]
+#opt-level = 'z'     # Optimize for size
+opt-level = 3       # Optimize for speed
+lto = true          # Enable link-time optimization
+codegen-units = 1   # Reduce number of codegen units to increase optimizations
+panic = 'abort'     # Abort on panic
+strip = true        # Strip symbols from binary*
+
+[dependencies]
+text_io = "0.1.12"
+tabled = "0.14.0"

README.md

@@ -1,3 +0,0 @@
-# binaryCalculatorPrototype
-
-This is a Python language prototype for a binary calculator to be used in Computer Arithmetics lab works for first-year students studying Computer Engineering at KPI.

bitutilities.py

@@ -1,475 +0,0 @@
-import copy
-from collections import deque
-
-from typing_extensions import Self
-from lib.prettytable import PrettyTable
-
-
-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: deque[bool]):
-        self.memory: deque[bool] = memory
-
-    def __repr__(self) -> str:
-        return "".join([str(int(value)) for value in self.memory])
-
-    def __str__(self) -> str:
-        return "".join([str(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(
-            deque([False] * max(resulting_size - current_memory_size, 0) + list(self.memory)[-resulting_size:])
-        )
-
-    def negate(self):
-        """
-        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.
-
-        :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
-
-
-class Counter(BasicRegister):
-    """
-    The Counter represents a hardware register specifically designed for countdowns.
-
-    :param int value: Initial numeric value this Counter holds.
-    """
-
-    def __init__(self, value: int):
-        # 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])
-
-    def __str__(self) -> str:
-        return "".join([str(int(value)) for value in self.memory])
-
-    def __len__(self) -> int:
-        return len(self.memory)
-
-    def decrement(self):
-        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) -> deque[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 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!")
-
-
-def binary_sum_with_carry(first_term: BasicRegister, second_term: BasicRegister) -> tuple[BasicRegister, int]:
-    """
-    Sums two registers' values and keeps the carry-out.
-
-    :param BasicRegister first_term: First register.
-    :param BasicRegister second_term: Second register.
-
-    :return: Register containing the sum and the carry-out bit.
-    :rtype: tuple[BasicRegister, int]
-    """
-    result_term = BasicRegister(deque([False] * len(first_term)))
-
-    carry = False
-    for i in range(len(first_term) - 1, -1, -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)
-
-    return result_term, 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 = 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(deque([False] * (len(difference) - 1) + [True])))
-    else:
-        difference.negate()
-        return difference
-
-
-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, ...]:
-    """
-    Aligns registers by the length of the bigger one.
-
-    :param BasicRegister registers: Registers to align.
-
-    :return: Aligned registers.
-    :rtype: tuple[BasicRegister, ...]
-    """
-    required_size: int = max(map(len, registers))
-    return tuple(reg.adjusted_by_size(required_size) for reg in registers)
-
-
-def format_device_state_table(table) -> str:
-    pt = PrettyTable()
-    pt.field_names = table[0]
-
-    for block in table[1:]:
-        for line in block[:-1]:
-            pt.add_row(line)
-        pt.add_row(block[-1], divider=True)
-
-    return pt.get_string()
-
-
-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.
-
-    :param BasicRegister first_term: First register to multiply.
-    :param BasicRegister second_term: Second register to multiply.
-
-    :return: Register containing the product.
-    :rtype: BasicRegister
-    """
-
-    n: int = len(first_term)
-
-    rg1 = BasicRegister(deque([False] * n))
-    rg2 = copy.copy(first_term)
-    rg3 = copy.copy(second_term)
-    ct = Counter(n)
-
-    data_table = [["iter", "RG1", "RG2", "RG3", "CT", "MicroOperations"]]
-
-    i = 0
-    data_table.append([])
-    data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, ct, "-"])))
-
-    while ct.non_zero():
-        i += 1
-        data_table.append([])
-
-        if rg2.memory[n-1]:
-            rg1 = binary_sum(rg1, rg3)
-            data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, ct, "RG1 := RG1 + RG3"])))
-
-        rg2.right_shift(rg1.memory[n-1])
-        rg1.right_shift()
-        ct.decrement()
-
-        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(rg1.memory + rg2.memory), data_table
-
-
-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.
-
-    :param BasicRegister first_term: First register to multiply.
-    :param BasicRegister second_term: Second register to multiply.
-
-    :return: Register containing the product.
-    :rtype: BasicRegister
-    """
-
-    n: int = len(first_term)
-
-    rg1 = BasicRegister(deque([False] * (2*n)))
-    rg2 = copy.copy(first_term)
-    rg3 = BasicRegister(deque([False] * n + list(second_term.memory)))
-
-    i = 0
-    data_table = [["iter", "RG1", "RG2", "RG3", "MicroOperations"], []]
-
-    data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "-"])))
-
-    while any(rg2.memory):
-        i += 1
-        data_table.append([])
-
-        if rg2.memory[n-1]:
-            rg1 = binary_sum(rg1, rg3)
-            data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "RG1 := RG1 + RG3"])))
-
-        rg2.right_shift()
-        rg3.left_shift()
-
-        data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "RG2 := 0.r(RG2)\nRG3 := l(RG3).0"])))
-
-    return rg1, data_table
-
-
-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.
-
-    :param BasicRegister first_term: First register to multiply.
-    :param BasicRegister second_term: Second register to multiply.
-
-    :return: Register containing the product.
-    :rtype: BasicRegister
-    """
-
-    n: int = len(first_term)
-
-    data_table = [["iter", "RG2", "RG1", "RG3", "CT", "MicroOperations"]]
-
-    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
-    data_table.append([])
-    data_table[-1].append(list(map(str, [i, rg2, rg1, rg3, ct, "-"])))
-
-    while ct.non_zero():
-        i += 1
-        data_table.append([])
-
-        if rg2.memory[0]:
-            result: list[bool] = list(binary_sum(BasicRegister(rg2.memory + rg1.memory), rg3).memory)
-            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])
-        rg1.left_shift()
-        ct.decrement()
-
-        data_table[-1].append(list(map(str, [i, rg2, rg1, rg3, ct, "RG2.RG1 := l(RG2.RG1).0\nCT := CT - 1"])))
-
-    return BasicRegister(deque(list(rg2.memory + rg1.memory)[:-1])), data_table
-
-
-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.
-
-    :param BasicRegister first_term: First register to multiply.
-    :param BasicRegister second_term: Second register to multiply.
-
-    :return: Register containing the product.
-    :rtype: BasicRegister
-    """
-
-    n: int = len(first_term)
-
-    rg1 = BasicRegister(deque([False] * (2*n+1)))
-    rg2 = copy.copy(first_term)
-    rg3 = BasicRegister(deque([False]) + second_term.memory + deque([False] * n))
-
-    data_table = [["iter", "RG1", "RG2", "RG3", "MicroOperations"]]
-
-    i = 0
-    data_table.append([])
-    data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "-"])))
-
-    while any(rg2.memory):
-        i += 1
-        data_table.append([])
-
-        if rg2.memory[0]:
-            rg1 = binary_sum(rg1, rg3)
-            data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "RG1 := RG1 + RG3"])))
-
-        rg2.left_shift()
-        rg3.right_shift()
-
-        data_table[-1].append(list(map(str, [i, rg1, rg2, rg3, "RG2 := l(RG2).0\nRG3 := 0.r(RG3)"])))
-
-    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
-    """
-
-    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
-    """
-
-    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

@@ -1,116 +0,0 @@
-import bitutilities as bu
-
-operation = ""
-method = ""
-
-user_input = []
-
-
-def process_command(symbol):
-    global operation, method
-
-    if symbol.lower() in "asmdq":
-        operation = symbol
-    elif operation == "m" and symbol in "1234":
-        method = symbol
-    elif operation == "d" and symbol in "12":
-        method = symbol
-    elif symbol in " ;:":
-        pass
-    else:
-        print(f"Error: unexpected instruction '{symbol}', skipping")
-
-
-def perform_operation(first_register: bu.BasicRegister, second_register: bu.BasicRegister):
-    global operation, method
-
-    match operation:
-        case "a":
-            result, carry = bu.binary_sum_with_carry(first_register, second_register)
-            print(f"\nSum: {result}\nCarry: {int(carry)}")
-            operation, method = "", ""
-        case "s":
-            result, carry = bu.binary_subtraction_second_complement(first_register, second_register)
-            print(f"\nSubtraction: {result}\nCarry: {int(carry)}")
-            operation, method = "", ""
-        case "m":
-            match method:
-                case "1":
-                    result, data_table = bu.binary_multiplication_method_1(first_register, second_register)
-                    print(f"\nMultiplication (method 1):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    operation, method = "", ""
-                case "2":
-                    result, data_table = bu.binary_multiplication_method_2(first_register, second_register)
-                    print(f"\nMultiplication (method 2):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    operation, method = "", ""
-                case "3":
-                    result, data_table = bu.binary_multiplication_method_3(first_register, second_register)
-                    print(f"\nMultiplication (method 3):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    operation, method = "", ""
-                case "4":
-                    result, data_table = bu.binary_multiplication_method_4(first_register, second_register)
-                    print(f"\nMultiplication (method 4):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    operation, method = "", ""
-                case _:
-                    pass
-        case "d":
-            match method:
-                case "1":
-                    result, data_table = bu.binary_division_method_1(first_register, second_register)
-                    print(f"\nDivision (method 1):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    operation, method = "", ""
-                case "2":
-                    result, data_table = bu.binary_division_method_2(first_register, second_register)
-                    print(f"\nDivision (method 2):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    operation, method = "", ""
-                case _:
-                    pass
-        case "q":
-            exit(0)
-
-        case _:
-            pass
-
-
-def get_prompt_text(operation: any, method: any) -> str:
-    response = "({} {})"
-
-    if operation:
-        response += " {}"
-    if operation and method:
-        response += "/{}"
-
-    return response
-
-
-def input_handler(first_register: bu.BasicRegister, second_register: bu.BasicRegister):
-    global user_input, operation
-    first_register, second_register = bu.align_registers(first_register, second_register)
-
-    print()
-    print(first_register)
-    print(second_register)
-
-    while True:
-        prompt_text: str = get_prompt_text(operation, method).format(first_register, second_register, operation, method)
-        print()
-        if operation == "":
-            raw_user_input = input("Choose the operation:\n[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, "
-                                   "[q]uit\n" + prompt_text + " > ")
-        elif operation == "m":
-            raw_user_input = input("Choose method to use (1-4):\n" + prompt_text + " > ")
-        elif operation == "d":
-            raw_user_input = input("Choose method to use (1-2):\n" + prompt_text + " > ")
-
-        user_input = list(raw_user_input)
-
-        for symbol in user_input:
-            process_command(symbol)
-            perform_operation(first_register, second_register)
-
-
-if __name__ == '__main__':
-    reg1: bu.BasicRegister = bu.BasicRegister(bu.get_memory("first operand"))
-    reg2: bu.BasicRegister = bu.BasicRegister(bu.get_memory("second operand"))
-
-    input_handler(reg1, reg2)

src/bit_utilities.rs

@@ -0,0 +1,266 @@
+use std::collections::VecDeque;
+use std::{cmp, fmt};
+
+fn capitalise(s: &str) -> String {
+    let mut c = s.chars();
+    match c.next() {
+        None => String::new(),
+        Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+    }
+}
+
+/// A basic register capable of storing binary data.
+#[derive(Debug, Clone)]
+pub struct BasicRegister {
+    /// A [VecDeque] that stores the binary data of the register.
+    memory: VecDeque<bool>,
+}
+
+impl BasicRegister {
+    /// Adjusts a register to a given size in bits.
+    pub fn adjusted_by_size(&mut self, resulting_size: usize) -> Self {
+        let current_memory_size: usize = self.memory.len();
+        let difference: i32 = current_memory_size as i32 - resulting_size as i32;
+
+        match current_memory_size > resulting_size {
+            true => BasicRegister::new(
+                (difference as usize..current_memory_size)
+                    .map(|i| self.memory[i])
+                    .collect::<VecDeque<bool>>(),
+            ),
+            false => {
+                let mut resulting_memory: VecDeque<bool> = vec![false; -difference as usize].into();
+                resulting_memory.append(&mut self.memory);
+                BasicRegister::new(resulting_memory)
+            }
+        }
+    }
+
+    /// Returns a register which was logically negated.
+    pub fn negated(&self) -> Self {
+        BasicRegister::new(self.memory.iter().map(|val| !val).collect())
+    }
+
+    /// Shifts the register to the left by a specified number of steps, shifting in the provided values.
+    pub fn left_shifted(&self, shift_in_value: bool, bits_shifted: usize) -> Self {
+        let mut shifted_memory = self.memory.clone();
+
+        for _ in 0..bits_shifted {
+            shifted_memory.pop_front();
+            shifted_memory.push_back(shift_in_value)
+        }
+
+        BasicRegister::new(shifted_memory)
+    }
+
+    /// Shifts the register to the left by a specified number of steps, shifting in the provided values.
+    pub fn right_shifted(&self, shift_in_value: bool, bits_shifted: i32) -> Self {
+        let mut shifted_memory = self.memory.clone();
+
+        for _i in 0..bits_shifted {
+            shifted_memory.pop_back();
+            shifted_memory.push_front(shift_in_value)
+        }
+
+        BasicRegister::new(shifted_memory)
+    }
+
+    /// Constructs a new BasicRegister from a given VecDeque<bool> as memory.
+    pub fn new(memory: VecDeque<bool>) -> Self {
+        Self { memory }
+    }
+
+    /// Returns the number of bits stored in a register.
+    pub fn len(&self) -> usize {
+        self.memory.len()
+    }
+
+    pub fn table(&self) -> String {
+        use tabled::{builder::Builder, settings::Style};
+        let mut m_row: Vec<String> = Vec::new();
+        self.memory
+            .iter()
+            .for_each(|bit| m_row.push((*bit as u8).to_string()));
+        let mut builder: Builder = Builder::default();
+        builder.push_record(
+            self.memory
+                .iter()
+                .map(|bit| (*bit as u8).to_string())
+                .collect::<Vec<String>>(),
+        );
+
+        builder.build().with(Style::modern()).to_string()
+    }
+
+    fn decrement(&mut self) {
+        let one = BasicRegister::new([true].into()).adjusted_by_size(self.len());
+        self.memory = binary_subtraction(self, &one).memory;
+    }
+
+    fn increment(&mut self) {
+        let one = BasicRegister::new([true].into()).adjusted_by_size(self.len());
+        self.memory = binary_sum(self, &one).memory;
+    }
+
+    fn non_zero(&mut self) -> bool {
+        self.memory.iter().any(|i| *i)
+    }
+}
+
+impl Default for BasicRegister {
+    fn default() -> Self {
+        Self {
+            memory: [false].into(),
+        }
+    }
+}
+
+impl fmt::Display for BasicRegister {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Memory: [")?;
+
+        for (count, v) in self.memory.iter().enumerate() {
+            if count != 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}", *v as u8)?;
+        }
+
+        write!(f, "]")
+    }
+}
+
+impl fmt::Binary for BasicRegister {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for v in self.memory.iter() {
+            write!(f, "{}", *v as u8)?;
+        }
+
+        write!(f, "")
+    }
+}
+
+/// Converts a u8 number to a boolean.
+///
+/// # Returns
+/// * false - if the number is zero or below.
+/// * true - if the number is above zero.
+fn u8_to_bool(number: u8) -> bool {
+    number > 0
+}
+
+/// Reads a Vec<char> containing only 1-s and 0-s from user.
+fn read_vec(variable_name: &str) -> Vec<char> {
+    loop {
+        print!("Enter {variable_name}: ");
+        let input: String = text_io::read!("{}\n");
+        match input.chars().all(|c| c == '1' || c == '0') {
+            true => return input.chars().collect(),
+            false => eprintln!(
+                "[ERROR] {} may contain only 1-s and 0-s with no whitespaces!",
+                capitalise(variable_name)
+            ),
+        }
+    }
+}
+
+/// Converts a Vec<char> containing only 1-s and 0-s to VecDeque<bool>.
+pub fn char_to_bool_vecdeque(char_vector: Vec<char>) -> VecDeque<bool> {
+    let mut bool_vector: VecDeque<bool> = VecDeque::new();
+
+    for value in char_vector.into_iter() {
+        match value {
+            '0' => bool_vector.push_back(false),
+            '1' => bool_vector.push_back(true),
+            _ => (),
+        }
+    }
+
+    bool_vector
+}
+
+/// Handles getting the memory for the register from the user.
+pub fn get_memory(variable_name: &str) -> VecDeque<bool> {
+    char_to_bool_vecdeque(read_vec(variable_name))
+}
+
+/// Aligns two registers by the length of the bigger one.
+pub fn align_registers(
+    mut first_register: BasicRegister,
+    mut second_register: BasicRegister,
+) -> (BasicRegister, BasicRegister) {
+    let required_size: usize = cmp::max(first_register.len(), second_register.len());
+
+    (
+        first_register.adjusted_by_size(required_size),
+        second_register.adjusted_by_size(required_size),
+    )
+}
+
+/// Sums two terms containing binary numbers and keeps the carry-out.
+/// Returns a tuple containing the register with result and a carry-out.
+fn binary_sum_with_carry(
+    first_term: &BasicRegister,
+    second_term: &BasicRegister,
+) -> (BasicRegister, bool) {
+    let mut sum: BasicRegister = BasicRegister::new(vec![false; first_term.len()].into());
+
+    let mut carry: bool = false;
+    let mut current_bit_sum: u8;
+    for i in (0..first_term.len()).rev() {
+        current_bit_sum = first_term.memory[i] as u8 + second_term.memory[i] as u8 + carry as u8;
+        carry = u8_to_bool(current_bit_sum & 2);
+        sum.memory[i] = u8_to_bool(current_bit_sum & 1);
+    }
+
+    (sum, carry)
+}
+
+/// Sums two terms containing binary numbers.
+/// Returns the BasicRegister with the result.
+pub fn binary_sum(first_term: &BasicRegister, second_term: &BasicRegister) -> BasicRegister {
+    binary_sum_with_carry(first_term, second_term).0
+}
+
+/// Subtracts the value of the subtrahend from the minuend in binary using ones' complement.
+pub fn binary_subtraction(minuend: &BasicRegister, subtrahend: &BasicRegister) -> BasicRegister {
+    let (difference, final_carry) = binary_sum_with_carry(minuend, &subtrahend.negated());
+
+    match final_carry {
+        true => {
+            let mut complement: Vec<bool> = vec![false; difference.len() - 1];
+            complement.extend([true]);
+            binary_sum(&difference, &BasicRegister::new(complement.into()))
+        }
+        false => difference.negated(),
+    }
+}
+
+/// Multiplies the first term by the second term.
+pub fn binary_multiplication_method_1(
+    first_term: &BasicRegister,
+    second_term: &BasicRegister,
+) -> BasicRegister {
+    let n = first_term.len();
+    let mut rg1: BasicRegister = BasicRegister::new(vec![false; n].into());
+    let mut rg2: &BasicRegister = first_term;
+    let rg3: &BasicRegister = second_term;
+    let mut counter: BasicRegister = BasicRegister::new(char_to_bool_vecdeque(format!("{n:b}").chars().collect()));
+
+    let _i = 0;
+
+    while counter.non_zero() {
+        let value_to_check = rg2.memory[n - 1].clone();
+        if value_to_check {
+            rg1 = binary_sum(&rg1, rg3);
+        }
+
+        let new_rg2 = rg2.right_shifted(rg1.memory[n - 1], 1).clone();
+        rg2 = &rg2.right_shifted(rg1.memory[n - 1], 1);
+        rg1 = rg1.right_shifted(false, 1);
+        counter.decrement();
+    }
+
+    rg1.memory.append(&mut rg2.memory.clone());
+    rg1
+}

src/main.rs

@@ -0,0 +1,60 @@
+#![allow(dead_code)]
+
+mod bit_utilities;
+
+use bit_utilities as bu;
+use text_io::read;
+
+fn input_handler() {
+    let (mut first_register, mut second_register) = bu::align_registers(
+        bu::BasicRegister::new(bu::get_memory("first number")),
+        bu::BasicRegister::new(bu::get_memory("second number")),
+    );
+
+    // println!();
+    // println!("First register:\n{}", first_register.table());
+    // println!("Second register:\n{}", second_register.table());
+
+    loop {
+        print!("\nChoose the operation:\n[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit\n>>> ");
+        let input: String = read!();
+        match input.as_str() {
+            "a" => {
+                let sum: bu::BasicRegister = bu::binary_sum(&first_register, &second_register);
+                println!("Sum:\n{}\nResult (to copy): {sum:b}", sum.table())
+            }
+            "s" => {
+                let difference: bu::BasicRegister =
+                    bu::binary_subtraction(&first_register, &second_register);
+                println!(
+                    "Difference:\n{}\nResult (to copy): {difference:b}",
+                    difference.table()
+                )
+            },
+            "m" => loop {
+                print!("\nChoose method to use (1-4): ");
+                let method_input: String = read!();
+                match method_input.as_str() {
+                    "1" => {
+                        println!("{}", bu::binary_multiplication_method_1(&first_register, &second_register));
+                        break;
+                    },
+                    _ => println!("Not an available operation, try again."),
+                }
+            },
+            "d" => (),
+            "q" => std::process::exit(0x0100),
+            _ => println!("Not an available operation, try again."),
+        }
+    }
+}
+
+fn main() {
+    // let mut reg = bu::BasicRegister::new(bu::get_memory("your number"));
+    // let mut reg2 = bu::BasicRegister::new(bu::get_memory("your number"));
+    //
+    // println!("{reg}");
+    // println!("{reg2}");
+    // println!("{}", bu::binary_multiplication_method_1(reg, reg2))
+    input_handler();
+}