uCalc Fast Math Parser
by uCalc Software - Product Type: Component / .NET Class / DLL
;)
A math parser for programmers. uCalc FMP is a 32-bit DLL component which allows your program to evaluate expressions that are defined at runtime. uCalc FMP is a fast, reliable and flexible math engine that allows you to develop applications that allow end users to add their own set of formulas whenever they want instead of having to pre-determine them. It includes direct support for .NET compilers, Visual Basic, Visual Basic .NET, and Visual C++, Borland C++ Builder, Delphi and PowerBASIC (PB/DLL and PB/CC).
Our regular prices are shown below. Please logon to see your discounted prices.
uCalc Fast Math Parser Lite Edition V2.95
| Add to Cart | $ 141.55 | 1 Developer License | Download (858 KB) |
uCalc Fast Math Parser Standard Edition V2.95
| Add to Cart | $ 474.05 | 1 Developer License | Download (858 KB) | |
| Add to Cart | $ 284.05 | 1 Developer License, price per license from 2 to 9 licenses | Download (858 KB) | |
| Add to Cart | $ 236.55 | 1 Developer License, price per license from 10 licenses | Download (858 KB) | |
| Add to Cart | $ 141.55 | 1 Developer Upgrade License from uCalc Fast Math Parser V2.0 | Verify | Download (858 KB) |
| Add to Cart | $ 332.50 | 1 Developer Upgrade License from Lite Edition | Verify | Download (858 KB) |
Our prices include ComponentSource technical support and, for most downloadable products, an online backup and a FREE upgrade to the new version if it is released within 30 days of your purchase. All sales are made on our standard Terms and Conditions and subject to our Return Policy. Please contact us if you require any licensing option not listed above including volume licensing and previous versions.
Our regular prices are shown above. Please logon to see your discounted prices.
uCalc FMP allows programs to evaluate math expressions that are defined at run time. It parses them, evaluates formulas and performs the calculations with extended precision via 80-bit numbers. uCalc Fast Math Parser performs everything from basic arithmetic to advanced trigonometric calculations. Ease of implementation, flexibility, sturdiness and speed are at the core of the product's design. It includes direct support for Borland C++ Builder, Delphi, PowerBASIC (PB/DLL and PB/CC), Visual Basic (classic), Visual Basic .NET, and Visual C++.
uCalc FMP in a nutshell
Example 1: This lets the end-user evaluate an expression such as 6+4*5/2
UserExpr$ = InputBox$("Enter an expression",,"6+4*5/2")
Print ucEval(UserExpr$) ' Returns 16
Example 2: This user expression is very rapidly evaluated in a loop
(See the demo that comes with the download for a more complete example)
UserExpr$ = InputBox$("Enter an expression",,"x^2+x+1")
xPtr = ucDefineVariable("x As Double", VarPtr(x))
ExprPtr = ucParse(UserExpr$)
For x = 1 To 1000000
SumTotal = SumTotal + ucEvaluate(ExprPtr)
Next
uCalc FMP is used by some Fortune 500 companies from categories such as Aeronautics, Automobile, Banking, Computers, and Securities.
Operators and functions available to end-users
The first section lists functions and operators that are typically familiar, each with a quick description and example. The subsequent section lists special functions that require additional explanations.
| Symbol | Description | Example |
| ! | Factorial | 5! = 120 |
| ^ | Raised to the power of | 4 ^ 5 = 1024 |
| * | Multiply by | 3 * 6 = 18 |
| / | Divide by | 9 / 2 = 4.5 |
| \ | Integer divide by | 9 \ 2 = 4 |
| mod | Modulo (remainder) | 7 mod 4 = 3 |
| + | Add | 1 + 1 = 2 |
| - | Subtract | 9 - 5 = 4 |
| - | Unary negation | -(5+4) = -9 |
| + | Concatenate | 'Zeb' + 'ra' = 'Zebra' |
| > | Greater than (numeric) | 9 > 2 = 1 |
| < | Less than (numeric) | 7 < 4 = 0 |
| == | Equal test (numeric) | 5 == 4 = 0 |
| >= | Greater or equal (numeric) | 3 >= 3 = 1 |
| <= | Less or equal (numeric) | #h3E <= 9 = 0 |
| <> | Not equal (numeric) | #b10101 <> 20 = 1 |
| > | Greater than (string) | 'This' > 'That' = 1 |
| < | Less than (string) | 'This' < 'That' = 0 |
| == | Equal test (string) | 'A' == 'B' = 0 |
| >= | Greater or equal (string) | 'Zeb' >= 'Zebra' = 0 |
| <= | Less or equal (string) | 'Zeb' <= 'Zebra' = 1 |
| <> | Not equal (string) | 'X' <> 'Y' = 1 |
| And | Bitwise AND | #b101 AND #h1E = 4 |
| Or | Bitwise OR | 13 OR 6 = 15 |
| AndAlso | Short-circuit And | |
| OrElse | Short-circuit Or | |
| IIF | If condition (numeric) | IIf(1+1=2, 4, 5) = 4 |
| IIF | If condition (string) | IIf(1, 'T', 'F') = 'T' |
| Min | Minimum value | min(10, 3) = 3 |
| Max | Maximum value | max(1, 9, 2) = 9 |
| Sin | Sine | sin(pi) = 0 |
| Cos | Cosine | cos(pi) = -1 |
| Tan | Tangent | tan(pi) = 0 |
| Atan | Arc tangent | atan(0) = 0 |
| Abs | Absolute value | abs(-8) = 8 |
| Exp | e to the power of | exp(3) = 20.08 |
| Log | Natural log | log(16) = 2.77 |
| Ceil | Round up | ceil(6.2) = 7 |
| Int | Truncate to an integer | int(6.8) = 6 |
| Frac | Fractional part | Frac(3.125) = 0.125 |
| Sgn | Sign (returns -1, 0, or 1) | sgn(-9) = -1 |
| Sqr | Square root | sqr(64) = 8 |
Functions that require further explanation:
Asc(StringArg [, Position])
Returns the ASCII value of a character. If the Position argument is omitted, then the ASCII value of the first character of the string is returned, otherwise the value of the nth position (starting with 1), as supplied by the Position argument is returned.
BaseConvert(Number, FromBase)
Converts from a given base to base 10. Number is a string argument (to allow for non-numeric digits as used in hexadecimal), and FromBase is numeric.
Example: BaseConvert("101", 2) returns 5
Chr(Number)
Returns the character associated with the ASCII value supplied as the Number argument.
Min(a, b [, ...])
Max(a, b [, ...])
These two are actually mocro-like items instead of functions. They take any number of arguments and return the minimum argument (for Min), or the maximum argument (for Max). They work with both string and numeric arguments. Arguments must be either all strings or all numbers
Precedence(Operator)
Returns the precedence level of a given operator. The Operator argument is a string.
Rand([x])
Rand(a, b)
Options
No parameters
Returns a floating point random number between 0 and 1. The number chosen is the next in a random sequence.
x > 0
Returns a floating point random number between 0 and 1. The number chosen is the next in a random sequence.
x = 0
Returns the same random number as the one previously generated.
x < 0
Returns the same random number each time, using the parameter as seed.
a, b
Returns an integer random number between a and b.
SetSyntaxParams(Params, Expression [, Thread])
This adds curly braces { and } around parameters in a string so that this string can be used as a syntax definition. This allows for the definition of macros, for instance.
Params is a string argument, which contains a list of parameters. The parameters in the string do not have to be organized in any special way. uCalc will pick out all alphanumeric elements in the string and treat those as the parameters. Expression is a string containing a definition that is to be parameterized. That is, curly braces will be added around each alphanumeric occurrence in Expression that was found in Params. Parameter names are not case sensitive. The thread argument is optional. A value of 0 represents the current thread.
The example below shows how you might call SetSyntaxParams. Here uCalc picks out x, y, and z from Params as parameters. Occurrences of x, y, and z in the second argument are surrounded by curly braces in the transformed string:
Expression ==> SetSyntaxParams("(x, y, z)", "macro(x, y, z) = sin(x)*y+abc+x-z")
Transformation ==> macro({x}, {y}, {z}) = sin({x})*{y}+abc+{x}-{z}
Here, the first argument could have equally been "x, y, z"; "(x y z)", "[x+y+z]", "((x) (y) (z))", etc...
See also the Macro construct at the very end of the include file.
uc_For(Counter, Step, Start, Finish, Expression)
This repeats the evaluation of Expression a certain number of times, as in a For/Next loop. The Counter argument accepts a numeric variable, which will first be set to the value of Start, and then successively be incremented by the amount of Step, until the Counter variable is finally set equal to Finish, at which point the loop ends. The return value is the result of the evaluation of the expression in its last iteration.
uc_Loop(DoCondition, Expression, LoopCondition)
This repeats the evaluation of the Expression argument until either DoCondition or LoopCondition is equal to 0. The value of DoCondition is checked prior to the evaluation of the expression, while the value of LoopCondition is checked after the expression is evaluated. The return value is the result of the evaluation of the expression in its last iteration.
uCalc(Command [, ...])
uCalcStr(Command [, ...])
uCalc and uCalcStr correspond with the uCalc function. This allows you to expose all of uCalc's functionality to the end-user. The end-user can use uCalc or uCalcStr in an expression just like any other function listed in this help file topic. This function is reserved for the commercial uCalc FMP license, or the uCalc Language Builder.
New or Enhanced
The IIF function now only evaluates either the True argument, or the False one, but not both.
The IIF function can work with either numeric or string arguments.
String relational (comparison) operators were added.
There is no longer any ambiguity between the + operator, the & operator, and the AND operator, for strings and numbers.
Standard license includes
- A license key that removes the message box
- Full feature set of uCalc Fast Math Parser
- Priority technical support
- Free upgrade(s) up to (and including) version 3.0 of uCalc Fast Math Parser
- Free license for uCalc Language Builder when that becomes available (a $950 value)
- Free serial number for previous versions (upon request)
Lite license
The lite license is for those who want a fast math parser, but don't care for advanced features. You can always upgrade later if necessary.
You get a license code that removes the message box, but with limitations.
The following end-user functions (that is functions that can be used in an expression) are disabled when the lite license option is applied:
- uCalc and uCalcStr (uCalc and uCalcStr are still available at the compiler level),
- uc_For, uc_Loop
- SetSyntaxParams (Macro uses SetSyntaxParams, therefore that is disabled as well)
- Usage of the Table and Stack types is restricted
- ucExpand, ucGetItemData, and ucSetItemData are unavailable
- You are limited to 55 syntax definitions (with ucDefineSyntax)
NOTE: Syntax definitions found in the include file count towards the definition limit, and deplete much of the limit. You can delete some definitions in the include file in order to make room for definitions of your own if necessary. And some definitions may internally count as multiple definitions.
Top 10 Reasons why uCalc customers said they have chosen to buy the uCalc Standard Edition:
1. Speed. When it comes to working with multiple equations at a time, customers have mentioned that uCalc is much faster than other parsers.
2. Customers mentioned flexibility as an advantage over other parsers.
3. Customers also found uCalc FMP very easy to implement in a program.
4. Customers find it easy to add new functions, operators and variables.
5. Customers have chosen uCalc for reliability / stability / quality as they have had bad experiences with other parsers they have tried before.
6. uCalc goes beyond just math/maths expressions, as it can handle strings as well.
7. The new ability to change syntax is considered useful by some customers.
8. Customers found that the multi-threading capability was useful.
9. uCalc is good at catching exceptions and error handling.
10. Customers thought that the uCalc product technical support was beyond what they had experienced with other products.
