eqrs 0.1.1

Zero-dependency math expression evaluator with variables
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::{
    helpers::find_closing_par,
    tokenize::{operator::Op, token::Token},
};

pub fn post_process(vec: &Vec<Token>) -> Vec<Token> {
    let mut vec = vec.clone();

    let mut i = 0;

    // "-n" --> "(0-n)"
    // "-(...)" --> "(0-(...))"
    while i < vec.len() - 1 {
        if let Token::Op(Op::Sub) = vec[i] {
            if i == 0 || matches!(vec[i - 1], Token::Op(_)) || matches!(vec[i - 1], Token::ParL) {
                vec.insert(i, Token::Num(0.0));
                vec.insert(i, Token::ParL);
                vec.insert(
                    if matches!(vec[i + 3], Token::ParL) {
                        find_closing_par(&vec, i + 3).expect("failed to find closing parenthesis")
                    } else {
                        i + 4
                    },
                    Token::ParR,
                );
            }
        }

        i += 1;
    }

    // insert multiply between Nx, xN, xy, x(, )x, N(, )N, and )(
    i = 0;
    while i < vec.len() - 1 {
        match (vec[i], vec[i + 1]) {
            (Token::Num(_), Token::Var(_))
            | (Token::Var(_), Token::Num(_))
            | (Token::Var(_), Token::Var(_))
            | (Token::Var(_), Token::ParL)
            | (Token::ParR, Token::Var(_))
            | (Token::Num(_), Token::ParL)
            | (Token::ParR, Token::Num(_))
            | (Token::ParR, Token::ParL) => {
                vec.insert(i + 1, Token::Op(Op::Mul));
            }
            _ => {}
        }

        i += 1;
    }

    vec
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::tokenize::{operator::Op, token::Token, tokenize};

    #[test]
    fn post_process_1() {
        assert_eq!(
            post_process(&tokenize("2 + 2").unwrap()),
            vec![Token::Num(2.0), Token::Op(Op::Add), Token::Num(2.0)]
        );
    }

    #[test]
    fn post_process_2() {
        assert_eq!(
            post_process(&tokenize("2 + 2 * 9 - 8").unwrap()),
            vec![
                Token::Num(2.0),
                Token::Op(Op::Add),
                Token::Num(2.0),
                Token::Op(Op::Mul),
                Token::Num(9.0),
                Token::Op(Op::Sub),
                Token::Num(8.0)
            ]
        );
    }

    #[test]
    fn post_process_3() {
        assert_eq!(
            post_process(&tokenize("x(7xy + 6) * 3y^2").unwrap()),
            vec![
                Token::Var('x'),
                Token::Op(Op::Mul),
                Token::ParL,
                Token::Num(7.0),
                Token::Op(Op::Mul),
                Token::Var('x'),
                Token::Op(Op::Mul),
                Token::Var('y'),
                Token::Op(Op::Add),
                Token::Num(6.0),
                Token::ParR,
                Token::Op(Op::Mul),
                Token::Num(3.0),
                Token::Op(Op::Mul),
                Token::Var('y'),
                Token::Op(Op::Pow),
                Token::Num(2.0)
            ]
        );
    }

    #[test]
    fn post_process_4() {
        assert_eq!(
            post_process(&tokenize("2x + 3(4 + 5)").unwrap()),
            vec![
                Token::Num(2.0),
                Token::Op(Op::Mul),
                Token::Var('x'),
                Token::Op(Op::Add),
                Token::Num(3.0),
                Token::Op(Op::Mul),
                Token::ParL,
                Token::Num(4.0),
                Token::Op(Op::Add),
                Token::Num(5.0),
                Token::ParR
            ]
        );
    }

    #[test]
    fn post_process_5() {
        assert_eq!(
            post_process(&tokenize("-(3 + 4)").unwrap()),
            vec![
                Token::ParL,
                Token::Num(0.0),
                Token::Op(Op::Sub),
                Token::ParL,
                Token::Num(3.0),
                Token::Op(Op::Add),
                Token::Num(4.0),
                Token::ParR,
                Token::ParR
            ]
        );
    }
}