Initial Commit

Author: JyotismoyKalita

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,6 @@
+[package]
+name = "booths-algorithm"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

Cargo.toml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jyotismoy Kalita
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE

@@ -0,0 +1,134 @@
+# Booth's Algorithm Step Visualization
+
+by [Jyotismoy Kalita](https://github.com/JyotismoyKalita)
+
+## Description
+
+A small program written in Rust to display the Booth's Algorithm for multiplication step by step.
+
+## Cloning the repository
+
+```sh
+# Clone the repository
+git clone https://github.com/JyotismoyKalita/booths-algorithm.git
+cd booths-algo
+```
+
+## Running Source file with cargo
+
+You can compile and run your program using cargo:
+
+### Compiling
+
+```sh
+#debug version
+#for release use --release
+cargo build
+```
+
+### Running
+
+```sh
+#debug version
+#for release use --release
+#Use "-h" for help.
+#Use "-r VALUE" for specifying the Register Size
+cargo run
+```
+
+## Using the binary - booths-algorithm
+
+Suppose in your current working directory you have saved the binary executable with the name `booths-algorithm`
+
+### Run the program
+
+Running without -r flag would let you enter the register size during runtime.
+
+```sh
+./booths-algorithm
+```
+
+### Run in Help mode
+
+Display Help and other useful information
+
+```sh
+./booths-algorithm -h
+```
+
+### Run with -r flag
+
+Run with register size specified at compile time.
+
+```sh
+#here the Register size is specified as 4 bits
+./booths-algorithm -r 4
+```
+
+## Modules
+
+### Under the `booth` module we have 4 submodules
+
+- **io.rs**: Contains functions for taking input and printing the values
+- **ops.rs**: Contains Operations of Booth's Algorithm
+- **utils.rs**: Contains other utility functions
+- **console.rs**: Contains console functions
+
+### Structure
+
+```sh
+📦 booths-algotithm
+├─ 📦 src
+│  ├─ 📦 booth
+│  │  ├─ 📄mod.rs
+│  │  ├─ 📄io.rs
+│  │  ├─ 📄ops.rs
+│  │  ├─ 📄util.rs
+│  │  └─ 📄console.rs
+│  ├─ 📄main.rs
+│  └─ 📄lib.rs
+│  .gitignore
+│  🔒Cargo.lock
+├─ Cargo.toml
+├─ 📖README.md
+└─ 🪪LICENSE 
+```
+
+## Help
+
+### FLAGS
+
+`-r X`:   Specify the register bit size where X is the specified size. 0 < X <= 16.
+        If Register flag is not used when executing the program. The option to specify register will
+        show during runtime.
+
+`-h`:     Use help.
+
+### DEFINITION OF STEPS
+
+`Initialization`:&emsp;Initial Value after loading up Multiplier and Multiplicand.
+
+`A <- A + M`:&emsp;&emsp;&emsp;Values of Register A & M are added and put back into A register.
+
+`A <- A - M`:&emsp;&emsp;&emsp;Values of Register M subtracted from A and put into A register.
+
+`ASR`:&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;Arithmetic Shift Right. The MSB is retained while all other bits are shifted right starting from A to Q-1.
+
+### ALGORITHM
+
+Action is determined by the Bits stored in 0th bit of Q and -1th bit of Q a.k.a Q-1. Here's the table for the actions -
+
+<div align="center">
+
+|Q   |Q-1 |Action                       |
+|:--:|:--:|:---------------------------:|
+|0   |0   |**ASR**                      |
+|0   |1   |**A <- A + M** *then* **ASR**|
+|1   |0   |**A <- A - M** *then* **ASR**|
+|1   |1   |**ASR**                      |
+
+</div>
+
+This Algorithm is repeated as many times as there are Bits in the Registers.
+
+E.g. If Register size if 4, the Algorithm is repeated 4 times.

README.md

@@ -0,0 +1,77 @@
+use std::process::exit;
+
+pub const R_FLAG: &str = "-r";
+pub const H_FLAG: &str = "-h";
+pub const HELP: &str = "
+    *******************Booth's Algorithm Step Visualization***************************
+                                                                - by Jyotismoy Kalita
+    
+    ------------------------------------ HELP ----------------------------------------
+    FLAGS:
+    -r X:   Specify the register bit size where X is the specified size. 0 < X <= 16.
+            If Register flag is not used when executing the program. The option to specify register will
+            show during runtime.
+
+    -h:     Use help.
+
+    DEFINITION OF STEPS:
+    Initialization:     Initial Value after loading up Multiplier and Multiplicand.
+    A <- A + M:         Values of Register A & M are added and put back into A register.
+    A <- A - M:         Values of Register M subtracted from A and put into A register.
+    ASR:                Arithmetic Shift Right. The MSB is retained while all other bits are shifted right starting from A to Q-1.
+
+    ALGORITHM:
+    Action is determined by the Bits stored in 0th bit of Q and -1th bit of Q a.k.a Q-1. Here's the table for the actions -
+
+    Q   Q-1     Action
+    --------------------------------
+    0   0       ASR
+    0   1       A <- A + M then ASR
+    1   0       A <- A - M then ASR
+    1   1       ASR
+    --------------------------------
+    This Algorithm is repeated as many times as there are Bits in the Registers.
+    E.g. If Register size if 4, the Algorithm is repeated 4 times.
+
+";
+
+pub fn initialize_size(args: Vec<String>) -> usize {
+    let size: usize;
+    if args.contains(&H_FLAG.to_string()) {
+        if args.contains(&R_FLAG.to_string()) {
+            println!("Note: Cannot run program while in Help mode\n");
+        }
+        println!("{}", HELP);
+        exit(0);
+    }
+    if args.contains(&R_FLAG.to_string()) {
+        let pos = args.iter().position(|x| x == R_FLAG).unwrap() + 1;
+        let n = args
+            .get(pos)
+            .expect("Register Flag used but size not specified\nUse -h for help.");
+        size = n
+            .parse::<usize>()
+            .expect("Invalid Register Size specified. Use -h for help.\n");
+    } else {
+        size = crate::booth::get_size();
+    }
+    if size == 0 {
+        println!("Register Size specified cannot be 0. Use -h for help.");
+        exit(1);
+    }
+    if size > 16 {
+        println!("Register Size specified exceeds maximum limit of 16. Use -h for help.");
+        exit(2);
+    }
+    println!(
+        "Input Range: {} to {}",
+        -2_i32.pow(size as u32 - 1),
+        (2_i32.pow(size as u32 - 1) - 1)
+    );
+    println!(
+        "Output Range: {} to {}\n",
+        -2_i32.pow(size as u32 * 2 - 1),
+        (2_i32.pow(size as u32 * 2 - 1) - 1)
+    );
+    size
+}

src/booth/console.rs

@@ -0,0 +1,35 @@
+use std::io;
+
+pub fn int_input<T: std::str::FromStr>() -> T
+where
+    <T as std::str::FromStr>::Err: std::fmt::Debug,
+{
+    let mut buff: String = String::new();
+    io::stdin().read_line(&mut buff).expect("Input Error");
+    let num: T = buff.trim().parse::<T>().expect("Invalid Input");
+    num
+}
+
+pub fn print_header() {
+    println!("A \tQ \tQ-1 \tM");
+}
+
+pub fn print_step(size: usize, mut a: i32, mut q: i32, qc: u32, mut m: i32, step: &str, end: bool) {
+    a = a & (2_i32.pow(size as u32) - 1);
+    q = q & (2_i32.pow(size as u32) - 1);
+    m = m & (2_i32.pow(size as u32) - 1);
+    println!(
+        "{:0size$b} \t{:0size$b} \t{:01b} \t{:0size$b} \t{}",
+        a, q, qc, m, step
+    );
+    if end {
+        println!("{}", "-".repeat(size * 6 + 28));
+    }
+}
+
+pub fn print_result(mut res: i32, mut size: usize) {
+    size *= 2;
+    println!("\tResult(decimal): \t{}", res);
+    res = res & (2_i32.pow(size as u32) - 1);
+    println!("\tResult(binary): \t{:0size$b}", res);
+}

src/booth/io.rs

@@ -0,0 +1,9 @@
+pub mod console;
+pub mod io;
+pub mod ops;
+pub mod util;
+
+pub use console::*;
+pub use io::*;
+pub use ops::*;
+pub use util::*;

src/booth/mod.rs

@@ -0,0 +1,26 @@
+use crate::booth;
+
+pub fn asr(a: &mut i32, q: &mut i32, qc: &mut u32, size: usize) {
+    *qc = *q as u32 & 1_u32;
+    let temp: i32 = *a & 1;
+    *q = ((*q >> 1) & (2_i32.pow(size as u32 - 1) - 1)) | (temp << (size - 1));
+    *a = *a >> 1;
+}
+
+pub fn booth_algorithm(a: &mut i32, q: &mut i32, qc: &mut u32, m: &mut i32, size: usize) {
+    booth::print_header();
+    booth::print_step(size, *a, *q, *qc, *m, "Initialization", true);
+
+    for _ in 0..size {
+        let lsb: i32 = *q & 1;
+        if lsb == 0 && *qc == 1 {
+            *a += *m;
+            booth::print_step(size, *a, *q, *qc, *m, "A <- A + M", false);
+        } else if lsb == 1 && *qc == 0 {
+            *a -= *m;
+            booth::print_step(size, *a, *q, *qc, *m, "A <- A - M", false);
+        }
+        asr(a, q, qc, size);
+        booth::print_step(size, *a, *q, *qc, *m, "ASR", true);
+    }
+}

src/booth/ops.rs

@@ -0,0 +1,30 @@
+use std::io::{self, Write};
+
+use crate::booth;
+
+pub fn get_size() -> usize {
+    print!("Enter the size of Registers(MAX 16): ");
+    io::stdout().flush().unwrap();
+    let size: usize = booth::int_input::<usize>();
+    size
+}
+
+pub fn initialize_a_q_m() -> (i32, i32, i32, u32) {
+    let a: i32 = 0;
+    let q: i32;
+    let m: i32;
+    let qc: u32 = 0;
+    print!("Enter the Multiplicand(M): ");
+    io::stdout().flush().unwrap();
+    m = booth::int_input::<i32>();
+    print!("Enter the Multiplier(Q): ");
+    io::stdout().flush().unwrap();
+    q = booth::int_input::<i32>();
+    (a, q, m, qc)
+}
+
+pub fn get_result(a: i32, q: i32, size: usize) -> i32 {
+    let size: u32 = size as u32;
+    let res: i32 = (a << size) | (q & (2_i32.pow(size as u32) - 1));
+    res
+}