                     Expression Synax:
                    Last update: 1.4.1.103 
					
======================================================================
Vars (Global)        | Type    | Description
======================================================================
IS_PEACE_ZONE        | BOOL    | If we are on peace zone
IS_SIEGE_ZONE        | BOOL    | If we are on siege zone
IS_GENERAL_ZONE      | BOOL    | If we are on general zone
======================================================================


Variables bellow should be used only with one of a prefix:
M_ - Myself
P_ - My Pet/Summon
T_ - Skill target or my real target.
======================================================================
Vars (With  M_,P_,T_)| Type    | Description
======================================================================
IS_ACTIVE            | BOOL    | Is active
IS_PLAYER            | BOOL    | Is a player
IS_PARTY_MEMBER      | BOOL    | Is party member
IS_MONSTER           | BOOL    | Is monster
IS_PARTY_MASTER      | BOOL    | Is party master
IS_FRIEND            | BOOL    | Is a clan/party/ally member
IS_ME                | BOOL    | Is me
IS_NPC               | BOOL    | Is NPC
IS_CLAN_MEMBER       | BOOL    | Is clan member
IS_CLAN_MASTER       | BOOL    | Is clan master
IS_ALLIANCE_MEMBER   | BOOL    | Is alliance member
IS_WALKING           | BOOL    | Is walking/Not running
IS_SITING            | BOOL    | Is siting
IS_ENEMY             | BOOL    | Is enemy, can be killed with no ctrl.
IS_PVP_FLAGED        | BOOL    | Is flaged, can be killed
IS_PVP_FLAG_BLINK    | BOOL    | Flag ends in max 20 seconds
IS_DEATH             | BOOL    | Is death
IS_SPOILED           | BOOL    | Is spoiled by our bot
IS_PET               | BOOL    | Is pet
IS_MY_PET            | BOOL    | Is my pet
IS_SUMMON            | BOOL    | Is summon
IS_ATTACKING         | BOOL    | Is attacking me
IS_ATTACKED          | BOOL    | Was attacked by me ?
IS_HUMAN             | BOOL    | Is human class (only if player)
IS_ELF               | BOOL    | Is elf class (only if player)
IS_DARKELF           | BOOL    | Is darkelf (only if player)
IS_ORC               | BOOL    | Is orc (only if player)
IS_DWARF             | BOOL    | Is dwarf (only if player)
IS_KAMAEL            | BOOL    | Is kamael (only if player)
IS_BLOCKED           | BOOL    | Can't move and use skills
IS_USING_MAGIC       | BOOL    | Is using magic now
IS_IN_COMBAT         | BOOL    | Is in combat
IS_CAN_SEE_ME        | BOOL    | Can see me ?
IS_HAVING_WEAPON     | BOOL    | Got weapon in hand
IS_HERO              | BOOL    | Is hero
IS_NOBLES            | BOOL    | Is nobles
IS_UNDER_ATTACK      | BOOL    | Is under attack
----------------------------------------------------------------------
MELE_ATTACK_RANGE    | NUMBER  | Mele attack range, usually 40
RANGE                | NUMBER  | Range to char
HP                   | NUMBER  | Hp
MP                   | NUMBER  | Mp
CP                   | NUMBER  | Cp
MAX_HP               | NUMBER  | Max Hp
MAX_MP               | NUMBER  | Max Mp
MAX_CP               | NUMBER  | Max Cp
DAMAGE_HP            | NUMBER  | Max Hp - Hp
DAMAGE_MP            | NUMBER  | Max Mp - Mp
DAMAGE_CP            | NUMBER  | Max Cp - Cp
PERCENT_HP           | NUMBER  | Hp/MaxHp*100%
PERCENT_MP           | NUMBER  | Mp/MaxMp*100%
PERCENT_CP           | NUMBER  | Cp/MaxCp*100%
LEVEL                | NUMBER  | Level
PENALTY_LEVEL        | NUMBER  | Penalty level (when you die ...)
SOULS                | NUMBER  | Souls (for kamaels)
ENERGY               | NUMBER  | Energy (for tyrant, gladiator)
NPC_ID               | NUMBER  | Npc ID
MAX_WEIGHT           | NUMBER  | MaxWeight
WEIGHT               | NUMBER  | Weight
PERCENT_WEIGHT       | NUMBER  | Weight/MaxWeight*100%
CLASS                | NUMBER  | Class ID
REPUTATION           | NUMBER  | Reputation (Karma on old chronicles)
WEAPON_ENCHANT_LEVEL | NUMBER  | Weapon enchant
VITALITY             | NUMBER  | Vitality 
LOC_X                | NUMBER  | Location X
LOC_Y                | NUMBER  | Location Y
LOC_Z                | NUMBER  | Location Z
======================================================================


