180 |
181 |
182 |
183 |
--------------------------------------------------------------------------------
/evaluator.js:
--------------------------------------------------------------------------------
1 | /**
2 | * ####### # # ###### ###### ####### ##### ##### ### ####### # #
3 | * # # # # # # # # # # # # # # # ## #
4 | * # # # # # # # # # # # # # # # #
5 | * ##### # ###### ###### ##### ##### ##### # # # # # #
6 | * # # # # # # # # # # # # # # #
7 | * # # # # # # # # # # # # # # # ##
8 | * ####### # # # # # ####### ##### ##### ### ####### # #
9 | *
10 | * ####### # # # # # # # ####### ####### ######
11 | * # # # # # # # # # # # # # # #
12 | * # # # # # # # # # # # # # # #
13 | * ##### # # # # # # # # # # # # ######
14 | * # # # ####### # # # ####### # # # # #
15 | * # # # # # # # # # # # # # # #
16 | * ####### # # # ####### ##### # # # ####### # #
17 | */
18 |
19 | // We'll set the default environment to contain a few handy math constants
20 | const defaultEnvironment = {
21 | PI: Math.PI,
22 | E: Math.E,
23 | };
24 |
25 | // And then we'll initialize the current environment to the default
26 | let environment = { ...defaultEnvironment };
27 |
28 | /**
29 | * Returns an array of tokens from the input expression string.
30 | */
31 | function tokenize(input) {
32 | // First, we'll initialize a `scanner` index to track how much
33 | // of the input string we've covered
34 | let scanner = 0;
35 |
36 | // We'll also need an array to put the tokens we find
37 | const tokens = [];
38 |
39 | // While we haven't reached the end of the input...
40 | while (scanner < input.length) {
41 | // Get the next character
42 | const char = input[scanner];
43 |
44 | // If the character is a number...
45 | if (/[0-9]/.test(char)) {
46 | // Create a string to hold all the digits in the number
47 | let digits = '';
48 |
49 | // While we have more digits (or a period) in the number and we haven't
50 | // gotten to the end of the input...
51 | while (scanner < input.length && /[0-9\.]/.test(input[scanner])) {
52 | // Collect all the digits
53 | digits += input[scanner++];
54 | }
55 |
56 | // Convert the digits to a number and push the number to the array of tokens
57 | const number = parseFloat(digits);
58 | tokens.push(number);
59 | continue;
60 | }
61 |
62 | // If the character is a symbol...
63 | if (/[+\-/*(),^<>=]/.test(char)) {
64 | // Push it to the array of tokens
65 | tokens.push(char);
66 | scanner++;
67 | continue;
68 | }
69 |
70 | // If the character is white space...
71 | if (char === ' ') {
72 | // Ignore it
73 | scanner++;
74 | continue;
75 | }
76 |
77 | // If the character is the first character of a name,
78 | // like the name of a function or variable or variable pointer
79 | if (/[A-Z$#]/.test(char)) {
80 | // Create a string to hold all the characters in the name
81 | let name = '';
82 |
83 | // While we have more characters that make up the name and we haven't
84 | // gotten to the end of the input...
85 | while (scanner < input.length && /[A-Z$#]/.test(input[scanner])) {
86 | // Collect all the characters in the name
87 | name += input[scanner++];
88 | }
89 |
90 | // Then push the full name to the array of tokens
91 | tokens.push(name);
92 | continue;
93 | }
94 |
95 | // If we can't recognize the character, we'll throw an error
96 | throw new Error(`Invalid token ${char} at position ${scanner}`);
97 | }
98 |
99 | // After collecting all the tokens in the expression, we'll return them
100 | return tokens;
101 | }
102 |
103 | /**
104 | * Converts the tokens in infix notation to Reverse Polish notation
105 | */
106 | function toRPN(tokens) {
107 | // First, we'll set up a stack to hold operators we're not yet ready to
108 | // add to the final expression
109 | const operators = [];
110 |
111 | // ...and an array to hold the final RPN expression
112 | const out = [];
113 |
114 | // For each token in the infix expression...
115 | for (let i = 0; i < tokens.length; i++) {
116 | const token = tokens[i];
117 |
118 | // If the token is a number...
119 | if (typeof token === 'number' || /^[$#]/.test(token)) {
120 | // We'll push it to `out`
121 | out.push(token);
122 | continue;
123 | }
124 |
125 | // If the token is an operator or a function name...
126 | if (/[+\-/*<>=^A-Z]/.test(token)) {
127 | // While there are operators in the `operators` stack with a higher
128 | // precedence than the current token, we'll unwind them `operators` on to `out`
129 | while (shouldUnwindOperatorStack(operators, token)) {
130 | out.push(operators.pop());
131 | }
132 |
133 | // And then, push the current token to the `operators` stack
134 | operators.push(token);
135 | continue;
136 | }
137 |
138 | // If the token is a left parenthesis symbol...
139 | if (token === '(') {
140 | // We'll push it to the `operators` stack
141 | operators.push(token);
142 | continue;
143 | }
144 |
145 | // If the token is a right parenthesis symbol...
146 | if (token === ')') {
147 | // While there are operators in the `operators` stack, and we haven't reached the
148 | // last left parenthesis symbol, we'll unwind them on to `out`
149 | while (operators.length > 0 && operators[operators.length - 1] !== '(') {
150 | out.push(operators.pop());
151 | }
152 |
153 | // We no longer need the left parenthesis symbol, so we'll discard it
154 | operators.pop();
155 | continue;
156 | }
157 |
158 | // If the token is a comma...
159 | if (token === ',') {
160 | // While there are operators in the `operators` stack, and we haven't reached the
161 | // last left parenthesis symbol, we'll unwind them on to `out`
162 | while (operators.length > 0 && operators[operators.length - 1] !== '(') {
163 | out.push(operators.pop());
164 | }
165 | continue;
166 | }
167 |
168 | // If we can't recognize the token, we'll throw an error
169 | throw new Error(`Invalid token ${token}`);
170 | }
171 |
172 | // Finally we'll unwind all the remaining operators on to `out`
173 | for (let i = operators.length - 1; i >= 0; i--) {
174 | out.push(operators[i]);
175 | }
176 |
177 | // And then return `out`
178 | return out;
179 | }
180 |
181 | // BODMAS, PEMDAS
182 | // Exponentiation > [multiplication, division] > [addition, subtraction]
183 | const precedence = {
184 | '^': 3,
185 | '*': 2,
186 | '/': 2,
187 | '+': 1,
188 | '-': 1,
189 | };
190 |
191 | // Returns true if the topmost operator in the `operators` stack has a
192 | // precedence higher than or equal to the precedence of `nextToken`
193 | function shouldUnwindOperatorStack(operators, nextToken) {
194 | if (operators.length === 0) {
195 | return false;
196 | }
197 |
198 | const lastOperator = operators[operators.length - 1];
199 | return /[A-Z]/.test(lastOperator) || (precedence[lastOperator] && precedence[lastOperator] >= precedence[nextToken]);
200 | }
201 |
202 | /**
203 | * Evaluates the RPN expression
204 | */
205 | function evalRPN(rpn) {
206 | const stack = [];
207 |
208 | // For each token in the RPN expression...
209 | for (let i = 0; i < rpn.length; i++) {
210 | const token = rpn[i];
211 |
212 | // If the token is an operator...
213 | if (/[+\-/*^<>=]/.test(token)) {
214 | // Operate on the stack and push the result back on to the stack
215 | stack.push(operate(token, stack));
216 | continue;
217 | }
218 |
219 | // If the token is a variable...
220 | if (/^\$/.test(token)) {
221 | // We'll try to get its value from the environment (remember to skip the '$' character)
222 | const value = environment[token.slice(1)];
223 |
224 | // If the variable has not been set in the environment, we'll throw an error
225 | if (value === undefined) {
226 | throw new Error(`${token} is undefined`);
227 | }
228 |
229 | // But if it has, we'll push the value to the stack
230 | stack.push(value);
231 | continue;
232 | }
233 |
234 | // If the token is a function name...
235 | if (/^[A-Z]/.test(token)) {
236 | // Apply the function on the stack and push the result to the stack
237 | stack.push(apply(token, stack));
238 | continue;
239 | }
240 |
241 | // If the token is a number or a variable pointer, push it to the stack
242 | if (typeof token === 'number' || /^\#/.test(token)) {
243 | stack.push(token);
244 | continue;
245 | }
246 |
247 | // If we can't recognize the token, we'll throw an error
248 | throw new Error(`Invalid token ${token}`);
249 | }
250 |
251 | // The value left on the stack is the final result of the evaluation
252 | return stack.pop();
253 | }
254 |
255 | /**
256 | * Returns the result of appyling the mathematical operator on the stack.
257 | * The operator here is either an arithmetic or a logical operator, so we
258 | * only need two operands from the stack for any operator.
259 | */
260 | function operate(operator, stack) {
261 | const b = stack.pop();
262 | const a = stack.pop();
263 |
264 | switch (operator) {
265 | case '+':
266 | return a + b;
267 | case '-':
268 | return a - b;
269 | case '*':
270 | return a * b;
271 | case '/':
272 | return a / b;
273 | case '^':
274 | return Math.pow(a, b);
275 | case '<':
276 | return a < b;
277 | case '>':
278 | return a > b;
279 | case '=':
280 | return a === b;
281 | default:
282 | throw new Error(`Invalid operator: ${operator}`);
283 | }
284 | }
285 |
286 | /**
287 | * Returns the result of applying the function onto the stack.
288 | *
289 | * Functions may have any number of arguments. But each function must have a
290 | * definite number of arguments. i.e. X(a, b) and Y(a, b, c) are possible, but
291 | * X(a, b) and X(a, b, c) are not possible.
292 | *
293 | * The function arguments are in right-to-left order in the stack, i.e. the rightmost
294 | * argument is at the top of the stack, and so on.
295 | */
296 | function apply(func, stack) {
297 | // MAX(a, b) returns the larger of a and b
298 | if (func === 'MAX') {
299 | const b = stack.pop();
300 | const a = stack.pop();
301 | return Math.max(a, b);
302 | }
303 |
304 | // SQRT(a) returns the square-root of a
305 | if (func === 'SQRT') {
306 | const a = stack.pop();
307 | return Math.sqrt(a);
308 | }
309 |
310 | // IF(a, b, c) returns b if a is true. Else, it returns c
311 | if (func === 'IF') {
312 | const ifFalse = stack.pop();
313 | const ifTrue = stack.pop();
314 | const predicate = stack.pop();
315 | return predicate ? ifTrue : ifFalse;
316 | }
317 |
318 | // SET(#a, b) sets the variable a to the value b
319 | if (func === 'SET') {
320 | const value = stack.pop();
321 | const key = stack.pop();
322 | environment[key.slice(1)] = value;
323 | return value;
324 | }
325 |
326 | // If we can't recognize the function, we'll throw an error
327 | throw new Error(`Undefined function: ${func}`);
328 | }
329 |
330 | /**
331 | * Finally, in the `evaluator` function, we'll link all stages
332 | * of the evaluation together.
333 | *
334 | * tokenize -> toRPN -> evalRPN
335 | */
336 | function evaluate(input) {
337 | return evalRPN(toRPN(tokenize(input)));
338 | }
339 |
340 | /**
341 | * Resets the environment back to the default
342 | */
343 | function reset() {
344 | environment = { ...defaultEnvironment };
345 | }
346 |
347 | module.exports = {
348 | tokenize,
349 | toRPN,
350 | evalRPN,
351 | evaluate,
352 | reset,
353 | environment,
354 | };
355 |
--------------------------------------------------------------------------------