Features:

• 5 base type - Integer, Extended, Boolean, String, DateTime;
• Arithmetic operators ( +, -, *, /, Div, Mod, ^ );
• Comparison operators ( >, <, =, <>, >=, <= ) for all types;
• Logical operators for boolean types (And, Or, Xor);
• 47 built-in functions;
• Unlimited amount of On-Event evaluated functions and variables;
• Unlimited amount of run-time defined functions and variables;
• Using field names of dataset as variables;
• Pseudo compilation of text for fast repeated evaluation;
• Full error handling;
• Comments in a text of expression;
• Customizable String/Comment signs;
• Denotation of two StringSignes in string as one sign;
• String constant with DateTime format as DateTime constant;
• Multilevel calling of subexpressions in evaluated On-Events;
• Saving library of variables and functions in a file;
• Initialization of variables using expressions in one text box;
• Links between variables of application and run-time variables of component;
• High speed (12 000 - 60 000 evaluations per sec. on 2GHz CPU);
• Full help and demo.

Provides:

• 7 arithmetic operations
• 10 logical operations
• 6 bitwise operations
• string concatenation & like operator
• 24 arithmetic functions
• 10 statistical functions
• 2 logical functions
• 17 string functions
• 13 date functions
• 14 programming functions
• User defined constant
• User defined variables
• User defined functions (modules).
• Subroutines, global const and vars definition
• Symbolical differentiation of functions with basic simplification of resulting derivatives

• Variables definitions and assignment statement
• Increment and Decrement operations
• Return function
• Compound statement (BEGIN... END)
• IF statement
• WHILE loop
• UNTIL loop
• FOR loop
• Interface functions: msg('text', 'caption', props), input('caption', 'text', defvalue).
• Defining subroutines, global const and vars.

Change Log:

• version 0.02:
  • Read/write variable to XML
• version 0.01:
  • improved precision of bfVal for extended values,
  • Faster PI calculation - based on pi=176*arctan(1/57) + 28*arctan(1/239) - 48*arctan(1/682) + 96*arctan(1/12943)
  • faster bfLn
  • on-spot constants re-calculation
  • thanx to: Sasa Zeman (www.szutils.net)
• version 0.0: first version available...

Perl and DFA matching algorithms are available. The syntax is Perl 5.8 compatible and includes

• Full substring capturing
• Named substrings
• Case in/sensitive matching
• Greedy and non-greedy repetition quantifiers
• Backtracking
• Assertions
• Much more ...

• Format
• Replace
• List.

• TDIRegExMaskEdit
• TDIRegExComboBox.

• Full HTML-Help
• RegEx Workbench
• Demo projects
• Examples of regular expressions.

What is a incremental dataflow constraint solver? Simply put, it maintains relationships between variables and when a variable changes, automatically computes which variables are dependant and what their new values should be.

For example: Given the constraint A + B = C, when either A or B changes, C will be recalculated; But if C changes, Delta Blue will also recalculate A or B depending on the strength of the constraint.
 
Fully functional
Source: Included

Features:

• Full set of operators
• More than 20 built-in functions
• Implicit parentheses
• Variables using a StringGrid
• Result can be a Double number or a formated string.

The math expressions is represented as string in a function style F(x1, x2,..., xn) =f(x1, x2,..., xn), where F(x1, x2,..., xn) - declares number and names of the variables;

f(x1, x2,..., xn) - math expression may contain:

• variables x1, x2,..., xn and numbers,
• arithmetic operations + - * / ^,
• supporting a large set of math functions: sqrt, sin, exp, cos, tan, ln, abs, acos, asin, atan, cosh, log10, sinh, tanh,
• constants e= 2.71828182845904 and pi= 3.14159265358979, and
• user defined functions and constants.

• F(x, y) = 3*x^2+y^2+e/4,
• F(x1, x2, y) = (x1-sin(x2))/y,
• F()=5+6+pi.

It needs Expression Parser to be installed.
 
Fully functional
Source: On purchase/registration
Source Price: $25

• user defined functions and aliases;
• supports: if...then..else...;for...:=... to/downto ... do ; while...do...; repeat...until...;
• try finally end; try except end; raising exceptions;
• class creating, referencing any published property of any class;
• and more than 800 registered public methods and properties of more than 100 useful Delphi VCL classes;
• creating and referencing OLE automation objects;
• links directly in a script to a runtime components, that can be also on a data module;
• links to any runtime function or class method;
• calling user defined scripts from the program;
• executing a script generated script;
• variables, can be a value, expression, DBField or a link to a runtime var;
• syntax checking of the scripts, checks also for using a valid variables, functions and arguments;
• request for used variables, by a given script, that need initialization;
• on event evaluated functions and variables;
• supports integer, hex, FP, boolean, date string and variant type constants;
• design time editors for variables and functions, that can be loaded and saved in INI file;
• special links of dependences, tracks the changes in related objects;
• more than 200 build in functions;
• enhance error handling;
• full help and demo.

Main properties:

• unlimited length and nested of expression
• addition floatpoint variables and parameters and integer variables
• addition external functions with unlimited and indefinite number variables
• many stages high performance compiler.

Functions include:

• Add, subtract, multiply, divide, mod
• GCD
• Power, Sqrt
• PowerAndMod, ModInv
• Prime checking.

The linear program solver is based on Interior-Point method that is know to outperform Simplex method specially for a big problem.