(0) Arithmetic Operators
+----------+---------------------------------------------------------+
| OPERATOR | DEFINITION                                              |
+----------+---------------------------------------------------------+
|  +       | Addition between x and y. (eg: x + y)                   |
+----------+---------------------------------------------------------+
|  -       | Subtraction between x and y. (eg: x - y)                |
+----------+---------------------------------------------------------+
|  *       | Multiplication between x and y. (eg: x * y)             |
+----------+---------------------------------------------------------+
|  /       | Division between x and y (eg: x / y)                    |
+----------+---------------------------------------------------------+
|  %       | Modulus of x with respect to y. (eg: x % y)             |
+----------+---------------------------------------------------------+
|  ^       | x to the power of y. (eg: x ^ y)                        |
+----------+---------------------------------------------------------+
|  :=      | Assign the value of x to y. (eg: y := x)                |
|          | Where y is a variable type.                             |
+----------+---------------------------------------------------------+

(1) Equalities & Inequalities
+----------+---------------------------------------------------------+
| OPERATOR | DEFINITION                                              |
+----------+---------------------------------------------------------+
| == or =  | True only if x is strictly equal to y. (eg: x == y)     |
+----------+---------------------------------------------------------+
| <> or != | True only if x does not equal y. (eg: x <> y or x != y) |
+----------+---------------------------------------------------------+
|  <       | True only if x is less than y. (eg: x < y)              |
+----------+---------------------------------------------------------+
|  <=      | True only if x is less than or equal to y. (eg: x <= y) |
+----------+---------------------------------------------------------+
|  >       | True only if x is greater than y. (eg: x > y)           |
+----------+---------------------------------------------------------+
|  >=      | True only if x greater than or equal to y. (eg: x >= y) |
+----------+---------------------------------------------------------+

(2) Boolean Operations
+----------+---------------------------------------------------------+
| OPERATOR | DEFINITION                                              |
+----------+---------------------------------------------------------+
| true     | True state or any value other than zero (typically 1).  |
+----------+---------------------------------------------------------+
| false    | False state, value of zero.                             |
+----------+---------------------------------------------------------+
| and      | Logical AND, True only if x and y are both true.        |
|          | (eg: x and y)                                           |
+----------+---------------------------------------------------------+
| mand     | Multi-input logical AND, True only if all inputs are    |
|          | true. Left to right short-circuiting of expressions.    |
|          | (eg: mand(x > y,z < w,u or v,w and x))                  |
+----------+---------------------------------------------------------+
| mor      | Multi-input logical OR, True if at least one of the     |
|          | inputs are true. Left to right short-circuiting of      |
|          | expressions. (eg: mor(x > y,z < w,u or v,w and x))      |
+----------+---------------------------------------------------------+
| nand     | Logical NAND, True only if either x or y is false.      |
|          | (eg: x nand y)                                          |
+----------+---------------------------------------------------------+
| nor      | Logical NOR, True only if the result of x or y is false |
|          | (eg: x nor y)                                           |
+----------+---------------------------------------------------------+
| not      | Logical NOT, Negate the logical sense of the input.     |
|          | (eg: not(x and y) == x nand y)                          |
+----------+---------------------------------------------------------+
| or       | Logical OR, True if either x or y is true. (eg: x or y) |
+----------+---------------------------------------------------------+
| xor      | Logical XOR, True only if the logical states of x and y |
|          | differ. (eg: x xor y)                                   |
+----------+---------------------------------------------------------+
| xnor     | Logical XNOR, True iff the biconditional of x and y is  |
|          | satisfied. (eg: x xnor y)                               |
+----------+---------------------------------------------------------+
| &        | Similar to AND but with left to right expression short  |
|          | circuiting optimisation. (eg: (x & y) == (y and x))     |
+----------+---------------------------------------------------------+
| |        | Similar to OR but with left to right expression short   |
|          | circuiting optimisation. (eg: (x | y) == (y or x))      |
+----------+---------------------------------------------------------+

