fix wrong carry bit output

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

Cargo.toml

@@ -1,21 +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.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

@@ -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,109 @@
+from collections import deque
+from typing_extensions import Self
+
+
+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 f"Memory: {[int(value) for value in  self.memory]}"
+
+    def __str__(self) -> str:
+        return f"Memory: {[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):
+        self.memory = deque([not value for value in self.memory])
+
+    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
+
+    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]:
+    """
+    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(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]
+    """
+    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(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:
+        return c

main.py

@@ -0,0 +1,31 @@
+import bitutilities as bu
+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"))
+
+    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)

src/bit_utilities.rs

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

@@ -1,60 +0,0 @@
-#![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();
-}