It's Official: uCalc FMP 2.9 is now available - and it's free.
It's been many years in the making, but uCalc Free Math Parser 2.9 is finally officially released today, June 1, 2007.
uCalc FMP allows your program to evaluate expressions defined at runtime. For more details, please visit
www.ucalc.com/ucalcfmp.html .
uCalc
Free Math Parser 2.9 replaces uCalc
Fast Math Parser 2.0. As of today, support for version 2.0 is officially discontinued. If you are a version 2.0 user, please be sure to read the help file topic entitled Upgrading Issues.
As the name implies, uCalc
Free Math Parser is now free. You may use it in your commercial, educational, or private projects. You may distribute the uCalc DLLs with your products on as many computers as required. There is no royalty fee. Be sure to read the License topic in the help file for more details.
Although the
free license does not entitle you to technical support, you are encouraged to ask questions and send feedback. You might get a response, even if it's on a lower priority level.
uCalc FMP now refers to both uCalc
Free Math Parser, and uCalc
Fast Math Parser (commercial license). The
free license imposes a limit on the number of items you can define. And certain advanced features (none of which were available in version 2.0), as well as full technical support, are reserved for commercial licensees of uCalc Fast Math Parser.
There is just one file to download. By default uCalc FMP is in a demo license mode. The help file's free license topic gives you the code to remove the message box that comes up in the demo mode. And if you purchase a commercial license, you get a serial number that unlocks features reserved for the commercial license. All users are encouraged to start with the free license, after having played with the demo. In many cases the free license will be all that you need. If you use uCalc more heavily, then soon enough you'll know whether you need to purchase a commercial license, as you will find a special message box that comes up whenever you have reached the limits of the free license.
Here is a partial list of new features. These are relevant mainly in the context of moving from 2.0 to 2.9. A host of other new features, which are not mentioned here, are found in the uCalc Language Builder (available separately; although it shares the same DLLs as FMP).
- The IIF() function evaluates either the True argument or the False argument, depending on the value of the Condition argument, but not both, unlike version 2.0 which always evaluated both.
- You can define callback functions similar to IIF() such that arguments passed ByExpr (as opposed to ByRef or ByVal) are not evaluated ahead of time. This was not possible in version 2.0.
- It is no longer necessary to set up definition space boundaries ahead of time. Memory is gradually allocated as needed. You won't need ucReset (though you can release an entire thread using ucReleaseItem), and you won't have to worry about running out of definition space (assuming you don't intentionally, or inadvertently devise a way to consume all your gigs of memory). And there is no maximum number of arguments per function.
- FMP 2.0 only allowed you to define infix (binary) operators. Now you can also define prefix and postfix operators as well. See DemoDefs.Txt for examples.
- FMP 2.0 operator definitions didn't allow you to set individual precedence levels for each operator, as you can do now. See DemoDefs.Txt for examples.
- Case sensitivity can be turned on or off. (It's off by default).
- User-friendly form-based demos for PowerBASIC, Borland C++ Builder, VC++, and VB.NET are now included. (VB classic, and Delphi already had form-based demos).
- Support for VB.NET was added.
- Speed. The new uCalc should be much faster, both in terms of parsing speed, and in evaluation speed. The difference in speed may range from barely noticeable to very dramatic, depending on what you are doing, how you choose to implement things, and in some cases which compiler you are using. By default, compilers that have native support for 80-bit precision can benefit the most in numeric calculations. Compilers that support pointers can create callbacks that use uCalc's NativeCall for more efficiency.
- You can attach a uCalc variable to the address of a variable defined in your source code. See the source code for the Plotting, and Sum examples in the demo files (excluding VB.NET).
- Specific data types (Single, Double, Long, String, WideString, LPCSTR, etc...) are supported, replacing generic numeric and string types.
- There is no longer a problem with using ucEval or ucEvalStr in your callbacks.
- Function overloading is supported.
- Function bootstrapping is supported.
- Function recursion is supported.
- More function definition flexibility is supported.
- Multi-threading is supported.
- Overall syntax was simplified.
- The FPU word of the host program and uCalc's FPU word are insulated from each other.
- FPU errors such as Overflow, Underflow, Division-by-0, etc... can be caught, or masked.
- uCalc() is a function that encapsulates all of uCalc's functionality. This function can be made available even to the end-user.
Please visit the download page at
www.ucalc.com/download.html to obtain the file.
Visit the uCalc home page at
www.ucalc.com ------------------
Daniel Corbier
uCalc FMP author
Show Posts