public void Integrate(TextBox eqnTextBox, TextBox fromTxtBox, TextBox toTxtBox, Label resultLbl)
{
MathEvaluator me = new MathEvaluator();
string eqn = eqnTextBox.Text;
double area = 0;
double from = double.Parse(fromTxtBox.Text);
double to = double.Parse(toTxtBox.Text);
double sliceWidth = 0.01;
List <double> ys = new List <double>();
while (to >= from)
{
string xString = eqn.Replace("x", ("(" + from + ")"));
xString = xString.Replace("X", ("(" + from + ")"));
ys.Add(me.Evaluate(xString));
from = from + sliceWidth;
}
for (int i = 0; i < ys.Count - 1; i++)
{
area = area + 0.5 * (ys[i] + ys[i + 1]) * (sliceWidth);
}
resultLbl.Text = area + "";
}
private static string RegexMatchEvaluatorResolveMathExpression(Match match)
{
string value = match.Groups[1].Value;
value = VarsRegex.Replace(value, RegexMatchEvaluatorConcatenateZeroIfEmptyCached);
return(MathEvaluator.Evaluate(value).ToString());
}
public char CalculateGrade(Person person)
{
if (string.IsNullOrEmpty(this.gradeFormula))
{
throw new InvalidOperationException("Grade formula must be set");
}
var participant = Participants.SingleOrDefault(x => x.pnr == person.pnr);
if (participant == null)
{
throw new ArgumentException("Person not in this course run.");
}
var evaluator = new MathEvaluator();
foreach (var part in CourseParts)
{
var resultRegistration = participant.GetResult(part.part);
if (resultRegistration.Result.HasValue)
{
evaluator.Variables.Add(part.part, resultRegistration.Result.Value.FromGrade());
}
else
{
return('?');
}
}
return(evaluator.Evaluate(this.gradeFormula).ToGrade());
}
public void Differentiate(TextBox eqnTextBox, TextBox limitTxtBox, Label resultLbl)
{
string eqn = eqnTextBox.Text;
MathEvaluator me = new MathEvaluator();
double limit = double.Parse(limitTxtBox.Text);
double limitX1 = limit - 0.0001;
double limitX2 = limit + 0.0001;
string xString1 = eqn.Replace("x", ("(" + limitX1 + ")"));
xString1 = xString1.Replace("X", ("(" + limitX1 + ")"));
double y1 = me.Evaluate(xString1);
string xString2 = eqn.Replace("x", ("(" + limitX2 + ")"));
xString2 = xString2.Replace("X", ("(" + limitX2 + ")"));
float y2 = (float)me.Evaluate(xString2);
resultLbl.Text = (y1 - y2) / (limitX1 - limitX2) + "";
}
public void equals(TextBox equationTxtBox)
{
MathEvaluator me = new MathEvaluator();
equationTxtBox.Text = me.Evaluate(eqnToEvaluate) + "";
Program.historyController.addEquation(eqnToEvaluate);
Program.historyController.addResult((float)me.Evaluate(eqnToEvaluate));
}
public void Test2()
{
Assert.AreEqual(25, MathEvaluator.Evaluate("(25)"));
Assert.AreEqual(-3, MathEvaluator.Evaluate("(-(3))"));
Assert.AreEqual(6, MathEvaluator.Evaluate("-(-(+6))"));
Assert.Throws <ExpressionEvaluationException>(() => MathEvaluator.Evaluate("((3)"));
}
public BitmapFormula()
{
InitializeComponent();
mInitializing = true;
ev = new MathEvaluator();
ev.AddEnvironmentFunctions(this);
ev.SetVariable("EvalFunctions", new EvalFunctions());
mInitializing = false;
}
public void EvaluateTest2()
{
var expression = "(10 + (-5 * 2))";
var tokens = Tokenizer.Default.GetTokens(expression);
var rpn = MathEvaluator.InfixToRPN(tokens);
Assert.AreEqual(0, MathEvaluator.Evaluate(rpn));
Assert.AreEqual(0, MathEvaluator.Evaluate(expression));
}
public void EvaluateTest3()
{
var expression = "max(10 - 4, 2 + 6)";
var tokens = Tokenizer.Default.GetTokens(expression);
var rpn = MathEvaluator.InfixToRPN(tokens);
Assert.AreEqual(8, MathEvaluator.Evaluate(rpn));
Assert.AreEqual(8, MathEvaluator.Evaluate(expression));
}
public BitmapFormula()
{
InitializeComponent();
mInitializing = true;
ev = new MathEvaluator();
ev.AddEnvironmentFunctions(this);
ev.SetVariable("EvalFunctions", new EvalFunctions());
mInitializing = false;
}
public void InfixToRPNTest4()
{
var tokens = Tokenizer.Default.GetTokens("e^2 + 1");
var rpn = MathEvaluator.InfixToRPN(tokens);
// e 2 ^ 1 +
var expected = new string[] { "e", "2", "^", "1", "+" };
Assert.AreEqual(expected, rpn.ToStringExpression(), "{0}\n{1}", rpn.CollectionToString(s => s.Value), rpn.CollectionToString());
}
public void InfixToRPNTest2()
{
var tokens = Tokenizer.Default.GetTokens("(10 + (-5 * 2))");
var rpn = MathEvaluator.InfixToRPN(tokens);
//10 5 - 2 * +
var expected = new string[] { "10", "5", "-", "2", "*", "+" };
Assert.AreEqual(expected, TokenExtensions.ToStringArray(rpn), "{0}\n{1}", rpn.CollectionToString(s => s.Value), rpn.CollectionToString());
}
public void InfixToRPNTest3()
{
var tokens = Tokenizer.Default.GetTokens("max(10 - 4, 2 + 6)");
var rpn = MathEvaluator.InfixToRPN(tokens);
// 10 4 - 2 6 + max
var expected = new string[] { "10", "4", "-", "2", "6", "+", "max" };
Assert.AreEqual(expected, TokenExtensions.ToStringArray(rpn), "{0}\n{1}", rpn.CollectionToString(s => s.Value), rpn.CollectionToString());
}
public static T Evaluate <T>(RPNExpression expression)
{
try
{
var context = new RPNContext(expression);
while (context.CanMove)
{
context.MoveNext();
if (DefaultEvaluator.Evaluate(context))
{
continue;
}
if (BasicEvaluator.Evaluate(context))
{
continue;
}
if (MathEvaluator.Evaluate(context))
{
continue;
}
if (LogicEvaluator.Evaluate(context))
{
continue;
}
if (StringEvaluator.Evaluate(context))
{
continue;
}
if (RegexEvaluator.Evaluate(context))
{
continue;
}
if (DateTimeEvaluator.Evaluate(context))
{
continue;
}
if (ControlEvaluator.Evaluate <T>(context))
{
continue;
}
context.Stack.Push(context.Current);
}
return(context.GetResult <T>());
}
catch (RPNException)
{
throw;
}
catch
{
throw new ParsingException(expression.Expression);
}
}
public void Test4()
{
Assert.AreEqual(25, MathEvaluator.Evaluate("(3 plus 2) times 10 divided 2"));
Assert.AreEqual(453, MathEvaluator.Evaluate("3 plus (3 times 5) pow 2 times 2"));
Assert.AreEqual(121, MathEvaluator.Evaluate("( 5 plus 6 ) pow 2"));
Assert.AreEqual(-61, MathEvaluator.Evaluate("56 minus ((-2) times 4) plus (-(5 pow 3))"));
Assert.AreEqual(1968.7, MathEvaluator.Evaluate("(3 pow 9 plus 2 times 3 times 4) divided 10.0 minus 2"), Delta);
Assert.AreEqual(25.5 * 3.666, MathEvaluator.Evaluate("25.5 times 3.666"), Delta);
Assert.AreEqual(21.333, MathEvaluator.Evaluate("0.333 plus (5 pow 2) minus 10 divided 2.5"), Delta);
}
public DynamicFormulas()
{
InitializeComponent();
A = new Eval4.Core.Variable<double>((double)updownA.Value, "UpDown A");
B = new Eval4.Core.Variable<double>((double)updownB.Value, "UpDown B");
C = new Eval4.Core.Variable<double>((double)updownC.Value, "UpDown C");
ev = new MathEvaluator();
ev.AddEnvironmentFunctions(this);
ev.SetVariable("EvalFunctions", new EvalFunctions());
}
public void Test3()
{
Assert.AreEqual(25, MathEvaluator.Evaluate("(3 + 2) * 10 / 2"));
Assert.AreEqual(453, MathEvaluator.Evaluate("3 + (3 * 5)^ 2 * 2"));
Assert.AreEqual(121, MathEvaluator.Evaluate("( 5 + 6 )^2"));
Assert.AreEqual(-61, MathEvaluator.Evaluate("56 - ((-2) * 4) + (-(5^3))"));
Assert.AreEqual(1968.7, MathEvaluator.Evaluate("(3 ^ 9 + 2 * 3 * 4) / 10.0 - 2"), Delta);
Assert.AreEqual(25.5 * 3.666, MathEvaluator.Evaluate("25.5 * 3.666"), Delta);
Assert.AreEqual(21.333, MathEvaluator.Evaluate("0.333 + (5 ^ 2) - 10 / 2.5"), Delta);
}
public DynamicFormulas()
{
InitializeComponent();
A = new Eval4.Core.Variable <double>((double)updownA.Value, "UpDown A");
B = new Eval4.Core.Variable <double>((double)updownB.Value, "UpDown B");
C = new Eval4.Core.Variable <double>((double)updownC.Value, "UpDown C");
ev = new MathEvaluator();
ev.AddEnvironmentFunctions(this);
ev.SetVariable("EvalFunctions", new EvalFunctions());
}
static void Main(string[] args)
{
MathEvaluator ev = new MathEvaluator();
ev.Variables.Add("TENA", 2);
var result = ev.Evaluate("2 * TENA");
Console.WriteLine(result);
Console.ReadLine();
}
public void InfixToRPNTest1()
{
var expression = "10 + 5 * 2";
var tokens = Tokenizer.Default.GetTokens(expression);
var rpn = MathEvaluator.InfixToRPN(tokens);
// 10 5 2 * +
var expected = new string[] { "10", "5", "2", "*", "+" };
CollectionAssert.AreEqual(expected, rpn.ToStringExpression(), rpn.Select(s => s.ToString()).AsString());
}
public void EvaluateTest4()
{
var expression = "e^2 + 1";
var tokens = Tokenizer.Default.GetTokens(expression);
var rpn = MathEvaluator.InfixToRPN(tokens);
var result = Math.Exp(2) + 1;
var delta = 0.00001;
Assert.AreEqual(result, MathEvaluator.Evaluate(rpn), delta);
Assert.AreEqual(result, MathEvaluator.Evaluate(expression), delta);
}
public void EvaluateTest5()
{
var expression = "(5 * 2) + 1";
var tokens = Tokenizer.Default.GetTokens(expression);
var rpn = MathEvaluator.InfixToRPN(tokens);
var expectedRPN = new string[] { "5", "2", "*", "1", "+" };
CollectionAssert.AreEqual(expectedRPN, rpn.ToStringExpression(), rpn.ToStringExpression().AsString());
Assert.AreEqual(11, MathEvaluator.Evaluate(expression));
Assert.AreEqual(11, MathEvaluator.Evaluate(rpn));
}
public void SetExpression(string expr)
{
if (eval == null)
{
eval = new MathEvaluator();
}
expression = expr;
try
{
eval.Evaluate(ReplaceVariableForTest(expression));
evaluable = true;
}
catch (Exception)
{
evaluable = false;
}
}
/// <summary>
/// Calcula a expressão das variaveis calculadas
/// </summary>
/// <param name="input"></param>
private double Eval(string input)
{
MathEvaluator _eval = new MathEvaluator();
Stopwatch watch = new Stopwatch();
string answer;
watch.Reset();
watch.Start();
try
{
answer = _eval.Evaluate(input).ToString();
}
catch (Exception ex)
{
answer = ex.Message;
}
watch.Stop();
return(Convert.ToDouble(answer));
}
// Use this for initialization
void Start()
{
CConsole.Log("You can log with different colours", new Color(1, 0.5f, 1));
CConsole.Log("You can log with different colours", Color.green);
CConsole.Log("You can log with different colours", Color.blue);
CConsole.Log("You can log with different colours", Color.magenta);
Debug.Log("CConsole can catches Debug.Log()'s");
Debug.LogWarning("CConsole can catches Debug.LogWarning()'s");
Debug.LogError("CConsole can catches Debug.LogError()'s");
// WithArg Cmd
CConsole.ActionsWithArg.Add("math", (s) =>
{
CConsole.Log(MathEvaluator.Evaluate(s));
});
// NoArg Cmd
CConsole.ActionsNoArg.Add("math", () =>
{
Debug.Log("Example usage\"math 5+3\"");
});
}
//This function responsable for resolving formual and getting the value
private static object GetFormulaFieldValue(PropertyInfo propertyInfo, T entity, FormulaField attFormual)
{
var formualFields = attFormual.Formula.Split(']');
string fieldName = "";
object fieldVal = "";
string formula = "";
PropertyInfo innerPropertyInfo;
object formulaValue = null;
formula = attFormual.Formula;
for (int i = 0; i < formualFields.Length - 1; i++)
{
fieldName = formualFields[i].Split('[')[1];
innerPropertyInfo = entity.GetType().GetProperty(fieldName);
fieldVal = innerPropertyInfo.GetValue(entity, null);
if (fieldVal != null)
{
formula = formula.Replace("[" + fieldName + "]", fieldVal.ToString().Trim());
}
}
if (propertyInfo.PropertyType == typeof(decimal) || propertyInfo.PropertyType == typeof(int) || propertyInfo.PropertyType == typeof(float))
{
formulaValue = MathEvaluator.Evaluate(formula);
SetFieldValue(entity, propertyInfo, formulaValue);
return(formulaValue);
}
//This only will be for default values on not numbers fields
else
{
return(formula);
}
}
public virtual bool Parse()
{
Protocol protocol = ProtocolList.Instance.Find(Packet.ProtocolHeader);
if (protocol == null)
{
return(false);
}
if (string.IsNullOrWhiteSpace(Packet.Data))
{
return(false);
}
string[] array = Packet.Data.Split(splitter);
if (array == null)
{
return(false);
}
if (array.Length == 0)
{
return(false);
}
ReceivedPacketQuery query = new ReceivedPacketQuery()
{
TerminalId = Packet.TerminalId,
ProtocolHeader = Packet.ProtocolHeader,
ReceivedOn = DateTimeHelper.CurrentUniversalTime
};
if (protocol.PageNumberIndex != -1)
{
if (array.Length > protocol.PageNumberIndex)
{
query.PageNumber = int.Parse(array[protocol.PageNumberIndex]);
}
}
Page page = protocol.FindPage(query.PageNumber);
if (page == null)
{
return(false);
}
List <string> values = new List <string>();
foreach (Parameter mapping in page.Parameters)
{
try
{
values.Clear();
foreach (int index in mapping.ParameterIndexes)
{
values.Add(array[index]);
}
string value = string.Format(mapping.Expression, values.ToArray());
if (mapping.ParameterType == ParameterType.Id)
{
query.Id = value;
}
else if (mapping.DataType == DataType.DateTime)
{
DateTime datetime = DateTimeHelper.Parse(value, DateTimeFormat.UK.DateTime);
query.Fields.Add(new Field(mapping.Field, datetime));
}
else if (mapping.Evaluate)
{
MathEvaluator evaluator = new MathEvaluator();
double val = Math.Round(evaluator.Evaluate(value), mapping.Precision);
query.Fields.Add(new Field(mapping.Field, val));
query.AddField(new Field(mapping.Field, val));
}
else
{
if (mapping.EnableDataType &&
(mapping.DataType == DataType.Integer ||
mapping.DataType == DataType.Double))
{
if (!ConversionHelper.IsNumeric(value))
{
// do stuff here
}
}
//query.Fields.Add(new Field(mapping.Field, value));
query.AddField(new Field(mapping.Field, value));
}
}
catch (Exception ex)
{
LoggingManager.Log(ex);
return(false);
}
}
try
{
//QueryExecutor.ExecuteWithLock(query.RealTimeQuery());
//QueryExecutor.Execute(query.SiteQuery());
}
catch (Exception ex)
{
LoggingManager.Log(ex);
return(false);
}
try
{
//QueryExecutor.Execute(query.SiteQuery());
}
catch (Exception ex)
{
LoggingManager.Log(ex);
return(false);
}
return(true);
}
public void drawGraph(Panel graphPnl, TextBox fromText, TextBox toText, TextBox eqnText)
{
// Declaring
List <float> xs = new List <float>(), ys = new List <float>();
//Getting Range
float from = float.Parse(fromText.Text), to = float.Parse(toText.Text);
//getting eqn
string eqn = eqnText.Text;
//Scaling Parameters
float PANELX = graphPnl.Size.Width;
float PANELY = graphPnl.Size.Height;
float fMax = float.MinValue;
float fMin = float.MaxValue;
// Computing Points
MathEvaluator me = new MathEvaluator();
float j = from;
while (j < to)
{
string xString = eqn.Replace("x", ("(" + j + ")"));
xString = xString.Replace("X", ("(" + j + ")"));
float y = (float)me.Evaluate(xString);
float x = j;
fMax = (y > fMax) ? y : fMax;
fMin = (y < fMin) ? y : fMin;
xs.Add(x);
ys.Add(-(y));
j += 0.001f;
}
if (from > 0)
{
from = 0;
}
if (to < 0)
{
to = 0;
}
if (fMax < 0)
{
fMax = 0;
}
if (fMin > 0)
{
fMin = 0;
}
// Scaling X values
float factorX = PANELX / (to - from);
for (int i = 0; i < xs.Count; i++)
{
xs[i] = xs[i] * factorX;
}
// Scaling Y values
float factorY = PANELY / (fMax - fMin);
for (int i = 0; i < ys.Count; i++)
{
ys[i] = ys[i] * factorY;
}
// Drawing From Computed Data
Pen graphPen = new Pen(Color.Red, 3);
Pen axisPen = new Pen(Color.White, 3);
Graphics g = graphPnl.CreateGraphics();
g.Clear(graphPnl.BackColor);
//Draw X axis
g.DrawLine(axisPen, 0, (fMax * factorY), PANELX, (fMax * factorY));
//Drawing Y axix
g.DrawLine(axisPen, -(from * factorX), 0, -(from * factorX), PANELY);
//Drawing Graph
for (int i = 1; i < xs.Count; i++)
{
g.DrawLine(graphPen, xs[i - 1] - (from * factorX), ys[i - 1] + (fMax * factorY), xs[i] - (from * factorX), ys[i] + (fMax * factorY));
}
g.Dispose();
}
/// <summary>
/// 初始化一个<see cref="MathEvaluatorTest"/>类型的实例
/// </summary>
public MathEvaluatorTest()
{
_evaluator = new MathEvaluator();
}
public override void DeriveToStack(MathEvaluator.ExpressionTree cur, MathEvaluator.MathState s, MathEvaluator.StaticStack<MathOperation> DeriveStack)
{
throw new MathEvaluator.Exceptions.UndefinedResultException(ToString() + " is not derivable");
}
public void Test9()
{
double result = MathEvaluator.Evaluate("Sum(4, Sqrt(25), Max(1, 2, 3))");
Assert.AreEqual(12, result);
}
public void Setup()
{
eval = new MathEvaluator();
}
public void Test10()
{
double result = MathEvaluator.Evaluate("Sum(3, (10), Sqrt(25), Max(1, 2, 3))");
Assert.AreEqual(21, result);
}
