val 0.3.6

An arbitrary precision calculator language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use {
  criterion::{Criterion, black_box, criterion_group, criterion_main},
  val::{Environment, Evaluator},
};

fn bench_recursive_factorial(criterion: &mut Criterion) {
  let mut group = criterion.benchmark_group("recursive_factorial");

  for &number in &[10_u32, 50, 100, 500] {
    let program = format!(
      "fn f(x) {{ if ( x <= 1) {{ return 1 }} else {{ return x * f(x - 1) }} }} f({number})"
    );

    let ast = val::parse(&program).unwrap();

    group.bench_function(format!("n = {number}"), |bencher| {
      bencher.iter(|| {
        black_box(Evaluator::from(Environment::default()).eval(&ast)).unwrap();
      })
    });
  }

  group.finish();
}

fn bench_prime_count(criterion: &mut Criterion) {
  let mut group = criterion.benchmark_group("prime_count");

  for &number in &[5_000_u32, 10_000_u32] {
    let program = format!(
      r#"
      fn prime(n) {{
        if (n < 2) {{
          return false
        }}

        i = 2

        while (i * i <= n) {{
          if (n % i == 0) {{
            return false
          }}

          i = i + 1
        }}

        return true
      }}

      fn count(limit) {{
        count = 0

        i = 2

        while (i <= limit) {{
          if (prime(i)) {{
            count = count + 1
          }}

          i = i + 1
        }}

        return count
      }}

      count({number})
      "#
    );

    let ast = val::parse(&program).unwrap();

    group.bench_function(format!("n = {number}"), |bencher| {
      bencher.iter(|| {
        black_box(Evaluator::from(Environment::default()).eval(&ast)).unwrap();
      });
    });
  }

  group.finish();
}

criterion_group!(benches, bench_recursive_factorial, bench_prime_count);

criterion_main!(benches);