Proyecto

General

Perfil

Warnings » Histórico » Revisión 4

Revisión 3 (Federico Vera, 2018-07-12 17:18) → Revisión 4/7 (Federico Vera, 2018-07-17 09:53)

# Warnings 

 {{>toc}} 

 # Checking for errors 
 # 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()` 
 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: 
 1. Save the value of `Expression#evaluate()` instead of calling it multiple times 
 1. 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`. 

 ## 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
Volver al inicio