Also you can define your own functions, those functions can contain from zero to any number of parameters, to define your own functions, you must define a delegate function of the following type "EvaluateFunctionDelegate" this type is define in Function.cs, then call the "DefaultFunctionEvaluation" property member to set your delegate function, all the functions that you have defined in the delegate function, will be added to the built in function.

Also the variable "pi" is internally recognized as 3.14159265358979,and the variable "e" is internally recognized as 2.71828182845905, if any error happen whatever the error type, the Error property will return true and the Description of  the Error will be returned by the ErrorDescription property member.

Here some examples of how to use the Function class:           

//-- Example 1, Simple --
Function fn = new Function();
fn.Parse("1+2");
fn.Infix2Postfix();
fn.EvaluatePostfix();
double nResult = fn.Result;
//----------------------------------------------
//-- Example 2, How to use built in function --
Function fn = new Function();
fn.Parse("1+2*5-cos(pi)");
fn.Infix2Postfix();
fn.EvaluatePostfix();
double nResult = fn.Result;
//---------------------------------------------
//-- Example 3, How to use variable --
Function fn = new Function();
fn.Parse("x+2*y-cos(pi)");
fn.Infix2Postfix();
ArrayList var = fn.Variables;
foreach(Symbol sym in var)
{
if(sym..m_name == "x")
sym.m_value = 1;
else if(sym..m_name == "y")
sym.m_value = 5;
}
fn.Variables = var;
fn.EvaluatePostfix();
double nResult = fn.Result;
//-------------------------------------------------
//-- Example 4, How to use recursive function call --
Function fn = new Function();
fn.Parse("sin(cos(pi)*pi/2)");
fn.Infix2Postfix();
fn.EvaluatePostfix();
double nResult = fn.Result;
//-------------------------------------------------
The other part of the program is to demonstrate how to use the Function class, and also it
emonstrate how to use DataGrid as a normal Grid to show the symbol table without any
atabase connection, to use this program after compiling the program write any
athematic expression in the edit box then click parse, if the expression contain any variable, you can change the value of this variable in the DataGrid Control, after that click on Evaluate to see the result.
///
///This class Function use the transformation from infix notation to postfix notation to evalute most
///Mathematic expression, it support most operators (+,-,*,/,%,^), functions from 0 to any number of parameters
///and also a user defined function by using delegate, also it support variables in the expression, it will
///generate a symbol table that can be updated at run time.
///
using System;
using System.Collections;
namespace EB.Math
{
///
///
///
public enum Type{Variable,Value,Operator,Function,Result,Bracket,Comma,Error}
public struct Symbol
{
public string m_name;
public double m_value;
public Type m_type;
public override string ToString()
{
return m_name;
}
}
public delegate Symbol EvaluateFunctionDelegate(string name, params Object[] args);
public class Function
{
public double Result
{
get
{
return m_result;
}
}
public ArrayList Equation
{
get
{
return (ArrayList)m_equation.Clone();
}
}
public ArrayList Postfix
{
get
{
return (ArrayList)m_postfix.Clone();
}
}
public EvaluateFunctionDelegate DefaultFunctionEvaluation
{
set
{
m_defaultFunctionEvaluation = value;
}
}
public bool Error
{
get
{
return m_bError;
}
}
public string ErrorDescription
{
get
{
return m_sErrorDescription;
}
}
public ArrayList Variables
{
get
{
ArrayList var = new ArrayList();
foreach(Symbol sym in m_equation)
{
if((sym.m_type == Type.Variable) && (!var.Contains(sym)))
var.Add(sym);
}
return var;
}
set
{
foreach(Symbol sym in value)
{
for(int i=0;i0)
{
tpSym = (Symbol)tpStack.Pop();
while((tpSym.m_name != "(") && (tpSym.m_name != "[") && (tpSym.m_name != "{"))
{
m_postfix.Add(tpSym);
tpSym = (Symbol)tpStack.Pop();
}
}
}
else
{
if(tpStack.Count > 0)
{
tpSym = (Symbol)tpStack.Pop();
while((tpStack.Count != 0) && ((tpSym.m_type == Type.Operator) ||
(tpSym.m_type == Type.Function) || (tpSym.m_type == Type.Comma)) && (Precedence(tpSym) >= Precedence(sym)))
{
m_postfix.Add(tpSym);
tpSym = (Symbol)tpStack.Pop();
}
if(((tpSym.m_type == Type.Operator) || (tpSym.m_type == Type.Function) || (tpSym.m_type == Type.Comma)) && (Precedence(tpSym) >= Precedence(sym)))m_postfix.Add(tpSym);
else
tpStack.Push(tpSym);
}
tpStack.Push(sym);
}
}
while(tpStack.Count > 0)
{
tpSym = (Symbol)tpStack.Pop();
m_postfix.Add(tpSym);
}
}
public void EvaluatePostfix()
{
Symbol tpSym1, tpSym2, tpResult;
Stack tpStack = new Stack();
ArrayList fnParam = new ArrayList();
m_bError = false;
foreach(Symbol sym in m_postfix)
{
if((sym.m_type == Type.Value) || (sym.m_type == Type.Variable) ||(sym.m_type == Type.Result))
tpStack.Push(sym);
else if(sym.m_type == Type.Operator)
{
tpSym1 = (Symbol)tpStack.Pop();
tpSym2 = (Symbol)tpStack.Pop();
tpResult = Evaluate(tpSym2, sym, tpSym1);
if(tpResult.m_type == Type.Error)
{
m_bError = true;
m_sErrorDescription = tpResult.m_name;
return;
}
tpStack.Push(tpResult);
}
else if(sym.m_type == Type.Function)
{
fnParam.Clear();
tpSym1 = (Symbol)tpStack.Pop();
if((tpSym1.m_type == Type.Value) || (tpSym1.m_type == Type.Variable) || Sym1.m_type == Type.Result))
{
tpResult = EvaluateFunction(sym.m_name,tpSym1);
if(tpResult.m_type == Type.Error)
{
m_bError = true;
m_sErrorDescription = tpResult.m_name;
return;
}
tpStack.Push(tpResult);
}
else if(tpSym1.m_type == Type.Comma)
{
while(tpSym1.m_type == Type.Comma)
{
tpSym1 = (Symbol)tpStack.Pop();
fnParam.Add(tpSym1);
tpSym1 = (Symbol)tpStack.Pop();
}
fnParam.Add(tpSym1);
tpResult = EvaluateFunction(sym.m_name,fnParam.ToArray());
if(tpResult.m_type == Type.Error)
{
m_bError = true;
m_sErrorDescription = tpResult.m_name;
return;
}
tpStack.Push(tpResult);
}
else
{
tpStack.Push(tpSym1);
tpResult = EvaluateFunction(sym.m_name);
if(tpResult.m_type == Type.Error)
{
m_bError = true;
m_sErrorDescription = tpResult.m_name;
return;
}
tpStack.Push(tpResult);
}
}
}
if(tpStack.Count == 1)
{
tpResult = (Symbol)tpStack.Pop();
m_result = tpResult.m_value;
}
}
protected int Precedence(Symbol sym)
{
switch(sym.m_type)
{
case Type.Bracket:
return 5;
case Type.Function:
return 4;
case Type.Comma:
return 0;
}
switch(sym.m_name)
{
case "^":
return 3;
case "/":
case "*":
case "%":
return 2;
case "+":
case "-":
return 1;
}
return -1;
}
protected Symbol Evaluate(Symbol sym1, Symbol opr, Symbol sym2)
{
Symbol result;
result.m_name = sym1.m_name + opr.m_name + sym2.m_name;
result.m_type = Type.Result;
result.m_value = 0;
switch(opr.m_name)
{
case "^":
result.m_value = System.Math.Pow(sym1.m_value,sym2.m_value);
break;
case "/":
{
if(sym2.m_value > 0)
result.m_value = sym1.m_value / sym2.m_value;
else
{
result.m_name = "Divide by Zero.";
result.m_type = Type.Error;
}
break;
}
case "*":
result.m_value = sym1.m_value * sym2.m_value;
break;
case "%":
result.m_value = sym1.m_value % sym2.m_value;
break;
case "+":
result.m_value = sym1.m_value + sym2.m_value;
break;
case "-":
result.m_value = sym1.m_value - sym2.m_value;
break;
default:
result.m_type = Type.Error;
result.m_name = "Undefine operator: " + opr.m_name + ".";
break;
}
return result;
}
protected Symbol EvaluateFunction(string name, params Object[] args)
{
Symbol result;
result.m_name = "";
result.m_type = Type.Result;
result.m_value = 0;
switch(name)
{
case "cos":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Cos(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "sin":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Sin(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "tan":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Tan(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "cosh":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Cosh(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "sinh":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Sinh(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "tanh":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Tanh(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "log":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Log10(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "ln":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Log(((Symbol)args[0]).m_value,2);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "logn":
if(args.Length == 2)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + "'" +
((Symbol)args[1]).m_value.ToString() + ")";
result.m_value = System.Math.Log(((Symbol)args[0]).m_value,((Symbol)args1]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "sqrt":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Sqrt(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "abs":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Abs(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "acos":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Acos(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "asin":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Asin(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "atan":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Atan(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
case "exp":
if(args.Length == 1)
{
result.m_name = name + "(" + ((Symbol)args[0]).m_value.ToString() + ")";
result.m_value = System.Math.Exp(((Symbol)args[0]).m_value);
}
else
{
result.m_name = "Invalid number of parameters in: "+ name +".";
result.m_type = Type.Error;
}
break;
default:
if(m_defaultFunctionEvaluation != null)
result = m_defaultFunctionEvaluation(name,args);
else
{
result.m_name = "Function: "+ name +", not found.";
result.m_type = Type.Error;
}
break;
}
return result;
}
protected bool m_bError = false;
protected string m_sErrorDescription = "None";
protected double m_result = 0;
protected ArrayList m_equation = new ArrayList();
protected ArrayList m_postfix = new ArrayList();
protected EvaluateFunctionDelegate m_defaultFunctionEvaluation;
}