Steve Heberts dotMath Library

Source code checked in, #99885

Project Collection Service Accounts — Mon, 01 Oct 2012 21:24:31 GMT

Upgrade: New Version of LabDefaultTemplate.xaml. To upgrade your build definitions, please visit the following link: http://go.microsoft.com/fwlink/?LinkId=254563

Source code checked in, #99884

Project Collection Service Accounts — Mon, 01 Oct 2012 21:16:08 GMT

Checked in by server upgrade

Commented Issue: Complex calculation [25995]

fernandezajp — Wed, 20 Apr 2011 14:39:01 GMT

if(4>5,10,100) * 5 ====> 500 but not calculated correctly.
Comments: ** Comment from web user: fernandezajp **

replace SetFunction( sEquation ); by SetFunction( "("+sEquation+")" );
in EqCompiler constructor

Source code checked in, #74794

_TFSSERVICE — Tue, 03 Aug 2010 19:44:57 GMT

Checked in by server upgrade

Created Issue: Complex calculation [25995]

tunzey — Wed, 20 Jan 2010 19:01:59 GMT

if(4>5,10,100) * 5 ====> 500 but not calculated correctly.

Source code checked in, #34065

sdhebert — Fri, 20 Jun 2008 16:02:23 GMT

Fleshed out tests for token and whitespace handling to obtain 100% code coverage

Source code checked in, #34059

sdhebert — Thu, 19 Jun 2008 11:08:55 GMT

Added Token.Equals override tests

Source code checked in, #34058

sdhebert — Thu, 19 Jun 2008 11:00:50 GMT

Added GetHashCode Tests

Source code checked in, #34057

sdhebert — Thu, 19 Jun 2008 10:49:20 GMT

Add Token constructor tests

Source code checked in, #34056

sdhebert — Thu, 19 Jun 2008 10:29:37 GMT

Added CharType enumeration

Source code checked in, #34055

sdhebert — Thu, 19 Jun 2008 03:12:09 GMT

Initial checkin with base tests

COMMENTED ISSUE: Boolean expressions

exigeguy — Wed, 06 Feb 2008 20:12:46 GMT

Hi, I had been testing this library, it's awsome, but It looks like the boolean expressions have some problems an expression like "100>50 and 30>50" returns "1" instead of "0" (False), and "30>50 and 100>50" returns "0". I think that the Calculate() methos is only evaluating the first part of the expression.

Richo
Comments: ** Comment from web user: exigeguy **

I tried your test case and I was able to get it to work by wrapping either side of the and with parenthesis, e.g. (100 > 50) && (30>50). I had to add the CAnd operator in the InitFunctions() method. The problem is it gets fouled up trying to evaluate complex logical expressions because it is trying to evaluate 50 && 30>50 instead of maintaining the expression to the left of the && operator. I fixed it locally and also added support for string operations.

CREATED ISSUE: Boolean expressions

ralcorta — Tue, 04 Sep 2007 17:14:47 GMT

NEW POST: In Commercial Library...

SelormeyPaul — Thu, 07 Jun 2007 03:57:26 GMT

I am creating a commercial charting library for my company. Can I include this library for user-typed
equation/function processing?

Best regards,
Paul.

New Post: In Commercial Library...

SelormeyPaul — Thu, 07 Jun 2007 03:57:26 GMT

I am creating a commercial charting library for my company. Can I include this library for user-typed
equation/function processing?

Best regards,
Paul.

UPDATED WIKI: The History of dotMath

sdhebert — Thu, 26 Oct 2006 01:50:06 GMT

A Brief History of dotMath

Initial Design

The initial design of .Math came about in 1997 with a need to create a function evaluator in C++. After looking around for commercial libraries, the pieces available generally reached a complexity we weren’t requiring and too expensive. We had a need for fairly simple equations (such as 4x^2 + 2x +24) where we would perform a wide range of values for x and evaluate each one. I went back to my college compiler books, read up on the subject and decided I could handle the problem myself. I decided to expose the variables thorough an interface and allow them to be discovered and set. At this point the code supported a minimal set of trig-functions. This implementation ran approximately 75,000 calculations per second on a Pentium 2 450.

Creating the Compiler

