Add logical operators and expressions

[LuigiPulcini]

This PR adds the possibility of having logical operators and expressions in a formula.

Possible operators are >, <, >=, <=, = and !=, the meaning of which is trivial.

Since the final goal is to use those operators in a mathematical formula, the result of a logical expression will always return a number: either 1 (when the expression is true) or 0 (when it is false), which can easily be used in a formula to achieve conditional calculations.

An example of a logical expression used in a formula is:

const f1 = new Formula( '[price] * ( 1 + 0.25 * ( [weight] > 10 )' );

const res = f1.evaluate( { price: 100, weight: 12.4 } );
console.log( res );

// res = 125

This would be essential to implement some logical functions – such as IF() – in the same form Microsoft Excel or Google Sheets do:

const f1 = new Formula( 'IF( [weight] > 10, 1.25, 1 ) * [price]' );

f1.IF = ( value, ifTrue, ifFalse ) => {
    return value ? ifTrue : ifFalse;
};

const res = f1.evaluate( { price: 100, weight: 12.4 } );
console.log( res );

// res = 125

[bylexus]

This is a useful addition, as it opens the possibility to implement conditional logic, thanks.

Would you mind:

• adding some Unit tests (see spec/specs/ for examples)
• merging the develop branch to resolve merge conflicts

Then I will consider your addition to be merged.

Many thanks for your contribution.

[LuigiPulcini]

Hi, @bylexus,

Thanks for reviewing my PR so swiftly. I followed both of your recommendations. While adding Unit tests, I spotted a few missing declarations for the new Logical Expression, which I added now, and rebuilt all the distribution files.

Let me know if the tests are enough and if there is anything else I can do.

[bylexus]

Hello,

Many thanks for your contribution. I have reviewed your input, and think the logical operator precedence should be changed to fit between PowerExpression (strongest), then logical expressions, then the rest. In the actual solution, the logical expressions are the weakest, which is wrong in my opinion.

Let me know what you think.

[bylexus]

This test is correct, but it does not test the operator precedence. I think the "correct" or logical precedence of operators is:

1. (strongest): Power of (x^y)
2. logical operators (x<y)
3. multiplication/division
4. additon/ substraction

So the following formula:

3+2>1*4<2^3

should be parsed as

3+((2>1)*(4<(2^3)))

which it actually does not. So from my point of view, the following test should be green

        it('evaluates the order of logical expressions correct', () => {
            // 3+2>1*4<2^3 should be evaulated as:
            // 3+((2>1)*(4<(2^3)))
            // which evaulates to 4
            const formulaStr = '3+2>1*4<2^3';
            const f = new Fparser();
            let ret = f.parse(formulaStr);
            expect(ret).toEqual(
                new Fparser.PlusMinusExpression(
                    '+',
                    new Fparser.ValueExpression(3),
                    new Fparser.MultDivExpression(
                        '*',
                        new Fparser.LogicalExpression(
                            '>',
                            new Fparser.ValueExpression(2),
                            new Fparser.ValueExpression(1)
                        ),

                        new Fparser.LogicalExpression(
                            '<',
                            new Fparser.ValueExpression(4),
                            new Fparser.PowerExpression(new Fparser.ValueExpression(2), new Fparser.ValueExpression(3))
                        )
                    )
                )
            );
            expect(ret.evaluate()).toBe(4);
        });

Please change the precedence order in fparser.ts, buildExpressionTree.

[bylexus]

On the other hand, if we look at other programming languages, e.g. JavaScript, the logical operators have the lowest precedence:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence#table

What do you think, what would be an appropriate handling / precedence? I would recommend to implement the general consensus, as in other languages...

[bylexus]

See comment above: Please change the order of logical operator precedence to fit between PowerExpression and MultDivExpression:

I think the "correct" or logical precedence of operators is:

(strongest): Power of (x^y)
logical operators (x<y)
multiplication/division
additon/ substraction

So the following formula:

3+2>1*4<2^3

should be parsed as

3+((2>1)*(4<(2^3)))

[bylexus]

On the other hand, if we look at other programming languages, e.g. JavaScript, the logical operators have the lowest precedence:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence#table

What do you think, what would be an appropriate handling / precedence? I would recommend to implement the general consensus, as in other languages...

[bylexus]

OK, I have decided that your solution and your implementation of the operator precedence is correct. I will merge your contribution into my develop branch, add some documentation and examples, and release a new version.

many thanks for your useful contribution.

[LuigiPulcini]

Thanks for reviewing the PR so thoroughly. I am glad that, in the end, it worked out as intended!