# Warnings¶

**Table of contents**- Warnings
- Checking for errors
- Variable naming
- Performance

# Checking for errors¶

## Concatenating comparison operators¶

This is a brutal ** and very common** error. Imagine the following equation:

`a < b < c`

, now let's set `a = 1`

, `b = 3`

and `c = 2`

so it will roughly translate to `1 < 3 < 2`

. Those of you not familiarized with operator precedence evaluation might think that this will result in `false`

but it will actually return `true`

. Why? Well:a < b < c -> ((a < b) < c)

So the example will become:

1 < 3 < 2 -> ((1 < 3) < 2) -> ((1) < 2) -> 1

So the morality of this tale is: **if unsure, DON'T CONCATENATE OPERATORS**

# Variable naming¶

Avoid variables and functions with the same name as build-in functions, constant or operators (or even custom functions). Even though this is possible and permitted by this version of `exp4j`

we intent to create a more strict version in the future.

Why is this bad? well... if we have a built-in function called `sin(x)`

and create a second function called `sin(x, y)`

and use a variable called `sin`

you might end up with expressions like: `sin(sin(sin, sin(sin)) + sin)`

this may sound dumb, but unfortunately is very common.

# Performance¶

~~Multiple calls to ~~`Expression#evaluate()`

¶

`Expression#evaluate()`

This is a common mistake, values returned from `Expression#evaluate()`

are not cached, so every call will reevaluate the entire expression. There are two options:

- Save the value of
`Expression#evaluate()`

instead of calling it multiple times - Implement the result cache! Checkout #752 for some details

## Simplifier enabled for single evaluation¶

The simplifier needs to do a full evaluation of the code in order to make the simplifications, so it should not be enabled for single evaluation, since this will create a 100% loss in performance (the expression needs to be evaluated twice).

## Write simplifiable expressions¶

Even though you can use the `Expression#toString()`

method to checkout the number of tokens, the rule of thumb is to sort the expression:

For instance the expression `2 + 3x - 1`

is not simplifiable, because the `Simplifier`

does not alter the order of the operators (Operators can be overridden and there's no way of handling those scenarios).

If you change `2 + 3x - 1`

to `2 - 1 + 3x`

it will be simplified to `1 + 3x`

.

Updated by Federico Vera over 2 years ago · 7 revisions

Go to top