ladderz

The ladderz project is a collection of math and tech concepts implemented in code.

ladderz library - A Rust library for running concept implementations
lz CLI - A command line tool for running ladderz functions
notebooks - Rust & Python Jupyter notebooks with concept exercises and solutions

Note: If you're looking for a more efficient implementation of a concept (e.g., for use in your programs), other resources may be more useful.

Demos

ladderz Library Demo

`lz` CLI Demo

CLI Example

The lz CLI tool can be used to run ladderz functions from the command line. Built with the clap crate, users may select a subject and concept to run on their given input.

First let's install the lz CLI tool using Cargo:

cargo install --git https://github.com/rzmk/ladderz --branch main

You may read the help text for the lz CLI tool and its subcommands with a -h or --help flag. For example, to read the help text for the prealgebra subject run:

lz prealgebra -h

Now let's run the lz CLI tool with the prealgebra subject and get-factors concept as an example. We want to get the factors of the positive integer 12:

lz prealgebra get-factors 12

The printed output may be:

The factors of 12 are {2, 3, 6, 1, 4, 12}.

We can use the --raw flag to get the raw output of the function:

lz prealgebra get-factors 12 --raw

The printed raw output may be:

{1, 2, 3, 4, 6, 12}

Note that the numbers may not be sorted since the get_factors function implemented in the ladderz library returns a HashSet<u32>.

Library Example

Here's an example of using the ladderz crate to get the factors and factor pairs of a positive integer in sorted order.

First let's create a new Rust project and change into the project directory:

cargo new my_ladderz_project
cd my_ladderz_project

Then let's add the following to Cargo.toml under the [dependencies] section:

ladderz = { git = "https://github.com/rzmk/ladderz", branch = "main" }

Now in src/main.rs let's replace the contents with the following code:

use ladderz::prealgebra::{get_factors, get_factor_pairs};
use std::env;

fn main() {
    // Get user input as a Vec
    let args: Vec<String> = env::args().collect();

    // Check if input was provided
    match args.get(1) {
        Some(_) => {
            match args[1].parse::<u32>() {
                // Handle input that can be parsed as a u32
                Ok(x) => {
                    // Convert the HashSet of factors of input x to a sorted Vec
                    let mut factors: Vec<u32> = get_factors(x).into_iter().collect::<Vec<u32>>();
                    factors.sort();

                    // Convert the HashSet of factor pairs of input x to a sorted Vec
                    let mut factor_pairs: Vec<(u32, u32)> =
                        get_factor_pairs(x).into_iter().collect::<Vec<(u32, u32)>>();
                    factor_pairs.sort();

                    // Print the results
                    println!("List of factors of {:?}: {:?}", x, factors);
                    println!("List of factor pairs of {:?}: {:?}", x, factor_pairs);
                }
                // Handle input that can't be parsed as a u32
                Err(e) => println!("Error parsing input: {e}"),
            }
        }
        None => println!("No input provided."),
    }
}

Now let's build the project's binary file so we can run it from the command line:

cargo build --release

Our runnable binary file should be located at the local path ./target/release/my_ladders_project (or ./target/release/my_ladders_project.exe for Windows). Let's run it with the positive integer 12 as input:

./target/release/my_ladderz_project 12

If you have a .exe file instead, you can run it with:

./target/release/my_ladderz_project.exe 12

The printed output should be:

List of factors of 12: [1, 2, 3, 4, 6, 12]
List of factor pairs of 12: [(1, 12), (2, 6), (3, 4)]

We've successfully used the ladderz crate to get the factors and factor pairs of a positive integer in sorted order.

Ideas

Not currently implemented, but ideas that may be useful:

Extend to:
- Algebra
- Precalculus
- Calculus
- Linear Algebra
- Statistics
- Discrete Math
- Bioinformatics
ladderz-py - A package for running implementations of mathematical concepts in Python
ladderz-app - An interactive cross-platform (web, desktop, mobile) app potentially including visualizations, practice problems, & a course-like structure (potentially in Flutter or Tauri with Next.js & Rust)

rzmk/ladderz