The user can specify the linear program using a set of exported DLL functions or import from a file in Mathematical Programming System (MPS) format.

Key features of GIPALS32:

• Unlimited linear program size.
• No external components or DLL are required.
• Simple way to specify a linear program without any special mathematical knowledge.
• Robust Interior-Point method for fast and reliable solution.
• Support the industrial standard format of linear programs.

KCompiler checks the syntax of given expression and generates real machine code to evaluate it. The code is highly optimized for x86-compatible processors produced since 1995, so formula evaluation process with KCompiler becomes faster than evaluation of the same formula with the most of other compilers, for example, Borland Delphi.

You can easily extend possibilities of KCompiler with functions in your Delphi program and they will be called in the fastest way or use free library KLib (included). Also you may add external variables of different types (the most of Delphi scalar types are included).

Use KCompiler to calculate formulas that are unknown at the stage of program compilation or to achieve greater speed with your Delphi application.

Major features:

• common arithmetic operations +, -, *, / and parenthesis (, )
• expression simplifying
• deep analyzing of formula
• great speed of calculations
• large set of optimizations
• syntax errors handling
• data alignment
• extendable variable list
• large set of supported variables' types
• extendable function list
• quick function parameters passing
• smart function call mode
• support for multithreaded computing.

TMathRRR: Is a component that graphics mathematical expresions of the form y=f(x): sin(x), cos(x), sin(x)*x, x/2, log(x)*sin(x)-x are examples of mathematical expressions that can be shown. The functions that can be used in expresions are:

• Sin: Sine
• Cos: Cosine
• Tan: Tangent
• Cot: Cotagent
• Sec: Secant
• Csc: Cosecant
• Custom: Custom function, you can use all the functions ant to use the +, -, *, / and ^ operators.
• Exp: e^x
• Log: Locarithm natural
• Atn: Arcotangent (Tan^-1)
• Asn: Arcosine (sin^-1)
• Acs: Arcocosine (cos^-1)
• Abs: Abosulte value
• Neg: Negative
• Sqr: Square
• Sqrt: Square root
• Sinh: Hyperbolic sine
• Cosh: Hyperbolic cosine
• Tanh: Hyperbolic sine.

TEvalRRR is a component that evaluate the same functions that TMathRRR and can trap errors in the case that there are errors in the evaluation or in the expression. Please, see the demo.
 
With Nag-Screen
Source: On request
Price: $20
Exe-Demo Included

Components and units, mentioned above, contain a number of high-speed simple methods having the singular input parameter of string type, which represents the mathematics expression, and returning the number (AsByte, AsInteger, AsBoolean, etc.). It makes possible using the parse components at any time without unnecessary understanding the internal parse mechanisms.

It is possible making a user-defined functions, variables, constants and types. It is also possible making a direct reference to the simple variable of type like Byte, Integer, etc. Each number is represented by structure able to keep the variable of almost any primitive type. Within the calculation process the numbers and their types are being changed to fit the execution result. It means that if we have an expression "(Byte 2) * (Byte 2)" then the result type is being set to Integer to fit the maximum possible value of two Byte type numbers multiplication. The numbers are being changed the same way when optimizing the expression.

The components are not free, except for using in science purpose - in this case the science license is required; the science license allows to declare the unlimited number of user-defined functions. There are no restrictions making impossible using the components for non-commercial purpose in case of having no license. The only limitation is the number of user-defined functions. In any case you are able to define as minimum as ten functions for free (non-commercial use only).
 
Fully functional
Source: None
Exe-Demo Included

Syntax:

• IF ... THEN {...} [ELSE {...}]
• WHILE ... DO {...}
• BREAK
• CONTINUE
• PROCEDURE {...}
• EXEC
• EXIT
• BEEP.

You can use the equation editor in your projects written in the Delphi environment, for example, in programs testing knowledge of different mathematics fields (mathematical analysis, discrete mathematics, probability theory and so on), physics and other.

It’s quite easy to enter formulas in it:

• simple symbols are entered similarly to entering data in a text field;
• special symbols and formula elements are entered with the help of an additional menu.

In addition the unaRegExp class provides an easy way for matching different strings with same RegEx avoiding unnecessary parsing.

Two console samples included shows how to use the library.
 
Fully functional
Source: Included

Besides basic, it supports also extended function name syntax, allowing you to use any special character, except [ and ], in the function name, thanks to Dmitry Yakubovich.
 
Fully functional
Source: Included

Example:

• Command: (134.55 + 28.97) * ((48.144 - 39.091) - 17), Result: -1299.49344
• Command: (134.55 + 28.97) * ((48.144 - 39.091) - 17) > 14, Result: False
• Command: ((134.55 + 28.97) * ((48.144 - 39.091) - 17) > 14) OR (4>2.2/3.3), Result: True.

TbcParser Component features include:

• Easy to use component API.
• Comes with predefined functions.
• You can create custom functions/variables and get a callback to your own functions that you define in your source code.
• Optimization: Constant expression elimination for repeated tasks.
• Analytic Operators: +, -, /, *, ^
• Logical Operators: <, >, =, &, |, ., <>, <=, >=
• Paranthesis: (, {, [
• Functions in the form of: f(x,y,z,...)
• List of predefined functions is available in the documentation.
• Royalty free distribution at affordable price.
• Source code is included.