Version history

What's new in v2.82

• Fixed bug in the opimizer which caused a crash with some functions.

What's new in v2.81

• Added support for units (see help on the AddUnit() method).
• Added support for optionally making the Eval() function thread-safe with a precompiler constant.
• Fixed optimizer bug that caused things like "acos(0)" to misbehave.

What's new in v2.8

• Put the compile-time options to a separate file fpconfig.hh.
• Added comparison operators "!=", "<=" and ">=".
• Added an epsilon value to the comparison operators (its value can be changed in fpconfig.hh or it can be completely disabled there).
• Added unary not operator "!".
• Now user-defined functions can take 0 parameters.
• Added a maximum recursion level to the "eval()" function (definable in fpconfig.hh). Now "eval()" should never cause an infinite recursion. (Note however, that it may still be relevant to disable it completely because it is possible to write functions which take enormous amounts of time to evaluate even when the maximum recursion level is not reached.)
• Separated the optimizer code to its own file (makes developement easier).

What's new in v2.71

• Fixed a couple of syntax errors which slipped through in the v2.7 distribution version:
  • non-standard semicolons at the end of namespace blocks
  • a compilation error which happens if SUPPORT_OPTIMIZER is disabled
• Included a simple example program.

What's new in v2.7

• Changed precedence rules for unary minus and the power operator (^) to make it closer in functionality to the power "operator" in mathematics (ie. superscript):
  • Consecutive power operators at the same precedence level are evaluated from right to left. That is, for example "2^3^4" is now evaluated as if it had been written as "2^(3^4)" (and not as "(2^3)^4" like in previous versions).
  • The unary minus in the base of the power has now a lower precedence than the power operator. That is, "-2^3" will be evaluated as if written as "-(2^3)", ie. the result is "-8" (and not "8" like in previous versions). The unary minus in the exponent is still evaluated first because of the right-left precedence change above (that is, "-2^-3" is evaluated as "-(2^(-3))").
• Fixed a bug in the copy-on-write engine.

What's new in v2.63

• Some tiny fixes to make the library more compatible with BCB4.

What's new in v2.62

• Only an addition to the usage license. (Please read it.)

What's new in v2.61

• Tiny bug fix: Tabs and carriage returns now allowed in the function string.

What's new in v2.6

• Added a new method: GetParseErrorType(). This method can be used to get the type of parsing error (which can be used eg. for customized error messages in another language).
• Added working copy constructor and assignment operator (using the copy-on-write technique for efficiency). See the "Usage" section for details.
• Fixed a problem with the comma operator (,): Comma is not allowed anymore anywhere else than separating function parameters. In other words, comma is not an operator anymore (just a parameter separator).

What's new in v2.51:

• Tiny fixes to make it work with gcc 2.x (which is still sadly common).

What's new in v2.5:

• A new AddConstant() method for adding constants to the parser.
• Two AddFunction() methods for adding user-defined functions to the parser.
• The library can now handle trigonometrical angles either in radians (default) or degrees with an optional parameter of Parse().
• New functions added: cot(), csc() and sec().
• Enhancements and bug fixes to the Optimize() method (please consider it still as experimental).

What's new in v2.4:

• A new Optimize() method which tries to simplify the bytecode so that it will be evaluated faster. Please note that this is still experimental.
• New functions added: atan2() and log10().
• Two new more detailed syntax error messages (previously simply "Syntax error").

What's new in v2.3:

• Variable names can now have digits and underscores (but they can't begin with a digit).
• Parsing speed optimizations. The Parse() method can be even 40% faster than in the previous version. (Please be aware that the new parser has not been thoroughly tested; bugs are possible.)
• A new "semi-undocumented" debugging function for printing the bytecode of the current function (in an asm-like syntax). Mostly useless from the user's point of view.

What's new in v2.22:

• Fixed a tiny bug which made the class to misbehave when an error occurred during parsing.

What's new in v2.21:

• A tiny fix to make the library work with Borland C++ Builder 4.

What's new in v2.2:

• Support for long variable names (NOTE: Unfortunately this breaks backwards compatibility.)
• New functions: min(), max(), if(), eval().
• Support for recursive calls (with if() and eval()).
• New operators (mainly for use with if(), but can be used anywhere): '=', '<', '>', '&' and '|'.

What's new in v2.1:

• Parsing speed optimization.

  I implemented the parser from the scratch using a known parsing algorithm from classical compiler techniques, thus replacing my old ad hoc parser.

  The parser should be much faster now, specially with long functions with lots of parentheses (specially when the expressions inside parentheses are very long).

  I made a test with the function "((2*(5+x*(cos(y-x)/3+2)/4)+1)/4+x)-1" in a Sun Ultra 5 computer. The version 2.0 of the library parses it in approximately 0.21 ms, while the new version 2.1 parses it in 0.115 ms. (I performed the test by parsing the function 100000 times and then dividing the total time by that.)

  Needs lots of testing to make sure that it works!

What's new in v2.0:

• Slight changes in the interface.
  I'm sorry for the lost backwards compatibility, but the v1.x way of taking the parameters was just awful - I made it better this time.
  These changes are:
  • Parse() takes the function as a const std::string& (this is fully backwards compatible).
  • Parse() takes the variables as a const std::string& (eg. "xy"). The old way of taking variable number of parameters was just a too awful hack.
  • The Eval() function taking a variable number of parameters has been removed. Although it was a bit easier to use, it was a hack and led to inefficient code (internally the parameters were put inside a dynamically allocated array anyways, and that's not the most efficient way of doing it; it's much more efficient that the user uses a statically allocated local array).
  These changes are not radical, so don't get too alarmed. I'm sure that changing old code to this new interface is trivial.
• Added the modulo operator (%) and a new function int().
• I hope that now, at last, all the problems with parsing functions with similar beginnings (eg. acos() vs. acosh()) are gone. Needs more testing, though...

What's new in v1.3:
(Thanks to Roland Schmehl for these bug reports).

• The library parsed wrongly sinh, cosh and tanh (confused them with sin, cos and tan and then reported a syntax error for the 'h').
• The library parsed an expression like "-cos(x)+cos(y)" like if it was "-(cos(x)+cos(y))" instead of "(-cos(x))+cos(y)" as it should. Fixed.
• The library didn't parse correctly numbers in the form "1e-2". Fixed.
• Added some explanations at the end of the fparser.txt file.

What's new in v1.21:

• Fixed several memory leaks (thanks to Stephen Agate for the bug report).

What's new in v1.2:

• If you define the identifier NO_ASINH (see the beginning of fparser.cc), then support for the functions asinh, acosh and atanh will be removed (they are not part of the ANSI C standard and thus not supported by most compilers).
• A tiny bug fixed.

What's new in v1.1:

• Fixed bug that made a negated function (eg. "-sin(x)") crash.