(3) General Purpose Functions
+----------+---------------------------------------------------------+
| FUNCTION | DEFINITION                                              |
+----------+---------------------------------------------------------+
| abs      | Absolute value of x.                                    |
+----------+---------------------------------------------------------+
| avg      | Average of all the inputs.                              |
|          | (eg: avg(x,y,z,w,u,v) == (x + y + z + w + u + v) / 6)   |
+----------+---------------------------------------------------------+
| ceil     | Smallest integer that is greater than or equal to x.    |
+----------+---------------------------------------------------------+
| clamp    | Clamp x in range between r0 and r1, where r0 < r1.      |
|          | (eg: clamp(r0,x,r1)                                     |
+----------+---------------------------------------------------------+
| equal    | Equality test between x and y using normalized epsilon  |
+----------+---------------------------------------------------------+
| erf      | Error function of x.                                    |
+----------+---------------------------------------------------------+
| erfc     | Complimentary error function of x.                      |
+----------+---------------------------------------------------------+
| exp      | e to the power of x.                                    |
+----------+---------------------------------------------------------+
| expm1    | e to the power of x minus 1, where x is very small.     |
|          | (eg: expm1(x))                                          |
+----------+---------------------------------------------------------+
| floor    | Largest integer that is less than or equal to x.        |
+----------+---------------------------------------------------------+
| frac     | Fractional portion of x.                                |
+----------+---------------------------------------------------------+
| hypot    | Hypotenuse of x and y (eg: hypot(x,y) = sqrt(x*x + y*y))|
+----------+---------------------------------------------------------+
| log      | Natural logarithm of x.                                 |
+----------+---------------------------------------------------------+
| log10    | Base 10 logarithm of x.                                 |
+----------+---------------------------------------------------------+
| log1p    | Natural logarithm of 1 + x, where x is very small.      |
|          | (eg: log1p(x))                                          |
+----------+---------------------------------------------------------+
| log2     | Base 2 logarithm of x.                                  |
+----------+---------------------------------------------------------+
| logn     | Base N logarithm of x (eg: logn(1235,8))                |
|          | where n > 0 and is an integer.                          |
+----------+---------------------------------------------------------+
| max      | Largest value of all the inputs. (eg: max(x,y,z,w,u,v)) |
+----------+---------------------------------------------------------+
| min      | Smallest value of all the inputs. (eg: min(x,y,z,w,u))  |
+----------+---------------------------------------------------------+
| mul      | Product of all the inputs.                              |
|          | (eg: mul(x,y,z,w,u,v,t) == (x * y * z * w * u * v * t)) |
+----------+---------------------------------------------------------+
| nequal   | Not-equal test between x and y using normalized epsilon |
+----------+---------------------------------------------------------+
| root     | Nth-Root of x (eg: root(x,3))                           |
|          | where n > 0 and is an integer.                          |
+----------+---------------------------------------------------------+
| round    | Round x to the nearest integer.                         |
+----------+---------------------------------------------------------+
| roundn   | Round x to n decimal places (eg: roundn(x,3))           |
|          | where n > 0 and is an integer.                          |
|          | (eg: roundn(1.2345678,4) == 1.2346)                     |
+----------+---------------------------------------------------------+
| sgn      | Sign of x, -1 where x < 0, +1 where x > 0, else zero.   |
+----------+---------------------------------------------------------+
| sqrt     | Square root of x, where x > 0                           |
+----------+---------------------------------------------------------+
| sum      | Sum of all the inputs.                                  |
|          | (eg: sum(x,y,z,w,u,v,t) == (x + y + z + w + u + v + t)) |
+----------+---------------------------------------------------------+
| trunc    | Integer portion of x.                                   |
+----------+---------------------------------------------------------+

(4) Trigonometry Functions
+----------+---------------------------------------------------------+
| FUNCTION | DEFINITION                                              |
+----------+---------------------------------------------------------+
| acos     | Arc cosine of x expressed in radians. Interval [-1,+1]  |
+----------+---------------------------------------------------------+
| asin     | Arc sine of x expressed in radians. Interval [-1,+1]    |
+----------+---------------------------------------------------------+
| atan     | Arc tangent of x expressed in radians. Interval [-1,+1] |
+----------+---------------------------------------------------------+
| atan2    | Arc tangent of (x/y) expressed in radians. [-pi,+pi]    |
|          | eg: atan2(x,y)                                          |
+----------+---------------------------------------------------------+
| cos      | Cosine of x.                                            |
+----------+---------------------------------------------------------+
| cosh     | Hyperbolic cosine of x.                                 |
+----------+---------------------------------------------------------+
| cot      | Cotangent of x.                                         |
+----------+---------------------------------------------------------+
| csc      | Cosecant of x.                                          |
+----------+---------------------------------------------------------+
| sec      | Secant of x.                                            |
+----------+---------------------------------------------------------+
| sin      | Sine of x.                                              |
+----------+---------------------------------------------------------+
| sinh     | Hyperbolic sine of x.                                   |
+----------+---------------------------------------------------------+
| tan      | Tangent of x.                                           |
+----------+---------------------------------------------------------+
| tanh     | Hyperbolic tangent of x.                                |
+----------+---------------------------------------------------------+
| deg2rad  | Convert x from degrees to radians.                      |
+----------+---------------------------------------------------------+
| deg2grad | Convert x from degrees to gradians.                     |
+----------+---------------------------------------------------------+
| rad2deg  | Convert x from radians to degrees.                      |
+----------+---------------------------------------------------------+
| grad2deg | Convert x from gradians to degrees.                     |
+----------+---------------------------------------------------------+

(5) String Processing
+----------+---------------------------------------------------------+
| FUNCTION | DEFINITION                                              |
+----------+---------------------------------------------------------+
| in       | True only if x is a substring of y.                     |
|          | (eg: x in y or 'abc' in 'abcdefgh')                     |
+----------+---------------------------------------------------------+
| like     | True only if the string x matches the pattern y.        |
|          | Available wildcard characters are '*' and '?' denoting  |
|          | zero or more and zero or one matches respectively.      |
|          | (eg: x like y or 'abcdefgh' like 'a?d*h')               |
+----------+---------------------------------------------------------+
| ilike    | True only if the string x matches the pattern y in a    |
|          | case insensitive manner. Available wildcard characters  |
|          | are '*' and '?' denoting zero or more and zero or one   |
|          | matches respectively.                                   |
|          | (eg: x ilike y or 'a1B2c3D4e5F6g7H' ilike 'a?d*h')      |
+----------+---------------------------------------------------------+
| [r0:r1]  | The closed interval [r0,r1] of the specified string.    |
|          | eg: Given a string x with a value of 'abcdefgh' then:   |
|          | 0. x[1:4] == 'bcde'                                     |
|          | 1. x[ :5] == 'abcdef'                                   |
|          | 2. x[3: ] == 'cdefgh'                                   |
|          | 3. x[ : ] == 'abcdefgh'                                 |
|          | 4. x[4/2:3+2] == x[2:5] == 'cdef'                       |
|          |                                                         |
|          | Note: Both r0 and r1 are assumed to be integers, where  |
|          | r0 <= r1. They may also be the result of an expression, |
|          | in the event they have fractional components truncation |
|          | will be performed. (eg: 1.67 -> 1)                      |
+----------+---------------------------------------------------------+

(6) Control Structures
+----------+---------------------------------------------------------+
|STRUCTURE | DEFINITION                                              |
+----------+---------------------------------------------------------+
| if       | If x is true then return y else return z.               |
|          | (eg: if(x, y, z) or if((x + 1) > 2y, z + 1, w / v))     |
+----------+---------------------------------------------------------+
| switch   | The first true case condition that is encountered will  |
|          | determine the result of the switch. If none of the case |
|          | conditions hold true, the default action is assumed as  |
|          | the final return value. This is sometimes also known as |
|          | a multi-way branch mechanism.                           |
|          | eg:                                                     |
|          | switch                                                  |
|          | {                                                       |
|          |   case x > (y + z) : 2 * x / abs(y - z);                |
|          |   case x < 3       : sin(x + y)                         |
|          |   default          : 1 + x;                             |
|          | }                                                       |
+----------+---------------------------------------------------------+
| while    | The structure will repeatedly evaluate the internal     |
|          | statement(s) 'while' the condition is true. The final   |
|          | statement in the final iteration will be used as the    |
|          | return value of the loop.                               |
|          | eg:                                                     |
|          | while ((x := (x - 1)) > 0)                              |
|          | {                                                       |
|          |   y := x + z;                                           |
|          |   w := z + y;                                           |
|          | }                                                       |
+----------+---------------------------------------------------------+
| repeat/  | The structure will repeatedly evaluate the internal     |
| until    | statement(s) 'until' the condition is true. The final   |
|          | statement in the final iteration will be used as the    |
|          | return value of the loop.                               |
|          | eg:                                                     |
|          | repeat                                                  |
|          |   y := x + z;                                           |
|          |   w := z + y;                                           |
|          | until ((x := (x - 1)) <= 0)                             |
+----------+---------------------------------------------------------+
| ~        | Evaluate each sub-expression, then return as the result |
|          | the value of the last sub-expression. This is sometimes |
|          | known as multiple sequence point evaluation.            |
|          | eg:                                                     |
|          | ~(i := x + 1, j := y / z, k := sin(w/u)) == (sin(w/u))) |
|          | ~{i := x + 1; j := y / z; k := sin(w/u)} == (sin(w/u))) |
+----------+---------------------------------------------------------+



