remove redundant method: BasicRegister.compact_str()

Added carry return (VERY NOT SURE IF IT WORKS CORRECTLY).

Cargo.toml

@@ -1,16 +0,0 @@
-[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.release]
-opt-level = 'z'     # Optimize for size
-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"

README.md

@@ -0,0 +1,3 @@
+# 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

@@ -0,0 +1,380 @@
+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: list[bool]):
+        self.memory: deque[bool] = deque(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(
+            [False] * max(resulting_size - current_memory_size, 0) + list(self.memory)[-resulting_size:]
+        )
+
+    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
+
+        :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:
+    """
+    The Counter represents a hardware register specifically designed for countdowns.
+
+    :param int value: Initial numeric value this Counter holds.
+    """
+
+    def __init__(self, value: int):
+        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([False] * (len(self.memory) - 1) + [True])).memory
+
+    def non_zero(self) -> bool:
+        return any(self.memory)
+
+
+def get_memory(variable_name: str) -> list[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 [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([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.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]))
+    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(*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) -> BasicRegister:
+    """
+    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
+    """
+    first_term, second_term = align_registers(first_term, second_term)
+    n: int = len(first_term)
+
+    rg1 = BasicRegister([False] * n)
+    rg2 = BasicRegister(first_term.memory)
+    rg3 = BasicRegister(second_term.memory)
+    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()
+
+        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
+
+def binary_multiplication_method_2(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+    """
+    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
+    """
+    first_term, second_term = align_registers(first_term, second_term)
+    n: int = len(first_term)
+
+    rg1 = BasicRegister([False] * (2*n))
+    rg2 = BasicRegister(first_term.memory)
+    rg3 = BasicRegister([False] * n + list(second_term.memory))
+
+    i = 0
+    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):
+        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) -> BasicRegister:
+    """
+    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
+    """
+    first_term, second_term = align_registers(first_term, second_term)
+    n: int = len(first_term)
+
+    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))
+    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(result[:n+1])
+            rg1 = BasicRegister(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((list(rg2.memory) + list(rg1.memory))[:-1]), data_table
+
+def binary_multiplication_method_4(first_term: BasicRegister, second_term: BasicRegister) -> BasicRegister:
+    """
+    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
+    """
+    first_term, second_term = align_registers(first_term, second_term)
+    n: int = len(first_term)
+
+    rg1 = BasicRegister([False] * (2*n+1))
+    rg2 = BasicRegister(first_term.memory)
+    rg3 = BasicRegister([False] + list(second_term.memory) + [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(list(rg1.memory)[:-1]), data_table

main.py

@@ -0,0 +1,46 @@
+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":
+                match input("Choose method to use (1-4):\n>>> "):
+                    case "1":
+                        result, data_table = bu.binary_multiplication_method_1(first_register, second_register)
+                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    case "2":
+                        result, data_table = bu.binary_multiplication_method_2(first_register, second_register)
+                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    case "3":
+                        result, data_table = bu.binary_multiplication_method_3(first_register, second_register)
+                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    case "4":
+                        result, data_table = bu.binary_multiplication_method_4(first_register, second_register)
+                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    case _:
+                        print("Such method does not exist, try again.")
+            case "d":
+                pass
+            case "q":
+                exit()
+            case _:
+                print("Not an available operation, try again.")
+
+
+if __name__ == '__main__':
+    reg: bu.BasicRegister = bu.BasicRegister(bu.get_memory("memory"))
+    reg2: bu.BasicRegister = bu.BasicRegister(bu.get_memory("more memory"))
+
+    input_handler(reg, reg2)

src/bit_utilities.rs

@@ -1,101 +0,0 @@
-use std::fmt;
-use std::fmt::Formatter;
-
-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)]
-pub struct BasicRegister {
-    /// A [Vec] that stores the binary data of the register.
-    memory: Vec<bool>,
-}
-
-impl BasicRegister {
-    pub fn l_shift(&mut self) {
-        let mut res: Vec<bool> = vec![false; self.memory.len()];
-
-        res[..(self.memory.len() - 1)]
-            .copy_from_slice(&self.memory[1..((self.memory.len() - 1) + 1)]);
-
-        self.memory = res;
-    }
-
-    pub fn r_shift(&mut self) {
-        let mut res: Vec<bool> = vec![false; self.memory.len()];
-
-        for i in (1..self.memory.len()).rev() {
-            res[i] = self.memory[i - 1];
-        }
-
-        self.memory = res;
-    }
-
-    pub fn reverse(&mut self) {
-        self.memory = self.memory.iter().map(|val| !val).collect();
-    }
-
-    pub fn new(memory: Vec<bool>) -> Self {
-        Self { memory }
-    }
-}
-
-impl Default for BasicRegister {
-    fn default() -> Self {
-        Self {
-            memory: vec![false],
-        }
-    }
-}
-
-impl fmt::Display for BasicRegister {
-    fn fmt(&self, f: &mut 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, "]")
-    }
-}
-
-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)
-            ),
-        }
-    }
-}
-
-pub fn char_to_bool_vector(char_vector: Vec<char>) -> Vec<bool> {
-    let mut bool_vector: Vec<bool> = Vec::new();
-
-    for value in char_vector.iter() {
-        match value {
-            '0' => bool_vector.push(false),
-            '1' => bool_vector.push(true),
-            _ => (),
-        }
-    }
-
-    bool_vector
-}
-
-pub fn get_memory(variable_name: &str) -> Vec<bool> {
-    char_to_bool_vector(read_vec(variable_name))
-}

src/main.rs

@@ -1,44 +0,0 @@
-#[allow(dead_code)]
-mod bit_utilities;
-
-use bit_utilities::*;
-// use text_io::read;
-
-fn main() {
-       let mut reg = BasicRegister::new(get_memory("your number"));
-    // let mut reg: BasicRegister = Default::default();
-
-    println!("\nRegister:");
-    println!("{}", reg);
-
-    println!("\nShifted right:");
-    reg.r_shift();
-    println!("{}", reg);
-
-    println!("\nShifted left:");
-    reg.l_shift();
-    println!("{}", reg);
-
-    println!("\nReversed:");
-    reg.reverse();
-    println!("{}", reg);
-
-    // println!("{}", true);
-    // println!("{}", true);
-
-    // let a: i8 = read!();
-    // println!("{} {0:b}", a);
-    // println!("{} {0:b}", a >> 1);
-    // println!("{} {0:b}", a << 1);
-    // println!("{} {0:b}", !a);
-    // println!("{}", '3'.to_digit(2).unwrap());
-    // let f_text = format!("{a:b}").chars().collect::<Vec<char>>();
-    // println!("{:?}", f_text);
-    // println!("{:?}", char_to_bool_vector(f_text.clone()));
-    // let b: BasicRegister = BasicRegister::new(char_to_bool_vector(f_text));
-    // b.print_register();
-    // println!("{:?}", get_memory(format!("{a:b}")));
-    // println!("{:?}", a.split(" ").collect::<Vec<&str>>());
-    // a = text_io::read!("{}\n");
-    // println!("{a}")
-}