mirror of
https://github.com/rzmk/ladderz.git
synced 2025-12-19 06:59:25 +00:00
155 lines
4.7 KiB
Markdown
155 lines
4.7 KiB
Markdown
# ladderz
|
|
|
|
The `ladderz` project is a collection of math and tech concepts implemented in code.
|
|
|
|
- **[`ladderz` library](https://rzmk.github.io/ladderz/)** - A Rust library for running concept implementations
|
|
- **[`lz` CLI](lz)** - A command line tool for running ladderz functions
|
|
- **[notebooks](notebooks)** - Jupyter notebooks with concept exercises and solutions in Python
|
|
|
|
> 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
|
|
|
|
### `lz` CLI Demo
|
|
|
|
### ladderz Library Demo
|
|
|
|
## CLI Example
|
|
|
|
The `lz` CLI tool can be used to run ladderz functions from the command line. Built with the [clap](https://clap.rs) crate, users may select a subject and concept to run on their given input.
|
|
|
|
First let's install the `lz` CLI tool using [Cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html):
|
|
|
|
```bash
|
|
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:
|
|
|
|
```bash
|
|
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`:
|
|
|
|
```bash
|
|
lz prealgebra get-factors 12
|
|
```
|
|
|
|
The printed output should be:
|
|
|
|
```console
|
|
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:
|
|
|
|
```bash
|
|
lz prealgebra get-factors 12 --raw
|
|
```
|
|
|
|
The printed output should be:
|
|
|
|
```console
|
|
{1, 2, 3, 4, 6, 12}
|
|
```
|
|
|
|
Note that the numbers may not be sorted.
|
|
|
|
## 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:
|
|
|
|
```bash
|
|
cargo new my_ladderz_project
|
|
cd my_ladderz_project
|
|
```
|
|
|
|
Then let's add the following to `Cargo.toml` under the `[dependencies]` section:
|
|
|
|
```toml
|
|
ladderz = { git = "https://github.com/rzmk/ladderz", branch = "main" }
|
|
```
|
|
|
|
Now in `src/main.rs` let's replace the contents with the following code:
|
|
|
|
```rust
|
|
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:
|
|
|
|
```bash
|
|
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:
|
|
|
|
```bash
|
|
./target/release/my_ladderz_project 12
|
|
```
|
|
|
|
If you have a `.exe` file instead, you can run it with:
|
|
|
|
```bash
|
|
./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
|
|
- Algorithms
|
|
- 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)
|