[09 - SPECIAL FUNCTIONS]
The purpose  of special  functions in  ExprTk is  to provide  compiler
generated equivalents of common mathematical expressions which can  be
invoked by  using the  'special function'  syntax (eg:  $f12(x,y,z) or
$f82(x,y,z,w)).

Special functions dramatically decrease  the total evaluation time  of
expressions which would otherwise  have been written using  the common
form by reducing the total number  of nodes in the evaluation tree  of
an  expression  and  by  also  leveraging  the  compiler's  ability to
correctly optimize such expressions for a given architecture.

          3-Parameter                       4-Parameter
 +-------------+-------------+    +--------------+------------------+
 |  Prototype  |  Operation  |    |  Prototype   |    Operation     |
 +-------------+-------------+    +--------------+------------------+
   $f00(x,y,z) | (x + y) / z       $f47(x,y,z,w) | x + ((y + z) / w)
   $f01(x,y,z) | (x + y) * z       $f48(x,y,z,w) | x + ((y + z) * w)
   $f02(x,y,z) | (x + y) - z       $f49(x,y,z,w) | x + ((y - z) / w)
   $f03(x,y,z) | (x + y) + z       $f50(x,y,z,w) | x + ((y - z) * w)
   $f04(x,y,z) | (x - y) / z       $f51(x,y,z,w) | x + ((y * z) / w)
   $f05(x,y,z) | (x - y) * z       $f52(x,y,z,w) | x + ((y * z) * w)
   $f06(x,y,z) | (x * y) + z       $f53(x,y,z,w) | x + ((y / z) + w)
   $f07(x,y,z) | (x * y) - z       $f54(x,y,z,w) | x + ((y / z) / w)
   $f08(x,y,z) | (x * y) / z       $f55(x,y,z,w) | x + ((y / z) * w)
   $f09(x,y,z) | (x * y) * z       $f56(x,y,z,w) | x - ((y + z) / w)
   $f10(x,y,z) | (x / y) + z       $f57(x,y,z,w) | x - ((y + z) * w)
   $f11(x,y,z) | (x / y) - z       $f58(x,y,z,w) | x - ((y - z) / w)
   $f12(x,y,z) | (x / y) / z       $f59(x,y,z,w) | x - ((y - z) * w)
   $f13(x,y,z) | (x / y) * z       $f60(x,y,z,w) | x - ((y * z) / w)
   $f14(x,y,z) | x / (y + z)       $f61(x,y,z,w) | x - ((y * z) * w)
   $f15(x,y,z) | x / (y - z)       $f62(x,y,z,w) | x - ((y / z) / w)
   $f16(x,y,z) | x / (y * z)       $f63(x,y,z,w) | x - ((y / z) * w)
   $f17(x,y,z) | x / (y / z)       $f64(x,y,z,w) | ((x + y) * z) - w
   $f18(x,y,z) | x * (y + z)       $f65(x,y,z,w) | ((x - y) * z) - w
   $f19(x,y,z) | x * (y - z)       $f66(x,y,z,w) | ((x * y) * z) - w
   $f20(x,y,z) | x * (y * z)       $f67(x,y,z,w) | ((x / y) * z) - w
   $f21(x,y,z) | x * (y / z)       $f68(x,y,z,w) | ((x + y) / z) - w
   $f22(x,y,z) | x - (y + z)       $f69(x,y,z,w) | ((x - y) / z) - w
   $f23(x,y,z) | x - (y - z)       $f70(x,y,z,w) | ((x * y) / z) - w
   $f24(x,y,z) | x - (y / z)       $f71(x,y,z,w) | ((x / y) / z) - w
   $f25(x,y,z) | x - (y * z)       $f72(x,y,z,w) | (x * y) + (z * w)
   $f26(x,y,z) | x + (y * z)       $f73(x,y,z,w) | (x * y) - (z * w)
   $f27(x,y,z) | x + (y / z)       $f74(x,y,z,w) | (x * y) + (z / w)
   $f28(x,y,z) | x + (y + z)       $f75(x,y,z,w) | (x * y) - (z / w)
   $f29(x,y,z) | x + (y - z)       $f76(x,y,z,w) | (x / y) + (z / w)
   $f30(x,y,z) | x * y^2 + z       $f77(x,y,z,w) | (x / y) - (z / w)
   $f31(x,y,z) | x * y^3 + z       $f78(x,y,z,w) | (x / y) - (z * w)
   $f32(x,y,z) | x * y^4 + z       $f79(x,y,z,w) | x / (y + (z * w))
   $f33(x,y,z) | x * y^5 + z       $f80(x,y,z,w) | x / (y - (z * w))
   $f34(x,y,z) | x * y^6 + z       $f81(x,y,z,w) | x * (y + (z * w))
   $f35(x,y,z) | x * y^7 + z       $f82(x,y,z,w) | x * (y - (z * w))
   $f36(x,y,z) | x * y^8 + z       $f83(x,y,z,w) | x*y^2 + z*w^2
   $f37(x,y,z) | x * y^9 + z       $f84(x,y,z,w) | x*y^3 + z*w^3
   $f38(x,y,z) | x * log(y)+z      $f85(x,y,z,w) | x*y^4 + z*w^4
   $f39(x,y,z) | x * log(y)-z      $f86(x,y,z,w) | x*y^5 + z*w^5
   $f40(x,y,z) | x * log10(y)+z    $f87(x,y,z,w) | x*y^6 + z*w^6
   $f41(x,y,z) | x * log10(y)-z    $f88(x,y,z,w) | x*y^7 + z*w^7
   $f42(x,y,z) | x * sin(y)+z      $f89(x,y,z,w) | x*y^8 + z*w^8
   $f43(x,y,z) | x * sin(y)-z      $f90(x,y,z,w) | x*y^9 + z*w^9
   $f44(x,y,z) | x * cos(y)+z      $f91(x,y,z,w) | (x and y) ? z
   $f45(x,y,z) | x * cos(y)-z      $f92(x,y,z,w) | (x or  y) ? z : w
   $f46(x,y,z) | x ? y : z         $f93(x,y,z,w) | (x <   y) ? z : w
                                   $f94(x,y,z,w) | (x <=  y) ? z : w
                                   $f95(x,y,z,w) | (x >   y) ? z : w
                                   $f96(x,y,z,w) | (x >=  y) ? z : w
                                   $f97(x,y,z,w) | (x ==  y) ? z : w
                                   $f98(x,y,z,w) | x * sin(y) + z * cos(w)



