The Shunting Yard algorithm, implemented in Rust.
This is me experimenting with Rust (I love it so far). As such, the code quality may be questionable and not 100% idiomatic Rust.
You can instantiate a ShuntingYard instance with an expression and call its calculate method, which returns an Option<f64>. An example would be:
``` extern crate rustyard;
fn main() { let yard = rustyard::ShuntingYard::new("2 + 4 * 3");
// This prints "The result is: 14"
println!("The result is: {}", yard.calculate().unwrap());
} ```
The implementation accepts the 4 basic mathematical operators and parenthesis. It also considers all input to be floating point. Some examples are below:
Basic addition:
Simon$ cargo run --example main "2 + 4"
Input is: 2 + 4
Lexer result: 2 + 4
Shunting Yard result: 2 4 +
Equation equals: 6
Floating point:
Simon$ cargo run --example main "1.75 * 2"
Input is: 1.75 * 2
Lexer result: 1.75 * 2
Shunting Yard result: 1.75 2 *
Equation equals: 3.5
Operator precedence:
Simon$ cargo run --example main "2 + 4 * 3"
Input is: 2 + 4 * 3
Lexer result: 2 + 4 * 3
Shunting Yard result: 2 4 3 * +
Equation equals: 14
Parenthesis:
Simon$ cargo run --example main "(2 + 4) * 3"
Input is: (2 + 4) * 3
Lexer result: ( 2 + 4 ) * 3
Shunting Yard result: 2 4 + 3 *
Equation equals: 18
Errors:
Simon$ cargo run --example main "4 / (2 + 3"
Input is: 4 / (2 + 3
Errors:
ERR: Unbalanced parenthesis
Simon$ cargo run --example main "a + b * c"
Input is: a + b * c
Errors:
ERR: Unknown identifier: a
ERR: Unknown identifier: b
ERR: Unknown identifier: c
You're free to use this as you see fit. Some acknowledgement would be nice if you feel like doing so.