A guide on breaking down complex mathematical expressions with arrays using javascript

Question

A guide on breaking down complex mathematical expressions with arrays using javascript

I am looking to store various mathematical expressions that involve basic operations such as addition, subtraction, multiplication, division, exponents, square roots, grouping, etc., along with unique placeholders in the form of a string.

const json = {
  “formula”: “{{a45bc2a1-ed82-4ccd-a455-f7959e875aad}}+({{f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9}}*{{335563ad-a715-47b9-8e54-2b8553768168}})”
}

The placeholders correspond to arrays like so:

const map = {
  “a45bc2a1-ed82-4ccd-a455-f7959e875aad”: [1, 2, 3, 4, 5],
  “f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9”: [10, 20, 30, 40, 50],
  “335563ad-a715-47b9-8e54-2b8553768168”: [1, 2, 3, 4, 5]
}

Is there a way to accomplish this? The eval() function is not suitable for vector operations and I am uncertain about how to parse arbitrary formulas for element-wise calculations.

The expected output should be:

[11, 42, 93, 164, 255]

javascript arrays eval

Answer 1

Answer №1

As you embark on the journey of creating your own programming language, it becomes essential to have a compiler (which translates string expressions into an Abstract Syntax Tree) and a runtime (responsible for evaluating the AST with given inputs and predefined bindings). Below is a snippet of code to kickstart your project. It has limited support for grammar

expression = term | term op expression

and lacks error handling:

// "compiler"

function parse(str) {
    return expr([...str])
}

function expr(chars) {
    let node = term(chars)
    if (chars.length)
        node = {
            op: chars.shift(),
            left: node,
            right: expr(chars)
        }
    return node
}

function term(chars) {
    let str = ''
    while (chars.length && chars[0].match(/\w/))
        str += chars.shift()
    return {value: str}
}

// "runtime"

ops = {
    '+': (a, b) => a + b,
    '-': (a, b) => a - b,
}

function evaluate(node, bindings) {
    if (node.value)
        return bindings[node.value]
    return eval_op(
        node.op,
        evaluate(node.left, bindings),
        evaluate(node.right, bindings))
}

function eval_op(op, left, right) {
    let fn = ops[op]
    return left.map((_, i) => fn(left[i], right[i]))
}

// demo

input = 'abc+def+xyz'
bindings = {
    'abc': [1, 2, 3],
    'def': [4, 5, 6],
    'xyz': [7, 8, 9],
}

ast = parse(input)
console.log('AST', ast)
res = evaluate(ast, bindings)
console.log('RESULT', res)

Transforming this prototype into fully functional code requires further effort. I recommend delving deeper into formal grammars, parsers, and parser generators to enhance your understanding.

Answer 2

As you embark on the journey of creating your own programming language, it becomes essential to have a compiler (which translates string expressions into an Abstract Syntax Tree) and a runtime (responsible for evaluating the AST with given inputs and predefined bindings). Below is a snippet of code to kickstart your project. It has limited support for grammar

expression = term | term op expression

and lacks error handling:

// "compiler"

function parse(str) {
    return expr([...str])
}

function expr(chars) {
    let node = term(chars)
    if (chars.length)
        node = {
            op: chars.shift(),
            left: node,
            right: expr(chars)
        }
    return node
}

function term(chars) {
    let str = ''
    while (chars.length && chars[0].match(/\w/))
        str += chars.shift()
    return {value: str}
}

// "runtime"

ops = {
    '+': (a, b) => a + b,
    '-': (a, b) => a - b,
}

function evaluate(node, bindings) {
    if (node.value)
        return bindings[node.value]
    return eval_op(
        node.op,
        evaluate(node.left, bindings),
        evaluate(node.right, bindings))
}

function eval_op(op, left, right) {
    let fn = ops[op]
    return left.map((_, i) => fn(left[i], right[i]))
}

// demo

input = 'abc+def+xyz'
bindings = {
    'abc': [1, 2, 3],
    'def': [4, 5, 6],
    'xyz': [7, 8, 9],
}

ast = parse(input)
console.log('AST', ast)
res = evaluate(ast, bindings)
console.log('RESULT', res)

Transforming this prototype into fully functional code requires further effort. I recommend delving deeper into formal grammars, parsers, and parser generators to enhance your understanding.

Answer 3

Answer №2

Iterate through the array indices, and substitute the placeholders with the current index in the corresponding part of map. Next, execute the eval() function.