[10 - EXPRTK NOTES]
 (00) Precision and performance of expression evaluations are the
      dominant principles of the ExprTk library.

 (01) Supported types are float, double and long double.

 (02) Standard mathematical operator precedence is applied (BEDMAS).

 (03) Results of expressions that are deemed as being 'valid' are to
      exist within the set of Real numbers. All other results will be
      of the value Not-A-Number (NaN).

 (04) Supported user defined types are numeric and string variables
      and functions.

 (05) All variable and function names are case-insensitive.

 (06) Variable and function names must begin with a letter
      (A-Z or a-z), then can be comprised of any combination of
      letters, digits and underscores. (eg: x, var1 or power_func99)

 (07) Expression lengths and sub-expression lists are limited only by
      storage capacity.

 (08) The life-time of objects registered with or created from a
      specific symbol-table must span at least the life-time of the
      compiled expressions which utilize objects, such as variables,
      of that symbol-table, otherwise the result will be undefined
      behavior.

 (09) Equal/Nequal are normalized equality routines, which use
      epsilons of 0.0000000001 and 0.000001 for double and float
      types respectively.

 (10) All trigonometric functions assume radian input unless
      stated otherwise.

 (11) Expressions may contain white-space characters such as
      space,  tabs, new-lines, control-feed et al.
      ('\n', '\r', '\t', '\b', '\v', '\f')

 (12) Strings may be constructed from any letters, digits or special
      characters such as (~!@#$%^&*()[]|=+ ,./?<>;:"`~_), and must
      be enclosed with single-quotes.
      eg: 'Frankly, my dear, I do not give a damn!'

 (13) User defined normal functions can have up to 20 parameters,
      where as user defined vararg-functions can have an unlimited
      number of parameters.

 (14) The inbuilt polynomial functions can be at most of degree 12.

 (15) Where appropriate constant folding optimisations will be
      applied. (eg: The expression '2+(3-(x/y))' becomes '5-(x/y)')

 (16) String processing capabilities are available by default.
      To turn them off, the following needs to be defined at
      compile time: exprtk_disable_string_capabilities

 (17) Composited functions can call themselves or any other functions
      that have been defined prior to their own definition.

 (18) Recursive calls made from within composited functions will have
      a stack size bound by the stack of the executing architecture.

 (19) Expressions may contain any of the following comment styles:
      1. // .... \n
      2. #  .... \n
      3. /* .... */