FormulaParser


A parser class for simple formulae, like those of algebra and propositional logic.
Produces ASTs in JSON format.

The algorithm is a fully-immutable JavaScript adaptation of
precedence climbing.

Install

``sh
npm install formula-parser
`

ES module:
`js
import FormulaParser from 'formula-parser';
`

Node:
`js
const FormulaParser = require('formula-parser');
`

Browser:
`html

`

Usage

$3

FormulaParser is a parser class for _operator-precedence languages_, i.e.,
context-free languages
which have only variables, (prefix) unary operators, and (infix) binary operators.

This restriction means that the grammar for a parser instance is wholly specified
by the operator definitions (and a key with which to label variable nodes).

$3

As the algebraParser example demonstrates,
an _operator definition_ is an object like the following:
`js
{ symbol: '+', key: 'plus', precedence: 1, associativity: 'left' }
`
It specifies a symbol, a key for its AST node,
a precedence level, and (for binaries) an associativity direction.

Once the definitions are assembled, creating a parser instance is straightforward:
`js
const algebraParser = new FormulaParser(variableKey, unaries, binaries);
`

$3

After creating a FormulaParser instance, calling its parse method will produce an AST for a formula:
`js
algebraParser.parse('(a + b * c) ^ -d');
`
→
`json
{ "exp": [
{ "plus": [
{ "var": "a" },
{ "mult": [
{ "var": "b" },
{ "var": "c" }
]}
]},
{ "neg": { "var": "d" } }
]}
`

Limitations (presumed and actual)

$3

Technically, constants aren't supported—the leaves of the formula are all treated as variables,
the values of which are to be evaluated at some post-parse stage.

That said, since a "variable" for present purposes is any alphanumeric string (including underscores),
'true', 'PI', and even '3' will all be happily parsed as such.
(_Of course, numbers in decimal notation will fail._)

$3

Function symbols aren't explicitly supported either, but they can be simulated by operator symbols.
Specifying sin as a unary symbol will accept sin x or sin(x),
while specifying mod as a binary symbol will accept x mod y`.

$3

Unfortunately, this one's hard and fast:
Unary symbols _must_ be in prefix notation and binary symbols _must_ be in infix notation.