More benchmarks, update readme

Author: yds12

.github/workflows/bench.yml

@@ -10,9 +10,9 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  build:
+  benchmarks:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
     - name: Run benchmarks
-      run: cargo bench
+      run: cargo bench -- bench_cmp

.github/workflows/unit.yml

@@ -1,4 +1,4 @@
-name: Unit Test
+name: Unit Tests
 
 on:
   push:
@@ -10,7 +10,7 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  build:
+  unit_tests:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

README.md

@@ -10,17 +10,24 @@
         let forty_six = eval("(5 * 8) + 6").unwrap();
         let two = eval("1 + 1").unwrap();
         println!("{} & {}", forty_six, two);
+
+        assert_eq!(forty_six, 46.0);
+        assert_eq!(two, 2.0);
     }
 
+Note: the above `assert_eq`s work, but for float comparison in general use a
+crate such as `float-cmp`.
+
 ## Why?
 
 If you need to evaluate simple arithmetic expressions, this crate offers a fast
 and lightweight solution.
 
-It's about 4-10x faster than `meval` and about 2x faster than `fasteval`, but
-there are still optimisations to come, which will make it even faster. Note that
-those crates do much more than `mexe`. Our focus on a very small problem makes
-it easier for us to ship a fast and lean library.
+In our [current benchmarks](https://github.com/yds12/mexe/actions/workflows/bench.yml),
+it's about 4-10x faster than `meval` and about 2x
+faster than `fasteval`, but there are still optimisations to come, which will
+make it even faster. Note that those crates do much more than `mexe`. Our focus
+on a very small problem makes it easier for us to ship a fast and lean library.
 
 ## Includes
 
@@ -41,12 +48,25 @@ it easier for us to ship a fast and lean library.
 - We can assume the input is ASCII, and throw an error otherwise
 - Thoroughly tested
 - Maybe try to make it no-std
-- Having fun
+
+## Run Tests and Benchmarks
+
+Unit tests:
+
+    cargo test
+
+Benchmarks:
+
+    cargo bench -- bench_cmp   # comparison with other crates
+    cargo bench -- bench_mexe  # only mexe
+
+Fuzz tests have been ran with [cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz).
 
 ## Similar Projects
 
+- [meval](https://crates.io/crates/meval)
+- [fasteval](https://crates.io/crates/fasteval)
 - [pmalmgren/rust-calculator](https://github.com/pmalmgren/rust-calculator)
-- [rekka/meval-rs](https://github.com/rekka/meval-rs)
 - [adriaN/simple_rust_parser](https://github.com/adrianN/simple_rust_parser)
 
 ## Grammar

benches/benchmarks.rs

@@ -1,42 +1,54 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, black_box};
 
 macro_rules! float_eq {
     ($op1:expr, $op2:expr) => {
         assert!(float_cmp::approx_eq!(f64, $op1, $op2));
     };
 }
 
-fn bench_eval(c: &mut Criterion) {
-    let expressions = [
+const EXPRESSIONS: [&str; 10] = [
         "1 + 2",
-        "4 * 3",
-        "12.837/8.3",
-        "2 * (1.5 - 6)",
-        "(1.5 / (2 + 3 * 0.1) + 6) * 3",
-        "(2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) - 1.1",
-        "(2 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * (((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) * (2 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * (((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) - 1.1",
+        "2 * 3",
+        "3/8.3",
+        "4 * (1.5 - 6)",
+        "(5 / (2 + 3 * 0.1) + 6) * 3",
+        "(6 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) - 1.1",
+        "(7 * (((1.5 * (0.7 - 0.33 + (6.00 * 0.05))) / (2.5 + 3 * 0.1) + 6) * 3)) - 1.1",
+        "((8 + 7.07) * ((((1.5 - 0.001 + 0.005) * (0.7 - 0.33 + (6.00 * 0.05))) / (2.5 + 3 * 0.1) + 6) * 3)) - 1.1",
+        "((9 + 7.07) * ((((1.5 - 0.001 + 0.005) * (0.7 - 0.33 + (6.00 * 0.05))) / (2.5 + 3 * 0.1) + 6) * 3)) - 1.1 * (1.00 * 2838.88736 * 3 / (6 - 2))",
+        "(10 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * (((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) * (2 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * (((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + (2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3))) * 3)) / ((2 * (((2 * ((1.5 / (2 + 3 * 0.1) + 6) * 3)) / (2 + 3 * 0.1) + 6) * 3)) * 2 + 3 * 0.1) + 6) * 3)) - 1.1",
     ];
 
+fn bench_mexe(c: &mut Criterion) {
+    for expr in EXPRESSIONS.iter() {
+        dbg!(mexe::eval(expr));
+        float_eq!(mexe::eval(expr).unwrap(), meval::eval_str(expr).unwrap());
+        let bench_id = format!("bench_mexe {}", expr);
+        c.bench_function(&bench_id, |b| b.iter(|| mexe::eval(black_box(expr))));
+    }
+}
+
+fn bench_cmp(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench_eval");
 
-    for expr in expressions.iter() {
+    for expr in EXPRESSIONS.iter() {
         dbg!(mexe::eval(expr));
         dbg!(meval::eval_str(expr));
         dbg!(fasteval::ez_eval(expr, &mut fasteval::EmptyNamespace));
         float_eq!(mexe::eval(expr).unwrap(), meval::eval_str(expr).unwrap());
 
-        group.bench_with_input(BenchmarkId::new("mexe", expr), expr, |b, &expr| {
+        group.bench_with_input(BenchmarkId::new("bench_cmp mexe", expr), expr, |b, &expr| {
             b.iter(|| mexe::eval(expr));
         });
-        group.bench_with_input(BenchmarkId::new("meval", expr), expr, |b, &expr| {
+        group.bench_with_input(BenchmarkId::new("bench_cmp meval", expr), expr, |b, &expr| {
             b.iter(|| meval::eval_str(expr));
         });
-        group.bench_with_input(BenchmarkId::new("fasteval", expr), expr, |b, &expr| {
+        group.bench_with_input(BenchmarkId::new("bench_cmp fasteval", expr), expr, |b, &expr| {
             b.iter(|| fasteval::ez_eval(expr, &mut fasteval::EmptyNamespace));
         });
     }
     group.finish();
 }
 
-criterion_group!(benches, bench_eval);
+criterion_group!(benches, bench_cmp, bench_mexe);
 criterion_main!(benches);