public void ParseArguments(string[] args)
{
if (args != null)
{
foreach (string str in args)
{
if (IsArgument(str))
{
string argumentValue;
var argumentName = GetArgumentName(str, out argumentValue);
if (!string.IsNullOrEmpty(argumentName) && ArgumentsMap.ContainsKey(argumentName))
{
ArgumentsMap[argumentName].SetValue(ArgumentsSource, argumentValue);
}
else
{
ArgumentsSource.OnUnknownArgument(argumentName, argumentValue);
}
}
else
{
ArgumentsSource.OnInvalidArgument(str);
}
}
}
ParseConfigArguments();
}
public static double Calculate(string Name, TreeNodeCollection Arguments, ArgumentsMap ArgsMap)
{
if (!functions.ContainsKey(Name))
{
throw new Exception("Function [" + Name + "] not found");
}
return(functions[Name].Calculate(Arguments, ArgsMap));
}
private void ParseConfigArguments()
{
foreach (var allKey in ConfigurationManager.AppSettings.AllKeys)
{
var upperInvariant = allKey.ToUpperInvariant();
var appSetting = ConfigurationManager.AppSettings[allKey];
if (ArgumentsMap.ContainsKey(upperInvariant) && !ArgumentsMap[upperInvariant].IsSet)
{
ArgumentsMap[upperInvariant].SetValue(ArgumentsSource, appSetting);
}
}
}
private static double Function_if(TreeNodeCollection Arguments, ArgumentsMap ArgsMap)
{
CheckArguments(Arguments, "if", 3);
double condition = TreeNodeCalculator.Calculate(Arguments[0], ArgsMap);
if (condition == 1)
{
return(TreeNodeCalculator.Calculate(Arguments[1], ArgsMap));
}
return(TreeNodeCalculator.Calculate(Arguments[2], ArgsMap));
}
public double Calculate(params Argument[] Arguments)
{
ArgumentsMap arguments = new ArgumentsMap();
if (Arguments != null)
{
for (int i = 0; i < Arguments.Length; ++i)
{
Argument arg = Arguments[i];
arguments[arg.Name] = arg.Value;
}
}
return(TreeNodeCalculator.Calculate(node, arguments));
}
public double Calculate(TreeNodeCollection Arguments, ArgumentsMap ArgsMap)
{
return(function(Arguments, ArgsMap));
}
public static double Calculate(TreeNode Node, ArgumentsMap Arguments)
{
if (Node is NumberNode)
{
return(((NumberNode)Node).Number);
}
else if (Node is ParameterNode)
{
string parameterName = ((ParameterNode)Node).Name;
if (!Arguments.ContainsKey(parameterName))
{
throw new System.Exception("Parameter [" + parameterName + "] doesn't supplied");
}
return(Arguments[parameterName]);
}
else if (Node is FunctionNode)
{
FunctionNode node = (FunctionNode)Node;
return(PredefinedFunctions.Calculate(node.Name, node.Parameters, Arguments));
}
else if (Node is LogicalOperatorNode)
{
LogicalOperatorNode node = (LogicalOperatorNode)Node;
double leftValue = Calculate(node.LeftNode, Arguments);
double rightValue = Calculate(node.RightNode, Arguments);
switch (node.Operator)
{
case LogicalOperatorNode.Operators.Equal:
return(leftValue == rightValue ? 1 : 0);
case LogicalOperatorNode.Operators.Greater:
return(leftValue > rightValue ? 1 : 0);
case LogicalOperatorNode.Operators.Less:
return(leftValue < rightValue ? 1 : 0);
case LogicalOperatorNode.Operators.GreaterEqual:
return(leftValue >= rightValue ? 1 : 0);
case LogicalOperatorNode.Operators.LessEqual:
return(leftValue <= rightValue ? 1 : 0);
default:
throw new System.Exception("Unknown Logical Operator type");
}
}
else if (Node is ArithmeticOperatorNode)
{
ArithmeticOperatorNode node = (ArithmeticOperatorNode)Node;
double leftValue = Calculate(node.LeftNode, Arguments);
double rightValue = Calculate(node.RightNode, Arguments);
switch (node.Operator)
{
case ArithmeticOperatorNode.Operators.Addition:
return(leftValue + rightValue);
case ArithmeticOperatorNode.Operators.Subtraction:
return(leftValue - rightValue);
case ArithmeticOperatorNode.Operators.Multiplication:
return(leftValue * rightValue);
case ArithmeticOperatorNode.Operators.Division:
return(leftValue / rightValue);
case ArithmeticOperatorNode.Operators.Remainder:
return(leftValue % rightValue);
case ArithmeticOperatorNode.Operators.Power:
return(System.Math.Pow(leftValue, rightValue));
default:
throw new System.Exception("Unknown Arithmetic Operator type");
}
}
throw new System.Exception("Unknown TreeNode type");
}
private static double Function_abs(TreeNodeCollection Arguments, ArgumentsMap ArgsMap)
{
CheckArguments(Arguments, "abs", 1);
return(Math.Abs(TreeNodeCalculator.Calculate(Arguments[0], ArgsMap)));
}
private static double Function_log(TreeNodeCollection Arguments, ArgumentsMap ArgsMap)
{
CheckArguments(Arguments, "log", 1);
return(Math.Log10(TreeNodeCalculator.Calculate(Arguments[0], ArgsMap)));
}
private static double Function_random(TreeNodeCollection Arguments, ArgumentsMap ArgsMap)
{
CheckArguments(Arguments, "random", 2);
return(TreeNodeCalculator.Calculate(Arguments[0], ArgsMap) + rnd.NextDouble() * (TreeNodeCalculator.Calculate(Arguments[1], ArgsMap) - TreeNodeCalculator.Calculate(Arguments[0], ArgsMap)));
}
private static double Function_min(TreeNodeCollection Arguments, ArgumentsMap ArgsMap)
{
CheckArguments(Arguments, "min", 2);
return(Math.Min(TreeNodeCalculator.Calculate(Arguments[0], ArgsMap), TreeNodeCalculator.Calculate(Arguments[1], ArgsMap)));
}