let length = Object.values(json.formula)[0].length;
for (let j = 0; j < len; j++) {
    let formula = json.formula.replace(/{{([-\w]+)}}/g, (match, placeholder) => map[placeholder][j];
    console.log(eval(formula));
}

Answer 4

Iterate through the array indices, and substitute the placeholders with the current index in the corresponding part of map. Next, execute the eval() function.

let length = Object.values(json.formula)[0].length;
for (let j = 0; j < len; j++) {
    let formula = json.formula.replace(/{{([-\w]+)}}/g, (match, placeholder) => map[placeholder][j];
    console.log(eval(formula));
}

Answer 5

Answer №3

After experimenting for some time today, I managed to develop a functioning version that eliminates the need for defining a formal AST. This implementation solely relies on eval() to create an arrow function responsible for calculating each index of the output based on input lists and an increasing input index.

'use strict';
const json={
    formula: '{{a45bc2a1-ed82-4ccd-a455-f7959e875aad}}+({{f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9}}*{{335563ad-a715-47b9-8e54-2b8553768168}})'
}

const map = {
    'a45bc2a1-ed82-4ccd-a455-f7959e875aad': [1, 2, 3, 4, 5],
    'f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9': [10, 20, 30, 40, 50],
    '335563ad-a715-47b9-8e54-2b8553768168': [1, 2, 3, 4, 5]
}

function parseFormula (formula) {
    const template = /{{([^}]*)}}/;
    const idList = [];
    for (let i = 0; template.test(formula); i++) {
        idList.push(formula.match(template)[0].replace(/[{}]/g, ''));
        formula = formula.replace(template, `input[${i}][i]`);
    }
    return {idList, formula};
}

function calculateFormula(map, parsed) {
    const input = [];
    const result = [];
    const lambda = eval(`(input, i) => ${parsed.formula}`)
    parsed.idList.forEach(id => input.push(map[id]));
    for (let i = 0; i < input[0].length; i++) {
        result.push(lambda(input, i));
    }
    return result;
}

const parsed = parseFormula(json.formula);
console.log(parsed);
console.log(calculateFormula(map, parsed));

Output:

{
  idList: [
    'a45bc2a1-ed82-4ccd-a455-f7959e875aad',       
    'f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9',       
    '335563ad-a715-47b9-8e54-2b8553768168'        
  ],
  formula: 'input[0][i]+(input[1][i]*input[2][i])'
}
[ 11, 42, 93, 164, 255 ]

Answer 6

After experimenting for some time today, I managed to develop a functioning version that eliminates the need for defining a formal AST. This implementation solely relies on eval() to create an arrow function responsible for calculating each index of the output based on input lists and an increasing input index.

'use strict';
const json={
    formula: '{{a45bc2a1-ed82-4ccd-a455-f7959e875aad}}+({{f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9}}*{{335563ad-a715-47b9-8e54-2b8553768168}})'
}

const map = {
    'a45bc2a1-ed82-4ccd-a455-f7959e875aad': [1, 2, 3, 4, 5],
    'f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9': [10, 20, 30, 40, 50],
    '335563ad-a715-47b9-8e54-2b8553768168': [1, 2, 3, 4, 5]
}

function parseFormula (formula) {
    const template = /{{([^}]*)}}/;
    const idList = [];
    for (let i = 0; template.test(formula); i++) {
        idList.push(formula.match(template)[0].replace(/[{}]/g, ''));
        formula = formula.replace(template, `input[${i}][i]`);
    }
    return {idList, formula};
}

function calculateFormula(map, parsed) {
    const input = [];
    const result = [];
    const lambda = eval(`(input, i) => ${parsed.formula}`)
    parsed.idList.forEach(id => input.push(map[id]));
    for (let i = 0; i < input[0].length; i++) {
        result.push(lambda(input, i));
    }
    return result;
}

const parsed = parseFormula(json.formula);
console.log(parsed);
console.log(calculateFormula(map, parsed));

Output:

{
  idList: [
    'a45bc2a1-ed82-4ccd-a455-f7959e875aad',       
    'f6c2ef2b-a4fa-4cfb-b62d-d0d7c3e266d9',       
    '335563ad-a715-47b9-8e54-2b8553768168'        
  ],
  formula: 'input[0][i]+(input[1][i]*input[2][i])'
}
[ 11, 42, 93, 164, 255 ]

A guide on breaking down complex mathematical expressions with arrays using javascript

Answer №1

Answer №2

Answer №3

Similar questions

Is it possible to edit the JSON file served by the API in NextJS during runtime and have the API serve the updated file?

What is the best way to configure Jenkins to exclude or include specific component.spec.ts files from being executed during the build

Tips for accessing the current state/value in a third-party event handler?

Implementing multiple filters for object arrays in Angular 8

Searching for city and postal code through the Google Maps API is a straightforward process

Assistance needed with implementing jQuery tabs

Using Set in combination with useRef: A Beginner's Guide

Tips for obtaining two arrays from one single array

What is the best location to initialize an array of Class in Android Studio?

IE users experiencing issues with parseInt conversion

What is the best method for passing information to my frontend JavaScript files using Express?

Implementing change event to activate select dropdown with jQuery

Create styles for each component based on their specific props when designing a customized Material-UI theme

Error when parsing JSON due to the presence of backslashes within the serialized object

Creating a Form in a Popup with Bootstrap

Sending a PHP variable to a JavaScript function when calling it on a different webpage

What is the reason that try/catch cannot handle errors thrown in the Promise constructor?

Searching for a jQuery plugin that can dynamically rearrange tables while automatically updating their corresponding IDs

What is the best way to refresh a page during an ajax call while also resetting all form fields?

Stop React Form from automatically submitting by preventing automatic submission