I used similar implementations on other projects and contemplated createing a ‘true’ compiler. The speed increase would be significant, but never significant enough to warrant the time spent. Then, in 2000, I decided to go ahead tackle the problem. It became apparent I could make this into a nice O-O based structure with the implementation classes compiled in C++ and instantiated as-needed. This structure gave me the opportunity to make the compiler extensible by registering new functions with the framework. Given the O-O framework, the first two-passes are handled by the code, while the linking was handled during the application compile. It’s a different way of looking at the compilation problem, but much simpler in terms of building and delivering the solution. I took this implementation and ported it to an early Visual Basic.NET implementation to test how the new language O-O features behaved.

Multi-Parameter Functions and Binary Operators

Shortly after creating the compiler, the need for more complex functions arose. These functions were modeled after the Excel format with comma-separators. I quickly realized that each function within the statement could be handled as a separate compiled function that shared the same variable space with the rest of the equation. At that point, the implementation became very simple. The most intriguing function then became the If-statement as such:

if( condition, then-result, else-result )

The if-statement required the use of binary operators (<, >, <=, <>, etc). The binary operation returns a 1 for true or a 0 for false. The if statement only tests for 0 equality – perform else portion if 0, otherwise perform then portion.

Porting to C# and the .NET Platform

I ported the code to C# in 2003 out of interest in reviving the code. I later used the project in 2004 to provide dimensionality support to a planning application.

Looking Ahead

There are a number of directions the code can take, including code optimization and levelization of the called objects. Levelization offers the biggest payback because the current implementation relies heavily on the call-stack. Getting away from the call-stack will remove the reliance on the memory allocations and jumps that become significant when doing millions of operations. I believe levelization of the function calls would involve using an accumulator structure for storing operation values one at a time.

UPDATED WIKI: Built-in functions and operators

sdhebert — Thu, 26 Oct 2006 01:49:55 GMT

Built-in Operators and Functions

The following lists show the built-in functions and operators that are included in dotMath. You can add your own functions by creating classes and registering with dotMath before compiling. Check out Getting Started - How to use dotMath to learn more.

Binary Operators

Operator	Description
=	Returns 1 if both sides are equal.
<	Returns 1 if left side is less than the right.
>	Returns 1 if left side is greater than the right.
<=	Returns 1 if the left side is less than or equal to the right.
>=	Returns 1 if the left side is greater than or equal to the right.
<>	Returns 1 if the left side is not equal to the right.
&	Returns 1 if both sides are not equal to 0
	Returns 1 if one or both sides are not equal to 1.

Built-in Functions

Function	Description
Abs	Absolute value of a specified value or expression.
Acos	Returns the angle whose cosine is the specified number.
Asin	Returns the angle whose sin is the specified number.
Atan	Returns the angle whose tangent is the specified number.
Ceiling	Returns the smallest whole number greater than or equal to the specified number.
Cos	Returns the cosine of the specified angle.
Cosh	Returns the hyperbolic cosine of the specified angle.
Exp	Returns e raised to the specified power.
Floor	Returns the largest whole number less than or equal to the specified number.
Log	Returns the logarithm of the specified number.
Log10	Returns the base 10 logarithm of the specified number.
Round	Returns the value nearest the specified value.
Sign	Returns a value indicating the sign of the specified value.
Sin	Returns the sine of the specified angle.
Sinh	Returns the hyperbolic sine of the specified angle.
Sqrt	Returns the square root of the specified number.
Tan	Returns the tangent of the specified angle.
Tanh	Returns the hyperbolic tangent of the specified angle.
Min	Min(expr1, expr2, …, expr(n)) Min returns the minimum value among the list of evaluated expressions. The list may contain 2 or more elements. Highest current test uses 50,000 values in the expression list.
Max	Max(expr1, expr2, …, expr(n)) Max returns the maximum value among the list of evaluated expressions. The list may contain 2 or more elements. Highest current test uses 50,000 values in the expression list.
If	If( binaryexpression, trueexpression, falseexpression ) If the value of binaryexpression is non-zero, the trueexpression evaluation is returned. Otherwies the falseexpression is returned.

UPDATED WIKI: Getting Started - How to use dotMath

sdhebert — Thu, 26 Oct 2006 01:49:43 GMT

How to use dotMath

The following page is focused on understanding how to use dotMath in your application and get up and running in the shortest amount of time.

