Cargo.toml

@@ -13,6 +13,4 @@ panic = 'abort'     # Abort on panic
 strip = true        # Strip symbols from binary*
 
 [dependencies]
-text_io = "0.1.12"
-prettytable-rs = "0.10.0"
-#tabled = "0.12.2"
+text_io = "0.1.12"

src/bit_utilities.rs

@@ -1,5 +1,5 @@
-use prettytable::{Cell, Row, Table};
 use std::collections::VecDeque;
+use std::fmt::Formatter;
 use std::{cmp, fmt};
 
 fn capitalise(s: &str) -> String {
@@ -18,7 +18,6 @@ pub struct BasicRegister {
 }
 
 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;
@@ -37,12 +36,14 @@ impl BasicRegister {
         }
     }
 
-    /// Returns a register which was logically negated.
+    pub fn negate(&mut self) {
+        self.memory = self.memory.iter().map(|val| !val).collect();
+    }
+
     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_shift(
         &mut self,
         shift_in_value_default: Option<bool>,
@@ -52,15 +53,12 @@ impl BasicRegister {
         let bits_shifted: usize = bits_shifted_default.unwrap_or(1) as usize;
 
         let mut shifted_bits: VecDeque<bool> = [].into();
-        for _i in 0..bits_shifted {
-            shifted_bits.push_back(self.memory.pop_front().unwrap());
-            self.memory.push_back(shift_in_value)
-        }
+        (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));
 
         shifted_bits
     }
 
-    /// Shifts the register to the left by a specified number of steps, shifting in the provided values.
     pub fn right_shift(
         &mut self,
         shift_in_value_default: Option<bool>,
@@ -70,35 +68,19 @@ impl BasicRegister {
         let bits_shifted: usize = bits_shifted_default.unwrap_or(1) as usize;
 
         let mut shifted_bits: VecDeque<bool> = [].into();
-        for _i in 0..bits_shifted {
-            shifted_bits.push_back(self.memory.pop_back().unwrap());
-            self.memory.push_front(shift_in_value)
-        }
+        (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));
 
         shifted_bits
     }
 
-    /// 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) -> Table {
-        let mut table = Table::new();
-
-        let mut memory_row: Vec<Cell> = vec![Cell::new("Memory")];
-        self.memory
-            .iter()
-            .for_each(|value| memory_row.push(Cell::new((*value as u8).to_string().as_str())));
-
-        table.add_row(Row::new(memory_row));
-        table
-    }*/
 }
 
 impl Default for BasicRegister {
@@ -110,7 +92,7 @@ impl Default for BasicRegister {
 }
 
 impl fmt::Display for BasicRegister {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "Memory: [")?;
 
         for (count, v) in self.memory.iter().enumerate() {
@@ -124,8 +106,8 @@ impl fmt::Display for BasicRegister {
     }
 }
 
-/*impl fmt::Binary for BasicRegister {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl fmt::Binary for BasicRegister {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "Memory: ")?;
 
         for v in self.memory.iter() {
@@ -134,18 +116,12 @@ impl fmt::Display for BasicRegister {
 
         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}: ");
@@ -160,11 +136,10 @@ fn read_vec(variable_name: &str) -> Vec<char> {
     }
 }
 
-/// 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> {
+pub fn char_to_bool_vector(char_vector: Vec<char>) -> VecDeque<bool> {
     let mut bool_vector: VecDeque<bool> = VecDeque::new();
 
-    for value in char_vector.into_iter() {
+    for value in char_vector.iter() {
         match value {
             '0' => bool_vector.push_back(false),
             '1' => bool_vector.push_back(true),
@@ -175,17 +150,17 @@ pub fn char_to_bool_vecdeque(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_vecdeque(read_vec(variable_name))
+    char_to_bool_vector(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());
+    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);
 
     (
         first_register.adjusted_by_size(required_size),
@@ -193,8 +168,6 @@ 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,
@@ -203,31 +176,34 @@ fn binary_sum_with_carry(
 
     let mut carry: bool = false;
     let mut current_bit_sum: u8;
-    for i in (0..first_term.len()).rev() {
+    for i in (1..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)
+    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)
 }
 
-/// 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]);
+            let mut complement = vec![false; difference.len() - 1];
+            complement.append(&mut vec![true]);
             binary_sum(&difference, &BasicRegister::new(complement.into()))
         }
         false => difference.negated(),
     }
+    // BasicRegister::default()
 }