113 lines
2.6 KiB
JavaScript
113 lines
2.6 KiB
JavaScript
function isLeftAssociative(op) {
|
|
return op === "+" || op === "-" || op === "*" || op === "/";
|
|
}
|
|
|
|
function popOps(opstack, queue, op, powInStack) {
|
|
const prec = {"+": 1, "-": 1, "*": 2, "/": 2, "u": 3, "^": 3}
|
|
while (opstack.length > 0) {
|
|
const op2 = opstack.at(-1);
|
|
if (op2 === "(") {
|
|
break;
|
|
}
|
|
|
|
if ((prec[op2] > prec[op]) || (prec[op2] === prec[op] && isLeftAssociative(op))) {
|
|
opstack.pop();
|
|
queue.push(op2);
|
|
if (op2 === "^") {
|
|
powInStack = false;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// practically, we want 2^(3+4) mod 7 to evaluate to 2^7 mod 7 = 2
|
|
// however, since our operators are all modular, this would instead
|
|
// evaluate as 2^0 mod 7 = 1
|
|
// rather than complicate things by evaluating exponent expressions
|
|
// normally instead of modularly (and consequently needing to deal with
|
|
// fractions) we simply require exponents to be integers
|
|
// NOTE: as written this allows for the exponent to be a function, not
|
|
// sure if that should change or not
|
|
if (powInStack && op !== "u") {
|
|
throw new Error("exponent must be an integer, not an expression");
|
|
}
|
|
|
|
return powInStack;
|
|
}
|
|
|
|
function popBetweenParens(opstack, queue, powInStack) {
|
|
while (opstack.at(-1) !== "(") {
|
|
if (opstack.length === 0) {
|
|
throw new Error("mismatched parentheses");
|
|
}
|
|
|
|
const op = opstack.pop();
|
|
if (op === "^") {
|
|
powInStack = false;
|
|
}
|
|
queue.push(op);
|
|
}
|
|
|
|
opstack.pop();
|
|
const t = opstack.at(-1);
|
|
if (t === "sqrt" || t === "ord") {
|
|
const func = opstack.pop();
|
|
queue.push(func);
|
|
}
|
|
return powInStack;
|
|
}
|
|
|
|
function empty(opstack, queue) {
|
|
while (opstack.length !== 0) {
|
|
const op = opstack.pop();
|
|
if (op === "(") {
|
|
throw new Error("mismatched parentheses");
|
|
}
|
|
|
|
queue.push(op);
|
|
}
|
|
}
|
|
|
|
function isUnaryMinus(token, lastToken) {
|
|
return token === "-" && (lastToken === null || /[(-+*/^]/.test(lastToken));
|
|
}
|
|
|
|
function shunt(tokens) {
|
|
const queue = [];
|
|
const opstack = [];
|
|
let lastToken = null;
|
|
let powInStack = false;
|
|
for (let token of tokens) {
|
|
if (typeof token === "bigint") {
|
|
queue.push(token);
|
|
} else if (/[-+*/^]/.test(token)) {
|
|
if (isUnaryMinus(token, lastToken)) {
|
|
token = "u";
|
|
}
|
|
|
|
powInStack = popOps(opstack, queue, token, powInStack);
|
|
|
|
opstack.push(token);
|
|
if (token === "^") {
|
|
powInStack = true;
|
|
}
|
|
} else if (token === "(") {
|
|
opstack.push(token);
|
|
} else if (token === ")") {
|
|
powInStack = popBetweenParens(opstack, queue, powInStack);
|
|
} else if (token === "sqrt") {
|
|
opstack.push(token);
|
|
} else if (token === "ord") {
|
|
opstack.push(token);
|
|
}
|
|
|
|
lastToken = token;
|
|
}
|
|
|
|
empty(opstack, queue);
|
|
return queue;
|
|
}
|
|
|
|
export { shunt };
|