If you are using the compiled assembly library, be sure to create a reference to the .Math library and include the library DLL in your distribution package.

Scenario 1: Evaluating an Expression

In order to take an expression without variables stored in a string – sExpression – and evaluate its value we need the following set of code.

sExpression = “4+3”;
EqCompiler oCompiler = new EqCompiler( sExpression, true);
oCompiler.Compile();
double dValue = oCompiler.Calculate();

If you do not perform the ‘.Compile()’ step, it will be executed automatically the first time you perform ‘.Calculate();’. Wherever the compile step is performed it is important to place a try..catch block around it to capture any compilation errors. All errors raised by the compilers are ApplicationExceptions.

Scenario 2: Evaluating an Expression with Variables

Taking advantage of expressions with variables involves discovering the variables and setting them before performing the .Calculate() step.

sExpression = “a+b”;
EqCompiler oCompiler = new EqCompiler( sExpression, true);
oCompiler.Compile();
string[] asVars = oCompiler.GetVariableList();
// At this point we have the variable list and we can do what we want.
// Here, we’ll set the values of each variable using the interface…
double dValue = 1.0;
foreach (string sVar in asVars)
{
       oCompiler.SetVariable( sVar, dValue );
       dValue = dValue +1.5;    
}
// at this point we’re ready to calculate the expression with our declared variable values.
double dValue = oCompiler.Calculate();

Scenario 3: Adding user-defined functions to the compiler’s syntax.

The .Math library allows the user to extend the syntax of functions by creating classes and registering them with the compiler. In this case, we’ll create a function called Pythag(a,b) where given the length of side a and the length of side b, we’ll return side c (assuming we’re dealing with a right triangle).

First, we’ll create our class:

using dotMath;
/// <summary>
/// CTanh class: Returns the hyperbolic tangent of the supplied angle.
/// </summary>
public class CPythag : EqCompiler.CFunction 
{
         ArrayList m_alValues;
         public CPythag( )       
         {
         }
          /// <summary>
         /// CreateInstance: this function is used to create
         /// and return an object for evaluation of Pythag(a,b)
         /// </summary>
         public override EqCompiler.CFunction CreateInstance( ArrayList alValues ) 
         {
                  CPythag oPythag = new CPythag();
                  oPythag.SetValue( alValues );
                  return oPythag;
         }
          /// <summary>
         /// SetValue(ArrayList): this function accepts an arraylist
         /// of CValue objects that represent the parameters passed.
         /// </summary>
         public override void SetValue( ArrayList alValues )
         {
                  /// CheckParms is a CFunction member that validates
                  // the number of parameters.  It throws an exception
                  // formatted for the client if a mismatch occurs.
                  CheckParms(alValues,2);
                  m_alValues = alValues;
         }
         /// <summary>
         /// GetValue(): returns the evaluated function value during
         /// the .Calculate process.
         /// </summary>
         public override double GetValue()
         {
                  EqCompiler.CValue oValue1 = (EqCompiler.CValue) m_alValues[0];
                  EqCompiler.CValue oValue2 = (EqCompiler.CValue) m_alValues[1];
                  return Math.Sqrt(Math.Pow(oValue1.GetValue(),2) + Math.Pow(oValue2.GetValue(),2));       }
          public override string GetFunction()
         {
                  return "pythag";
         }
}

When we’re ready to evaluate the function, the following code enables the function:

string sFunction = “pythag(2,4)”;
EqCompiler eq = new EqCompiler( txtFunction.Text.Trim(),true);
eq.AddFunction( new CPythag() );

UPDATED WIKI: Home

sdhebert — Thu, 26 Oct 2006 01:49:24 GMT

Welcome to the dotMath Library

Welcome to dotMath, the extensible OpenSource expression compiler for the .NET platform written entirely in C#. Offering speed through compilation of expressions, the library allows for variable handling, an entire function library and the ability to add your own functions.

If you need to evaluate fixed or variable expressions, dotMath is your solution:

fixed expression example: (sin(5)* cos(4/5)) / 3
variable expressions example: (sin(a)* cos(b/a)) / c

Download the Version 1.0 release here... [release:875]

Getting Started - How to use dotMath
Built-in functions and operators

The History of dotMath