Trying to multiply.

Cargo.toml

@@ -5,12 +5,17 @@ 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 = '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"
+text_io = "0.1.12"
+tabled = "0.14.0"

src/bit_utilities.rs

@@ -1,5 +1,4 @@
 use std::collections::VecDeque;
-use std::fmt::Formatter;
 use std::{cmp, fmt};
 
 fn capitalise(s: &str) -> String {
@@ -11,13 +10,14 @@ fn capitalise(s: &str) -> String {
 }
 
 /// A basic register capable of storing binary data.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct BasicRegister {
-    /// A [Vec] that stores the binary data of the register.
+    /// 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;
@@ -36,51 +36,75 @@ impl BasicRegister {
         }
     }
 
-    pub fn negate(&mut self) {
-        self.memory = self.memory.iter().map(|val| !val).collect();
-    }
-
+    /// Returns a register which was logically negated.
     pub fn negated(&self) -> Self {
         BasicRegister::new(self.memory.iter().map(|val| !val).collect())
     }
 
-    pub fn left_shift(
-        &mut self,
-        shift_in_value_default: Option<bool>,
-        bits_shifted_default: Option<i32>,
-    ) -> VecDeque<bool> {
-        let shift_in_value: bool = shift_in_value_default.unwrap_or(false);
-        let bits_shifted: usize = bits_shifted_default.unwrap_or(1) as usize;
+    /// 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();
 
-        let mut shifted_bits: VecDeque<bool> = [].into();
-        (0..bits_shifted).for_each(|_| shifted_bits.push_back(self.memory.pop_front().unwrap()));
-        (0..bits_shifted).for_each(|_| self.memory.push_back(shift_in_value));
+        for _ in 0..bits_shifted {
+            shifted_memory.pop_front();
+            shifted_memory.push_back(shift_in_value)
+        }
 
-        shifted_bits
+        BasicRegister::new(shifted_memory)
     }
 
-    pub fn right_shift(
-        &mut self,
-        shift_in_value_default: Option<bool>,
-        bits_shifted_default: Option<i32>,
-    ) -> VecDeque<bool> {
-        let shift_in_value: bool = shift_in_value_default.unwrap_or(false);
-        let bits_shifted: usize = bits_shifted_default.unwrap_or(1) as usize;
+    /// 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();
 
-        let mut shifted_bits: VecDeque<bool> = [].into();
-        (0..bits_shifted).for_each(|_| shifted_bits.push_back(self.memory.pop_back().unwrap()));
-        (0..bits_shifted).for_each(|_| self.memory.push_front(shift_in_value));
+        for _i in 0..bits_shifted {
+            shifted_memory.pop_back();
+            shifted_memory.push_front(shift_in_value)
+        }
 
-        shifted_bits
+        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 {
@@ -92,7 +116,7 @@ impl Default for BasicRegister {
 }
 
 impl fmt::Display for BasicRegister {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Memory: [")?;
 
         for (count, v) in self.memory.iter().enumerate() {
@@ -107,9 +131,7 @@ impl fmt::Display for BasicRegister {
 }
 
 impl fmt::Binary for BasicRegister {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "Memory: ")?;
-
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         for v in self.memory.iter() {
             write!(f, "{}", *v as u8)?;
         }
@@ -118,10 +140,16 @@ impl fmt::Binary for BasicRegister {
     }
 }
 
+/// 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}: ");
@@ -136,10 +164,11 @@ fn read_vec(variable_name: &str) -> Vec<char> {
     }
 }
 
-pub fn char_to_bool_vector(char_vector: Vec<char>) -> VecDeque<bool> {
+/// 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.iter() {
+    for value in char_vector.into_iter() {
         match value {
             '0' => bool_vector.push_back(false),
             '1' => bool_vector.push_back(true),
@@ -150,17 +179,17 @@ pub fn char_to_bool_vector(char_vector: Vec<char>) -> VecDeque<bool> {
     bool_vector
 }
 
+/// Handles getting the memory for the register from the user.
 pub fn get_memory(variable_name: &str) -> VecDeque<bool> {
-    char_to_bool_vector(read_vec(variable_name))
+    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 first_size: usize = first_register.memory.len();
-    let second_size: usize = second_register.memory.len();
-    let required_size: usize = cmp::max(first_size, second_size);
+    let required_size: usize = cmp::max(first_register.len(), second_register.len());
 
     (
         first_register.adjusted_by_size(required_size),
@@ -168,6 +197,8 @@ pub fn align_registers(
     )
 }
 
+/// 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,
@@ -176,34 +207,60 @@ fn binary_sum_with_carry(
 
     let mut carry: bool = false;
     let mut current_bit_sum: u8;
-    for i in (1..first_term.len()).rev() {
+    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);
     }
 
-    let final_bit_sum: u8 = first_term.memory[0] as u8 + second_term.memory[0] as u8 + carry as u8;
-    let final_carry: bool = u8_to_bool(final_bit_sum & 2);
-
-    sum.memory[0] = u8_to_bool(final_bit_sum & 1);
-
-    (sum, final_carry)
+    (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![false; difference.len() - 1];
-            complement.append(&mut vec![true]);
+            let mut complement: Vec<bool> = vec![false; difference.len() - 1];
+            complement.extend([true]);
             binary_sum(&difference, &BasicRegister::new(complement.into()))
         }
         false => difference.negated(),
     }
-    // BasicRegister::default()
+}
+
+/// 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,29 +1,47 @@
-#[allow(dead_code)]
+#![allow(dead_code)]
+
 mod bit_utilities;
 
 use bit_utilities as bu;
 use text_io::read;
 
-fn input_handler(first_register: bu::BasicRegister, second_register: bu::BasicRegister) {
-    let (first_register, second_register) = bu::align_registers(first_register, second_register);
+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);
-    println!("{}", second_register);
+    // 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" => println!(
-                "Sum:\n{}",
-                bu::binary_sum(&first_register, &second_register)
-            ),
-            "s" => println!(
-                "Subtraction:\n{}",
-                bu::binary_subtraction(&first_register, &second_register)
-            ),
-            "m" => (),
+            "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."),
@@ -32,8 +50,11 @@ fn input_handler(first_register: bu::BasicRegister, second_register: bu::BasicRe
 }
 
 fn main() {
-    let reg = bu::BasicRegister::new(bu::get_memory("your number"));
-    let reg2 = bu::BasicRegister::new(bu::get_memory("your number"));
-
-    input_handler(reg, reg2);
+    // 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();
 }