public AstBuilder(IFunctionRegistry functionRegistry, bool adjustVariableCaseEnabled) { if (functionRegistry == null) { throw new ArgumentNullException("functionRegistry"); } this.functionRegistry = functionRegistry; this.adjustVariableCaseEnabled = adjustVariableCaseEnabled; operationPrecedence.Add('(', 0); operationPrecedence.Add('&', 1); operationPrecedence.Add('|', 1); operationPrecedence.Add('<', 2); operationPrecedence.Add('>', 2); operationPrecedence.Add('≤', 2); operationPrecedence.Add('≥', 2); operationPrecedence.Add('≠', 2); operationPrecedence.Add('=', 2); operationPrecedence.Add('+', 3); operationPrecedence.Add('-', 3); operationPrecedence.Add('*', 4); operationPrecedence.Add('/', 4); operationPrecedence.Add('%', 4); operationPrecedence.Add('_', 6); operationPrecedence.Add('^', 5); }
public AstBuilder(IFunctionRegistry functionRegistry, bool caseSensitive, IConstantRegistry compiledConstants = null) { if (functionRegistry == null) { throw new ArgumentNullException("functionRegistry"); } this.functionRegistry = functionRegistry; this.localConstantRegistry = compiledConstants ?? new ConstantRegistry(caseSensitive); this.caseSensitive = caseSensitive; operationPrecedence.Add('(', 0); operationPrecedence.Add('&', 1); operationPrecedence.Add('|', 1); operationPrecedence.Add('<', 2); operationPrecedence.Add('>', 2); operationPrecedence.Add('≤', 2); operationPrecedence.Add('≥', 2); operationPrecedence.Add('≠', 2); operationPrecedence.Add('=', 2); operationPrecedence.Add('+', 3); operationPrecedence.Add('-', 3); operationPrecedence.Add('*', 4); operationPrecedence.Add('/', 4); operationPrecedence.Add('%', 4); operationPrecedence.Add('_', 6); operationPrecedence.Add('^', 5); }
public FormulaContext(IDictionary <string, double> variables, IFunctionRegistry functionRegistry, IConstantRegistry constantRegistry) { this.Variables = variables; this.FunctionRegistry = functionRegistry; this.ConstantRegistry = constantRegistry; }
public Func<Dictionary<string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry) { return variables => { variables = EngineUtil.ConvertVariableNamesToLowerCase(variables); return Execute(operation, functionRegistry, variables); }; }
private void GenerateMethodBody(DynamicMethod method, Operation operation, IFunctionRegistry functionRegistry) { ILGenerator generator = method.GetILGenerator(); generator.DeclareLocal(typeof(double)); generator.DeclareLocal(typeof(object[])); GenerateMethodBody(generator, operation, functionRegistry); generator.Emit(OpCodes.Ret); }
public Func <IDictionary <string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry) { return(variables => { variables = EngineUtil.ConvertVariableNamesToLowerCase(variables); return Execute(operation, functionRegistry, variables); }); }
public Operation Optimize(Operation operation, IFunctionRegistry functionRegistry, IConstantRegistry constantRegistry) { if (!operation.DependsOnVariables && operation.IsIdempotent && operation.GetType() != typeof(IntegerConstant) && operation.GetType() != typeof(FloatingPointConstant)) { double result = executor.Execute(operation, functionRegistry, constantRegistry); return(new FloatingPointConstant(result)); } else { if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; addition.Argument1 = Optimize(addition.Argument1, functionRegistry, constantRegistry); addition.Argument2 = Optimize(addition.Argument2, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction substraction = (Subtraction)operation; substraction.Argument1 = Optimize(substraction.Argument1, functionRegistry, constantRegistry); substraction.Argument2 = Optimize(substraction.Argument2, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; multiplication.Argument1 = Optimize(multiplication.Argument1, functionRegistry, constantRegistry); multiplication.Argument2 = Optimize(multiplication.Argument2, functionRegistry, constantRegistry); if ((multiplication.Argument1.GetType() == typeof(FloatingPointConstant) && ((FloatingPointConstant)multiplication.Argument1).Value == 0.0) || (multiplication.Argument2.GetType() == typeof(FloatingPointConstant) && ((FloatingPointConstant)multiplication.Argument2).Value == 0.0)) { return(new FloatingPointConstant(0.0)); } } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; division.Dividend = Optimize(division.Dividend, functionRegistry, constantRegistry); division.Divisor = Optimize(division.Divisor, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation division = (Exponentiation)operation; division.Base = Optimize(division.Base, functionRegistry, constantRegistry); division.Exponent = Optimize(division.Exponent, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; IList <Operation> arguments = function.Arguments.Select(a => Optimize(a, functionRegistry, constantRegistry)).ToList(); function.Arguments = arguments; } return(operation); } }
public Func<Dictionary<string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry) { Func<FormulaContext, double> func = BuildFormulaInternal(operation, functionRegistry); return a => { FormulaContext context = new FormulaContext(a, functionRegistry); return func(context); }; }
public Func <Dictionary <string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry) { Func <FormulaContext, double> func = BuildFormulaInternal(operation, functionRegistry); return(a => { FormulaContext context = new FormulaContext(a, functionRegistry); return func(context); }); }
public Func<Dictionary<string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry) { Func<FormulaContext, double> func = BuildFormulaInternal(operation, functionRegistry); return variables => { variables = EngineUtil.ConvertVariableNamesToLowerCase(variables); FormulaContext context = new FormulaContext(variables, functionRegistry); return func(context); }; }
private Func<FormulaContext, double> BuildFormulaInternal(Operation operation, IFunctionRegistry functionRegistry) { DynamicMethod method = new DynamicMethod("MyCalcMethod", typeof(double), new Type[] { typeof(FormulaContext) }); GenerateMethodBody(method, operation, functionRegistry); Func<FormulaContext, double> function = (Func<FormulaContext, double>)method.CreateDelegate(typeof(Func<FormulaContext, double>)); return function; }
public Func <IDictionary <string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry) { Func <FormulaContext, double> func = BuildFormulaInternal(operation, functionRegistry); return(variables => { variables = EngineUtil.ConvertVariableNamesToLowerCase(variables); FormulaContext context = new FormulaContext(variables, functionRegistry); return func(context); }); }
private Func <FormulaContext, double> BuildFormulaInternal(Operation operation, IFunctionRegistry functionRegistry) { DynamicMethod method = new DynamicMethod("MyCalcMethod", typeof(double), new Type[] { typeof(FormulaContext) }); GenerateMethodBody(method, operation, functionRegistry); Func <FormulaContext, double> function = (Func <FormulaContext, double>)method.CreateDelegate(typeof(Func <FormulaContext, double>)); return(function); }
public AstBuilder(IFunctionRegistry functionRegistry) { this.functionRegistry = functionRegistry; operationPrecedence.Add('(', 0); operationPrecedence.Add('+', 1); operationPrecedence.Add('-', 1); operationPrecedence.Add('*', 2); operationPrecedence.Add('/', 2); operationPrecedence.Add('%', 2); operationPrecedence.Add('_', 4); operationPrecedence.Add('^', 3); }
public Operation Optimize(Operation operation, IFunctionRegistry functionRegistry) { if (!operation.DependsOnVariables && operation.GetType() != typeof(UnitNumberConstant) && operation.GetType() != typeof(FloatingPointConstant)) { var result = executor.Execute(operation, functionRegistry); if (result.DataType == DataType.Number) { return(new FloatingPointConstant((double)result.Value)); } else { return(new UnitNumberConstant((UnitNumber)result.Value)); } } else { if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; addition.Argument1 = Optimize(addition.Argument1, functionRegistry); addition.Argument2 = Optimize(addition.Argument2, functionRegistry); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction substraction = (Subtraction)operation; substraction.Argument1 = Optimize(substraction.Argument1, functionRegistry); substraction.Argument2 = Optimize(substraction.Argument2, functionRegistry); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; multiplication.Argument1 = Optimize(multiplication.Argument1, functionRegistry); multiplication.Argument2 = Optimize(multiplication.Argument2, functionRegistry); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; division.Dividend = Optimize(division.Dividend, functionRegistry); division.Divisor = Optimize(division.Divisor, functionRegistry); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation division = (Exponentiation)operation; division.Base = Optimize(division.Base, functionRegistry); division.Exponent = Optimize(division.Exponent, functionRegistry); } return(operation); } }
private Func <FormulaContext, double> BuildFormulaInternal(Operation operation, IFunctionRegistry functionRegistry) { ParameterExpression contextParameter = Expression.Parameter(typeof(FormulaContext), "context"); LabelTarget returnLabel = Expression.Label(typeof(double)); Expression <Func <FormulaContext, double> > lambda = Expression.Lambda <Func <FormulaContext, double> >( GenerateMethodBody(operation, contextParameter, functionRegistry), contextParameter ); return(lambda.Compile()); }
private Func <FormulaContext, ExecutionResult> BuildFormulaInternal(Operation operation, IFunctionRegistry functionRegistry) { ParameterExpression contextParameter = Expression.Parameter(typeof(FormulaContext), "context"); LabelTarget returnLabel = Expression.Label(typeof(ExecutionResult)); return(Expression.Lambda <Func <FormulaContext, ExecutionResult> >( Expression.Block( //block as a body Expression.Return(returnLabel, GenerateMethodBody(operation, contextParameter, functionRegistry)), Expression.Label(returnLabel, Expression.Constant(new ExecutionResult(0))) ), contextParameter //parameter ).Compile()); }
private Func <FormulaContext, double> BuildFormulaInternal(Operation operation, IFunctionRegistry functionRegistry) { ParameterExpression contextParameter = Expression.Parameter(typeof(FormulaContext), "context"); LabelTarget returnLabel = Expression.Label(typeof(double)); return(Expression.Lambda <Func <FormulaContext, double> >( Expression.Block( Expression.Return(returnLabel, GenerateMethodBody(operation, contextParameter, functionRegistry)), Expression.Label(returnLabel, Expression.Constant(0.0)) ), contextParameter ).Compile()); }
public Func <IDictionary <string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry, IConstantRegistry constantRegistry, IDictionary <string, double> vars) { return(adjustVariableCaseEnabled ? (Func <IDictionary <string, double>, double>)(variables => { variables = EngineUtil.ConvertVariableNamesToLowerCase(variables); return Execute(operation, functionRegistry, constantRegistry, variables); }) : (Func <IDictionary <string, double>, double>)(variables => { return Execute(operation, functionRegistry, constantRegistry, variables); })); }
public AstBuilder(IFunctionRegistry functionRegistry) { if (functionRegistry == null) { throw new ArgumentNullException("functionRegistry"); } this.functionRegistry = functionRegistry; operationPrecedence.Add('(', 0); operationPrecedence.Add('+', 1); operationPrecedence.Add('-', 1); operationPrecedence.Add('_', 2); operationPrecedence.Add('*', 3); operationPrecedence.Add('/', 3); operationPrecedence.Add('^', 4); }
public Func <IDictionary <string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry, IConstantRegistry constantRegistry, IDictionary <string, double> vars) { Func <FormulaContext, double> func = BuildFormulaInternal(operation, functionRegistry, vars); return(adjustVariableCaseEnabled ? (Func <IDictionary <string, double>, double>)(variables => { variables = EngineUtil.ConvertVariableNamesToLowerCase(variables); FormulaContext context = new FormulaContext(variables, functionRegistry, constantRegistry); return func(context); }) : (Func <IDictionary <string, double>, double>)(variables => { return func(new FormulaContext(variables, functionRegistry, constantRegistry)); })); }
public Operation Optimize(Operation operation, IFunctionRegistry functionRegistry) { if (!operation.DependsOnVariables && operation.GetType() != typeof(IntegerConstant) && operation.GetType() != typeof(FloatingPointConstant)) { double result = executor.Execute(operation, functionRegistry); return new FloatingPointConstant(result); } else { if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; addition.Argument1 = Optimize(addition.Argument1, functionRegistry); addition.Argument2 = Optimize(addition.Argument2, functionRegistry); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction substraction = (Subtraction)operation; substraction.Argument1 = Optimize(substraction.Argument1, functionRegistry); substraction.Argument2 = Optimize(substraction.Argument2, functionRegistry); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; multiplication.Argument1 = Optimize(multiplication.Argument1, functionRegistry); multiplication.Argument2 = Optimize(multiplication.Argument2, functionRegistry); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; division.Dividend = Optimize(division.Dividend, functionRegistry); division.Divisor = Optimize(division.Divisor, functionRegistry); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation division = (Exponentiation)operation; division.Base = Optimize(division.Base, functionRegistry); division.Exponent = Optimize(division.Exponent, functionRegistry); } return operation; } }
public Operation Optimize(Operation operation, IFunctionRegistry functionRegistry, IConstantRegistry constantRegistry) { if (!operation.DependsOnVariables && operation.GetType() != typeof(IntegerConstant) && operation.GetType() != typeof(FloatingPointConstant)) { double result = executor.Execute(operation, functionRegistry, constantRegistry); return(new FloatingPointConstant(result)); } else { if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; addition.Argument1 = Optimize(addition.Argument1, functionRegistry, constantRegistry); addition.Argument2 = Optimize(addition.Argument2, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction substraction = (Subtraction)operation; substraction.Argument1 = Optimize(substraction.Argument1, functionRegistry, constantRegistry); substraction.Argument2 = Optimize(substraction.Argument2, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; multiplication.Argument1 = Optimize(multiplication.Argument1, functionRegistry, constantRegistry); multiplication.Argument2 = Optimize(multiplication.Argument2, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; division.Dividend = Optimize(division.Dividend, functionRegistry, constantRegistry); division.Divisor = Optimize(division.Divisor, functionRegistry, constantRegistry); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation division = (Exponentiation)operation; division.Base = Optimize(division.Base, functionRegistry, constantRegistry); division.Exponent = Optimize(division.Exponent, functionRegistry, constantRegistry); } return(operation); } }
public AstBuilder(IFunctionRegistry functionRegistry) { this.functionRegistry = functionRegistry ?? throw new ArgumentNullException(nameof(functionRegistry)); operationPrecedence.Add('(', 0); operationPrecedence.Add('&', 1); operationPrecedence.Add('|', 1); operationPrecedence.Add('<', 2); operationPrecedence.Add('>', 2); operationPrecedence.Add('≤', 2); operationPrecedence.Add('≥', 2); operationPrecedence.Add('≠', 2); operationPrecedence.Add('=', 2); operationPrecedence.Add('+', 3); operationPrecedence.Add('-', 3); operationPrecedence.Add('*', 4); operationPrecedence.Add('/', 4); operationPrecedence.Add('%', 4); operationPrecedence.Add('_', 6); operationPrecedence.Add('^', 5); }
public Operation Optimize(Operation operation, IFunctionRegistry functionRegistry) { if (!operation.DependsOnVariables && !(operation is FloatingPointConstant)) { float result = executor.Execute(operation, functionRegistry); return(new FloatingPointConstant(result)); } else { switch (operation) { case Addition addition: addition.Argument1 = Optimize(addition.Argument1, functionRegistry); addition.Argument2 = Optimize(addition.Argument2, functionRegistry); break; case Substraction substraction: substraction.Argument1 = Optimize(substraction.Argument1, functionRegistry); substraction.Argument2 = Optimize(substraction.Argument2, functionRegistry); break; case Multiplication multiplication: multiplication.Argument1 = Optimize(multiplication.Argument1, functionRegistry); multiplication.Argument2 = Optimize(multiplication.Argument2, functionRegistry); break; case Division division: division.Dividend = Optimize(division.Dividend, functionRegistry); division.Divisor = Optimize(division.Divisor, functionRegistry); break; case Exponentiation exponentiation: exponentiation.Base = Optimize(exponentiation.Base, functionRegistry); exponentiation.Exponent = Optimize(exponentiation.Exponent, functionRegistry); break; } return(operation); } }
public Expression <TFunc> BuildExpressionTree <TFunc>( Operation operation, IFunctionRegistry functionRegistry, IConstantRegistry constantRegistry, IList <string> paramNames) where TFunc : Delegate { ParameterExpression[] parameters = paramNames .Select(param => Expression.Parameter(typeof(float), param)) .ToArray(); IDictionary <string, ParameterExpression> parametersDic = parameters.ToDictionary(parameter => parameter.Name); return(Expression.Lambda <TFunc>( GenerateMethodBody( operation, functionRegistry, constantRegistry, parametersDic), parameters )); }
public double Execute(Operation operation, IFunctionRegistry functionRegistry) { return Execute(operation, functionRegistry, new Dictionary<string, double>()); }
public double Execute(Operation operation, IFunctionRegistry functionRegistry, IDictionary<string, double> variables) { if (operation == null) throw new ArgumentNullException("operation"); if (operation.GetType() == typeof(IntegerConstant)) { IntegerConstant constant = (IntegerConstant)operation; return constant.Value; } else if (operation.GetType() == typeof(FloatingPointConstant)) { FloatingPointConstant constant = (FloatingPointConstant)operation; return constant.Value; } else if (operation.GetType() == typeof(Variable)) { Variable variable = (Variable)operation; double value; bool variableFound = variables.TryGetValue(variable.Name, out value); if (variableFound) return value; else throw new VariableNotDefinedException(string.Format("The variable \"{0}\" used is not defined.", variable.Name)); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; return Execute(multiplication.Argument1, functionRegistry, variables) * Execute(multiplication.Argument2, functionRegistry, variables); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; return Execute(addition.Argument1, functionRegistry, variables) + Execute(addition.Argument2, functionRegistry, variables); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; return Execute(addition.Argument1, functionRegistry, variables) - Execute(addition.Argument2, functionRegistry, variables); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; return Execute(division.Dividend, functionRegistry, variables) / Execute(division.Divisor, functionRegistry, variables); } else if (operation.GetType() == typeof(Modulo)) { Modulo division = (Modulo)operation; return Execute(division.Dividend, functionRegistry, variables) % Execute(division.Divisor, functionRegistry, variables); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentiation = (Exponentiation)operation; return Math.Pow(Execute(exponentiation.Base, functionRegistry, variables), Execute(exponentiation.Exponent, functionRegistry, variables)); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; return -Execute(unaryMinus.Argument, functionRegistry, variables); } else if(operation.GetType() == typeof(LessThan)) { LessThan lessThan = (LessThan)operation; return (Execute(lessThan.Argument1, functionRegistry, variables) < Execute(lessThan.Argument2, functionRegistry, variables)) ? 1.0 : 0.0; } else if (operation.GetType() == typeof(LessOrEqualThan)) { LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation; return (Execute(lessOrEqualThan.Argument1, functionRegistry, variables) <= Execute(lessOrEqualThan.Argument2, functionRegistry, variables)) ? 1.0 : 0.0; } else if (operation.GetType() == typeof(GreaterThan)) { GreaterThan greaterThan = (GreaterThan)operation; return (Execute(greaterThan.Argument1, functionRegistry, variables) > Execute(greaterThan.Argument2, functionRegistry, variables)) ? 1.0 : 0.0; } else if (operation.GetType() == typeof(GreaterOrEqualThan)) { GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation; return (Execute(greaterOrEqualThan.Argument1, functionRegistry, variables) >= Execute(greaterOrEqualThan.Argument2, functionRegistry, variables)) ? 1.0 : 0.0; } else if (operation.GetType() == typeof(Equal)) { Equal equal = (Equal)operation; return (Execute(equal.Argument1, functionRegistry, variables) == Execute(equal.Argument2, functionRegistry, variables)) ? 1.0 : 0.0; } else if (operation.GetType() == typeof(NotEqual)) { NotEqual notEqual = (NotEqual)operation; return (Execute(notEqual.Argument1, functionRegistry, variables) != Execute(notEqual.Argument2, functionRegistry, variables)) ? 1.0 : 0.0; } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); double[] arguments = new double[functionInfo.NumberOfParameters]; for (int i = 0; i < arguments.Length; i++) arguments[i] = Execute(function.Arguments[i], functionRegistry, variables); return Invoke(functionInfo.Function, arguments); } else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
private void GenerateMethodBody(ILGenerator generator, Operation operation, IFunctionRegistry functionRegistry) { if (operation == null) { throw new ArgumentNullException("operation"); } if (operation.GetType() == typeof(IntegerConstant)) { IntegerConstant constant = (IntegerConstant)operation; generator.Emit(OpCodes.Ldc_I4, constant.Value); generator.Emit(OpCodes.Conv_R8); } else if (operation.GetType() == typeof(FloatingPointConstant)) { FloatingPointConstant constant = (FloatingPointConstant)operation; generator.Emit(OpCodes.Ldc_R8, constant.Value); } else if (operation.GetType() == typeof(Variable)) { Type dictionaryType = typeof(IDictionary <string, double>); Variable variable = (Variable)operation; Label throwExceptionLabel = generator.DefineLabel(); Label returnLabel = generator.DefineLabel(); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Callvirt, typeof(FormulaContext).GetProperty("Variables").GetGetMethod()); generator.Emit(OpCodes.Ldstr, variable.Name); generator.Emit(OpCodes.Ldloca_S, (byte)0); generator.Emit(OpCodes.Callvirt, dictionaryType.GetMethod("TryGetValue", new Type[] { typeof(string), typeof(double).MakeByRefType() })); generator.Emit(OpCodes.Ldc_I4_0); generator.Emit(OpCodes.Ceq); generator.Emit(OpCodes.Brtrue_S, throwExceptionLabel); generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Br_S, returnLabel); generator.MarkLabel(throwExceptionLabel); generator.Emit(OpCodes.Ldstr, string.Format("The variable \"{0}\" used is not defined.", variable.Name)); generator.Emit(OpCodes.Newobj, typeof(VariableNotDefinedException).GetConstructor(new Type[] { typeof(string) })); generator.Emit(OpCodes.Throw); generator.MarkLabel(returnLabel); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; GenerateMethodBody(generator, multiplication.Argument1, functionRegistry); GenerateMethodBody(generator, multiplication.Argument2, functionRegistry); generator.Emit(OpCodes.Mul); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; GenerateMethodBody(generator, addition.Argument1, functionRegistry); GenerateMethodBody(generator, addition.Argument2, functionRegistry); generator.Emit(OpCodes.Add); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; GenerateMethodBody(generator, addition.Argument1, functionRegistry); GenerateMethodBody(generator, addition.Argument2, functionRegistry); generator.Emit(OpCodes.Sub); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; GenerateMethodBody(generator, division.Dividend, functionRegistry); GenerateMethodBody(generator, division.Divisor, functionRegistry); generator.Emit(OpCodes.Div); } else if (operation.GetType() == typeof(Modulo)) { Modulo modulo = (Modulo)operation; GenerateMethodBody(generator, modulo.Dividend, functionRegistry); GenerateMethodBody(generator, modulo.Divisor, functionRegistry); generator.Emit(OpCodes.Rem); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentation = (Exponentiation)operation; GenerateMethodBody(generator, exponentation.Base, functionRegistry); GenerateMethodBody(generator, exponentation.Exponent, functionRegistry); generator.Emit(OpCodes.Call, typeof(Math).GetMethod("Pow")); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; GenerateMethodBody(generator, unaryMinus.Argument, functionRegistry); generator.Emit(OpCodes.Neg); } else if (operation.GetType() == typeof(LessThan)) { LessThan lessThan = (LessThan)operation; Label ifLabel = generator.DefineLabel(); Label endLabel = generator.DefineLabel(); GenerateMethodBody(generator, lessThan.Argument1, functionRegistry); GenerateMethodBody(generator, lessThan.Argument2, functionRegistry); generator.Emit(OpCodes.Blt_S, ifLabel); generator.Emit(OpCodes.Ldc_R8, 0.0); generator.Emit(OpCodes.Br_S, endLabel); generator.MarkLabel(ifLabel); generator.Emit(OpCodes.Ldc_R8, 1.0); generator.MarkLabel(endLabel); } else if (operation.GetType() == typeof(LessOrEqualThan)) { LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation; Label ifLabel = generator.DefineLabel(); Label endLabel = generator.DefineLabel(); GenerateMethodBody(generator, lessOrEqualThan.Argument1, functionRegistry); GenerateMethodBody(generator, lessOrEqualThan.Argument2, functionRegistry); generator.Emit(OpCodes.Ble_S, ifLabel); generator.Emit(OpCodes.Ldc_R8, 0.0); generator.Emit(OpCodes.Br_S, endLabel); generator.MarkLabel(ifLabel); generator.Emit(OpCodes.Ldc_R8, 1.0); generator.MarkLabel(endLabel); } else if (operation.GetType() == typeof(GreaterThan)) { GreaterThan greaterThan = (GreaterThan)operation; Label ifLabel = generator.DefineLabel(); Label endLabel = generator.DefineLabel(); GenerateMethodBody(generator, greaterThan.Argument1, functionRegistry); GenerateMethodBody(generator, greaterThan.Argument2, functionRegistry); generator.Emit(OpCodes.Bgt_S, ifLabel); generator.Emit(OpCodes.Ldc_R8, 0.0); generator.Emit(OpCodes.Br_S, endLabel); generator.MarkLabel(ifLabel); generator.Emit(OpCodes.Ldc_R8, 1.0); generator.MarkLabel(endLabel); } else if (operation.GetType() == typeof(GreaterOrEqualThan)) { GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation; Label ifLabel = generator.DefineLabel(); Label endLabel = generator.DefineLabel(); GenerateMethodBody(generator, greaterOrEqualThan.Argument1, functionRegistry); GenerateMethodBody(generator, greaterOrEqualThan.Argument2, functionRegistry); generator.Emit(OpCodes.Bge_S, ifLabel); generator.Emit(OpCodes.Ldc_R8, 0.0); generator.Emit(OpCodes.Br_S, endLabel); generator.MarkLabel(ifLabel); generator.Emit(OpCodes.Ldc_R8, 1.0); generator.MarkLabel(endLabel); } else if (operation.GetType() == typeof(Equal)) { Equal equal = (Equal)operation; Label ifLabel = generator.DefineLabel(); Label endLabel = generator.DefineLabel(); GenerateMethodBody(generator, equal.Argument1, functionRegistry); GenerateMethodBody(generator, equal.Argument2, functionRegistry); generator.Emit(OpCodes.Beq_S, ifLabel); generator.Emit(OpCodes.Ldc_R8, 0.0); generator.Emit(OpCodes.Br_S, endLabel); generator.MarkLabel(ifLabel); generator.Emit(OpCodes.Ldc_R8, 1.0); generator.MarkLabel(endLabel); } else if (operation.GetType() == typeof(NotEqual)) { NotEqual notEqual = (NotEqual)operation; Label ifLabel = generator.DefineLabel(); Label endLabel = generator.DefineLabel(); GenerateMethodBody(generator, notEqual.Argument1, functionRegistry); GenerateMethodBody(generator, notEqual.Argument2, functionRegistry); generator.Emit(OpCodes.Beq, ifLabel); generator.Emit(OpCodes.Ldc_R8, 1.0); generator.Emit(OpCodes.Br_S, endLabel); generator.MarkLabel(ifLabel); generator.Emit(OpCodes.Ldc_R8, 0.0); generator.MarkLabel(endLabel); } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); Type funcType = GetFuncType(functionInfo.NumberOfParameters); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Callvirt, typeof(FormulaContext).GetProperty("FunctionRegistry").GetGetMethod()); generator.Emit(OpCodes.Ldstr, function.FunctionName); generator.Emit(OpCodes.Callvirt, typeof(IFunctionRegistry).GetMethod("GetFunctionInfo", new Type[] { typeof(string) })); generator.Emit(OpCodes.Callvirt, typeof(FunctionInfo).GetProperty("Function").GetGetMethod()); generator.Emit(OpCodes.Castclass, funcType); for (int i = 0; i < functionInfo.NumberOfParameters; i++) { GenerateMethodBody(generator, function.Arguments[i], functionRegistry); } generator.Emit(OpCodes.Call, funcType.GetMethod("Invoke")); } else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
public double Execute(Operation operation, IFunctionRegistry functionRegistry) { return(Execute(operation, functionRegistry, new Dictionary <string, double>())); }
public VariableCalcurator Execute(Operation operation, IFunctionRegistry functionRegistry, IDictionary <string, VariableCalcurator> variables) { VariableCalcurator.defaultVariables = variables; if (operation == null) { throw new ArgumentNullException("operation"); } /* * if (operation.GetType() == typeof(IntegerConstant)) * { * IntegerConstant constant = (IntegerConstant)operation; * return constant.Value; * } * else if (operation.GetType() == typeof(FloatingPointConstant)) * { * FloatingPointConstant constant = (FloatingPointConstant)operation; * return constant.Value; * } * else*/ if (operation.GetType() == typeof(VariableCalcurator)) { VariableCalcurator variable = (VariableCalcurator)operation; /* * if (variable.DataType == DataType.Literal) * return new VariableCalcurator(DataType.Literal, variable.Literal()); * else if(variable.DataType == DataType.Identifier) * { * bool variableFound = variables.ContainsKey(variable.Literal()); * * if (variableFound) * return variables[variable.Literal()]; * * else * return variable; * throw new VariableNotDefinedException(string.Format("The variable \"{0}\" used is not defined.", variable.Literal())); * } */ return(variable); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; return(Execute(multiplication.Argument1, functionRegistry, variables).GetInstance() * Execute(multiplication.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; return(Execute(addition.Argument1, functionRegistry, variables).GetInstance() + Execute(addition.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; return(Execute(addition.Argument1, functionRegistry, variables).GetInstance() - Execute(addition.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; return(Execute(division.Dividend, functionRegistry, variables).GetInstance() / Execute(division.Divisor, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(Modulo)) { Modulo division = (Modulo)operation; return(Execute(division.Dividend, functionRegistry, variables).GetInstance() % Execute(division.Divisor, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentiation = (Exponentiation)operation; return(new VariableCalcurator((float)Math.Pow(Execute(exponentiation.Base, functionRegistry, variables).GetInstance().Float(), Execute(exponentiation.Exponent, functionRegistry, variables).GetInstance().Float()))); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; return(-Execute(unaryMinus.Argument, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(LessThan)) { LessThan lessThan = (LessThan)operation; return(Execute(lessThan.Argument1, functionRegistry, variables).GetInstance() < Execute(lessThan.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(LessOrEqualThan)) { LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation; return(Execute(lessOrEqualThan.Argument1, functionRegistry, variables).GetInstance() <= Execute(lessOrEqualThan.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(GreaterThan)) { GreaterThan greaterThan = (GreaterThan)operation; return(Execute(greaterThan.Argument1, functionRegistry, variables).GetInstance() > Execute(greaterThan.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(GreaterOrEqualThan)) { GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation; return(Execute(greaterOrEqualThan.Argument1, functionRegistry, variables).GetInstance() >= Execute(greaterOrEqualThan.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(Equal)) { Equal equal = (Equal)operation; return(Execute(equal.Argument1, functionRegistry, variables).GetInstance() == Execute(equal.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(NotEqual)) { NotEqual notEqual = (NotEqual)operation; return(Execute(notEqual.Argument1, functionRegistry, variables).GetInstance() != Execute(notEqual.Argument2, functionRegistry, variables).GetInstance()); } else if (operation.GetType() == typeof(Index)) { Index index = (Index)operation; return(Index(Execute(index.Argument1, functionRegistry, variables), Execute(index.Argument2, functionRegistry, variables), variables)); } else if (operation.GetType() == typeof(Substitution)) { Substitution substitution = (Substitution)operation; return(Substitute(Execute(substitution.Argument1, functionRegistry, variables), Execute(substitution.Argument2, functionRegistry, variables), variables)); } /* * else if (operation.GetType() == typeof(Function)) * { * Function function = (Function)operation; * * FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); * * double[] arguments = new double[functionInfo.IsDynamicFunc ? function.Arguments.Count : functionInfo.NumberOfParameters]; * for (int i = 0; i < arguments.Length; i++) * arguments[i] = Execute(function.Arguments[i], functionRegistry, variables); * * return Invoke(functionInfo.Function, arguments); * } */ else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
public double Execute(Operation operation, IFunctionRegistry functionRegistry, Dictionary<string, double> variables) { if (operation == null) throw new ArgumentNullException("operation"); if (operation.GetType() == typeof(IntegerConstant)) { IntegerConstant constant = (IntegerConstant)operation; return constant.Value; } else if (operation.GetType() == typeof(FloatingPointConstant)) { FloatingPointConstant constant = (FloatingPointConstant)operation; return constant.Value; } else if (operation.GetType() == typeof(Variable)) { Variable variable = (Variable)operation; if (variables.ContainsKey(variable.Name)) return variables[variable.Name]; else throw new VariableNotDefinedException(string.Format("The variable \"{0}\" used is not defined.", variable.Name)); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; return Execute(multiplication.Argument1, functionRegistry, variables) * Execute(multiplication.Argument2, functionRegistry, variables); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; return Execute(addition.Argument1, functionRegistry, variables) + Execute(addition.Argument2, functionRegistry, variables); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; return Execute(addition.Argument1, functionRegistry, variables) - Execute(addition.Argument2, functionRegistry, variables); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; return Execute(division.Dividend, functionRegistry, variables) / Execute(division.Divisor, functionRegistry, variables); } else if (operation.GetType() == typeof(Modulo)) { Modulo division = (Modulo)operation; return Execute(division.Dividend, functionRegistry, variables) % Execute(division.Divisor, functionRegistry, variables); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentiation = (Exponentiation)operation; return Math.Pow(Execute(exponentiation.Base, functionRegistry, variables), Execute(exponentiation.Exponent, functionRegistry, variables)); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; return -Execute(unaryMinus.Argument, functionRegistry, variables); } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); double[] arguments = new double[functionInfo.NumberOfParameters]; for (int i = 0; i < arguments.Length; i++) arguments[i] = Execute(function.Arguments[i], functionRegistry, variables); return Invoke(functionInfo.Function, arguments); } else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
private Expression GenerateMethodBody(Operation operation, ParameterExpression contextParameter, IFunctionRegistry functionRegistry) { if (operation == null) { throw new ArgumentNullException("operation"); } if (operation.GetType() == typeof(IntegerConstant)) { IntegerConstant constant = (IntegerConstant)operation; double value = constant.Value; return(Expression.Constant(value, typeof(double))); } else if (operation.GetType() == typeof(FloatingPointConstant)) { FloatingPointConstant constant = (FloatingPointConstant)operation; return(Expression.Constant(constant.Value, typeof(double))); } else if (operation.GetType() == typeof(Variable)) { Variable variable = (Variable)operation; Func <string, FormulaContext, double> getVariableValueOrThrow = PrecompiledMethods.GetVariableValueOrThrow; return(Expression.Call(null, getVariableValueOrThrow.GetMethodInfo(), Expression.Constant(variable.Name), contextParameter)); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; Expression argument1 = GenerateMethodBody(multiplication.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(multiplication.Argument2, contextParameter, functionRegistry); return(Expression.Multiply(argument1, argument2)); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; Expression argument1 = GenerateMethodBody(addition.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(addition.Argument2, contextParameter, functionRegistry); return(Expression.Add(argument1, argument2)); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; Expression argument1 = GenerateMethodBody(addition.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(addition.Argument2, contextParameter, functionRegistry); return(Expression.Subtract(argument1, argument2)); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; Expression dividend = GenerateMethodBody(division.Dividend, contextParameter, functionRegistry); Expression divisor = GenerateMethodBody(division.Divisor, contextParameter, functionRegistry); return(Expression.Divide(dividend, divisor)); } else if (operation.GetType() == typeof(Modulo)) { Modulo modulo = (Modulo)operation; Expression dividend = GenerateMethodBody(modulo.Dividend, contextParameter, functionRegistry); Expression divisor = GenerateMethodBody(modulo.Divisor, contextParameter, functionRegistry); return(Expression.Modulo(dividend, divisor)); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentation = (Exponentiation)operation; Expression @base = GenerateMethodBody(exponentation.Base, contextParameter, functionRegistry); Expression exponent = GenerateMethodBody(exponentation.Exponent, contextParameter, functionRegistry); return(Expression.Call(null, typeof(Math).GetRuntimeMethod("Pow", new Type[] { typeof(double), typeof(double) }), @base, exponent)); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; Expression argument = GenerateMethodBody(unaryMinus.Argument, contextParameter, functionRegistry); return(Expression.Negate(argument)); } else if (operation.GetType() == typeof(And)) { And and = (And)operation; Expression argument1 = Expression.NotEqual(GenerateMethodBody(and.Argument1, contextParameter, functionRegistry), Expression.Constant(0.0)); Expression argument2 = Expression.NotEqual(GenerateMethodBody(and.Argument2, contextParameter, functionRegistry), Expression.Constant(0.0)); return(Expression.Condition(Expression.And(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(Or)) { Or and = (Or)operation; Expression argument1 = Expression.NotEqual(GenerateMethodBody(and.Argument1, contextParameter, functionRegistry), Expression.Constant(0.0)); Expression argument2 = Expression.NotEqual(GenerateMethodBody(and.Argument2, contextParameter, functionRegistry), Expression.Constant(0.0)); return(Expression.Condition(Expression.Or(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(LessThan)) { LessThan lessThan = (LessThan)operation; Expression argument1 = GenerateMethodBody(lessThan.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(lessThan.Argument2, contextParameter, functionRegistry); return(Expression.Condition(Expression.LessThan(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(LessOrEqualThan)) { LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation; Expression argument1 = GenerateMethodBody(lessOrEqualThan.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(lessOrEqualThan.Argument2, contextParameter, functionRegistry); return(Expression.Condition(Expression.LessThanOrEqual(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(GreaterThan)) { GreaterThan greaterThan = (GreaterThan)operation; Expression argument1 = GenerateMethodBody(greaterThan.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(greaterThan.Argument2, contextParameter, functionRegistry); return(Expression.Condition(Expression.GreaterThan(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(GreaterOrEqualThan)) { GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation; Expression argument1 = GenerateMethodBody(greaterOrEqualThan.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(greaterOrEqualThan.Argument2, contextParameter, functionRegistry); return(Expression.Condition(Expression.GreaterThanOrEqual(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(Equal)) { Equal equal = (Equal)operation; Expression argument1 = GenerateMethodBody(equal.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(equal.Argument2, contextParameter, functionRegistry); return(Expression.Condition(Expression.Equal(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(NotEqual)) { NotEqual notEqual = (NotEqual)operation; Expression argument1 = GenerateMethodBody(notEqual.Argument1, contextParameter, functionRegistry); Expression argument2 = GenerateMethodBody(notEqual.Argument2, contextParameter, functionRegistry); return(Expression.Condition(Expression.NotEqual(argument1, argument2), Expression.Constant(1.0), Expression.Constant(0.0))); } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); Type funcType; Type[] parameterTypes; Expression[] arguments; if (functionInfo.IsDynamicFunc) { funcType = typeof(DynamicFunc <double, double>); parameterTypes = new Type[] { typeof(double[]) }; Expression[] arrayArguments = new Expression[function.Arguments.Count]; for (int i = 0; i < function.Arguments.Count; i++) { arrayArguments[i] = GenerateMethodBody(function.Arguments[i], contextParameter, functionRegistry); } arguments = new Expression[1]; arguments[0] = NewArrayExpression.NewArrayInit(typeof(double), arrayArguments); } else { funcType = GetFuncType(functionInfo.NumberOfParameters); parameterTypes = (from i in Enumerable.Range(0, functionInfo.NumberOfParameters) select typeof(double)).ToArray(); arguments = new Expression[functionInfo.NumberOfParameters]; for (int i = 0; i < functionInfo.NumberOfParameters; i++) { arguments[i] = GenerateMethodBody(function.Arguments[i], contextParameter, functionRegistry); } } Expression getFunctionRegistry = Expression.Property(contextParameter, "FunctionRegistry"); ParameterExpression functionInfoVariable = Expression.Variable(typeof(FunctionInfo)); Expression funcInstance; if (!functionInfo.IsOverWritable) { funcInstance = Expression.Convert( Expression.Property( Expression.Call( getFunctionRegistry, typeof(IFunctionRegistry).GetRuntimeMethod("GetFunctionInfo", new Type[] { typeof(string) }), Expression.Constant(function.FunctionName)), "Function"), funcType); } else { funcInstance = Expression.Constant(functionInfo.Function, funcType); } return(Expression.Call( funcInstance, funcType.GetRuntimeMethod("Invoke", parameterTypes), arguments)); } else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
public Func <IDictionary <string, VariableCalcurator>, VariableCalcurator> BuildFormulaV2(Operation operation, IFunctionRegistry functionRegistry) { return(null); }
public double Execute(Operation operation, IFunctionRegistry functionRegistry, IConstantRegistry constantRegistry, IDictionary <string, double> variables) { if (operation == null) { throw new ArgumentNullException("operation"); } if (operation.GetType() == typeof(IntegerConstant)) { IntegerConstant constant = (IntegerConstant)operation; return(constant.Value); } else if (operation.GetType() == typeof(FloatingPointConstant)) { FloatingPointConstant constant = (FloatingPointConstant)operation; return(constant.Value); } else if (operation.GetType() == typeof(Variable)) { Variable variable = (Variable)operation; double value; bool variableFound = variables.TryGetValue(variable.Name, out value); if (variableFound) { return(value); } else { throw new VariableNotDefinedException(string.Format("The variable \"{0}\" used is not defined.", variable.Name)); } } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; return(Execute(multiplication.Argument1, functionRegistry, constantRegistry, variables) * Execute(multiplication.Argument2, functionRegistry, constantRegistry, variables)); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; return(Execute(addition.Argument1, functionRegistry, constantRegistry, variables) + Execute(addition.Argument2, functionRegistry, constantRegistry, variables)); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; return(Execute(addition.Argument1, functionRegistry, constantRegistry, variables) - Execute(addition.Argument2, functionRegistry, constantRegistry, variables)); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; return(Execute(division.Dividend, functionRegistry, constantRegistry, variables) / Execute(division.Divisor, functionRegistry, constantRegistry, variables)); } else if (operation.GetType() == typeof(Modulo)) { Modulo division = (Modulo)operation; return(Execute(division.Dividend, functionRegistry, constantRegistry, variables) % Execute(division.Divisor, functionRegistry, constantRegistry, variables)); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentiation = (Exponentiation)operation; return(Math.Pow(Execute(exponentiation.Base, functionRegistry, constantRegistry, variables), Execute(exponentiation.Exponent, functionRegistry, constantRegistry, variables))); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; return(-Execute(unaryMinus.Argument, functionRegistry, constantRegistry, variables)); } else if (operation.GetType() == typeof(And)) { And and = (And)operation; var operation1 = Execute(and.Argument1, functionRegistry, constantRegistry, variables) != 0; var operation2 = Execute(and.Argument2, functionRegistry, constantRegistry, variables) != 0; return((operation1 && operation2) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(Or)) { Or or = (Or)operation; var operation1 = Execute(or.Argument1, functionRegistry, constantRegistry, variables) != 0; var operation2 = Execute(or.Argument2, functionRegistry, constantRegistry, variables) != 0; return((operation1 || operation2) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(LessThan)) { LessThan lessThan = (LessThan)operation; return((Execute(lessThan.Argument1, functionRegistry, constantRegistry, variables) < Execute(lessThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(LessOrEqualThan)) { LessOrEqualThan lessOrEqualThan = (LessOrEqualThan)operation; return((Execute(lessOrEqualThan.Argument1, functionRegistry, constantRegistry, variables) <= Execute(lessOrEqualThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(GreaterThan)) { GreaterThan greaterThan = (GreaterThan)operation; return((Execute(greaterThan.Argument1, functionRegistry, constantRegistry, variables) > Execute(greaterThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(GreaterOrEqualThan)) { GreaterOrEqualThan greaterOrEqualThan = (GreaterOrEqualThan)operation; return((Execute(greaterOrEqualThan.Argument1, functionRegistry, constantRegistry, variables) >= Execute(greaterOrEqualThan.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(Equal)) { Equal equal = (Equal)operation; return((Execute(equal.Argument1, functionRegistry, constantRegistry, variables) == Execute(equal.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(NotEqual)) { NotEqual notEqual = (NotEqual)operation; return((Execute(notEqual.Argument1, functionRegistry, constantRegistry, variables) != Execute(notEqual.Argument2, functionRegistry, constantRegistry, variables)) ? 1.0 : 0.0); } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); double[] arguments = new double[functionInfo.IsDynamicFunc ? function.Arguments.Count : functionInfo.NumberOfParameters]; for (int i = 0; i < arguments.Length; i++) { arguments[i] = Execute(function.Arguments[i], functionRegistry, constantRegistry, variables); } return(Invoke(functionInfo.Function, arguments)); } else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
public FormulaContext(Dictionary<string, double> variables, IFunctionRegistry functionRegistry) { this.Variables = variables; this.FunctionRegistry = functionRegistry; }
public double Execute(Operation operation, IFunctionRegistry functionRegistry, Dictionary<string, double> variables) { return BuildFormula(operation, functionRegistry)(variables); }
public double Execute(Operation operation, IFunctionRegistry functionRegistry, IDictionary <string, double> variables) { return(BuildFormula(operation, functionRegistry)(variables)); }
public ExecutionResult Execute(Operation operation, IFunctionRegistry functionRegistry, IDictionary <string, ExecutionResult> variables) { if (operation == null) { throw new ArgumentNullException("operation"); } if (operation.GetType() == typeof(UnitNumberConstant)) { UnitNumberConstant constant = (UnitNumberConstant)operation; return(new ExecutionResult(constant.Value)); } else if (operation.GetType() == typeof(FloatingPointConstant)) { FloatingPointConstant constant = (FloatingPointConstant)operation; return(new ExecutionResult(constant.Value)); } else if (operation.GetType() == typeof(Variable)) { Variable variable = (Variable)operation; ExecutionResult value; bool variableFound = variables.TryGetValue(variable.Name, out value); if (variableFound) { return(value); } else { throw new VariableNotDefinedException(string.Format("The variable \"{0}\" used is not defined.", variable.Name)); } } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; var executionResult1 = Execute(multiplication.Argument1, functionRegistry, variables); var executionResult2 = Execute(multiplication.Argument2, functionRegistry, variables); return(ExecuteMultiplication(executionResult1, executionResult2)); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; var executionResult1 = Execute(addition.Argument1, functionRegistry, variables); var executionResult2 = Execute(addition.Argument2, functionRegistry, variables); return(ExecuteAddition(executionResult1, executionResult2));; } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; var executionResult1 = Execute(addition.Argument1, functionRegistry, variables); var executionResult2 = Execute(addition.Argument2, functionRegistry, variables); return(ExecuteSubtraction(executionResult1, executionResult2)); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; var executionResult1 = Execute(division.Dividend, functionRegistry, variables); var executionResult2 = Execute(division.Divisor, functionRegistry, variables); return(ExecuteDivision(executionResult1, executionResult2)); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentiation = (Exponentiation)operation; var executionResult1 = Execute(exponentiation.Base, functionRegistry, variables); var executionResult2 = Execute(exponentiation.Exponent, functionRegistry, variables); return(ExecuteExponentiation(executionResult1, executionResult2)); } else if (operation.GetType() == typeof(ChangeUnit)) { ChangeUnit exponentiation = (ChangeUnit)operation; var executionResult1 = Execute(exponentiation.Argument1, functionRegistry, variables); return(ExecuteUnitChange(executionResult1, exponentiation.Unit)); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; var executionResult = Execute(unaryMinus.Argument, functionRegistry, variables); if (executionResult.DataType == DataType.Number) { return(new ExecutionResult(-(double)executionResult.Value)); } else { return(new ExecutionResult(-(UnitNumber)executionResult.Value)); } } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); ExecutionResult[] arguments = new ExecutionResult[functionInfo.IsDynamicFunc ? function.Arguments.Count : functionInfo.NumberOfParameters]; for (int i = 0; i < arguments.Length; i++) { arguments[i] = Execute(function.Arguments[i], functionRegistry, variables); } return(Invoke(functionInfo.Function, arguments)); } else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
public Func <IDictionary <string, VariableCalcurator>, VariableCalcurator> BuildFormulaV2(Operation operation, IFunctionRegistry functionRegistry) { return(variables => { return Execute(operation, functionRegistry, variables); }); }
private void GenerateMethodBody(ILGenerator generator, Operation operation, IFunctionRegistry functionRegistry) { if (operation == null) throw new ArgumentNullException("operation"); if (operation.GetType() == typeof(IntegerConstant)) { IntegerConstant constant = (IntegerConstant)operation; generator.Emit(OpCodes.Ldc_I4, constant.Value); generator.Emit(OpCodes.Conv_R8); } else if (operation.GetType() == typeof(FloatingPointConstant)) { FloatingPointConstant constant = (FloatingPointConstant)operation; generator.Emit(OpCodes.Ldc_R8, constant.Value); } else if (operation.GetType() == typeof(Variable)) { Type dictionaryType = typeof(Dictionary<string, double>); Variable variable = (Variable)operation; Label throwExceptionLabel = generator.DefineLabel(); Label returnLabel = generator.DefineLabel(); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Callvirt, typeof(FormulaContext).GetProperty("Variables").GetGetMethod()); generator.Emit(OpCodes.Ldstr, variable.Name); generator.Emit(OpCodes.Callvirt, dictionaryType.GetMethod("ContainsKey", new Type[] { typeof(string) })); generator.Emit(OpCodes.Ldc_I4_0); generator.Emit(OpCodes.Ceq); generator.Emit(OpCodes.Brtrue_S, throwExceptionLabel); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Callvirt, typeof(FormulaContext).GetProperty("Variables").GetGetMethod()); generator.Emit(OpCodes.Ldstr, variable.Name); generator.Emit(OpCodes.Callvirt, dictionaryType.GetMethod("get_Item", new Type[] { typeof(string) })); generator.Emit(OpCodes.Br_S, returnLabel); generator.MarkLabel(throwExceptionLabel); generator.Emit(OpCodes.Ldstr, string.Format("The variable \"{0}\" used is not defined.", variable.Name)); generator.Emit(OpCodes.Newobj, typeof(VariableNotDefinedException).GetConstructor(new Type[] { typeof(string) })); generator.Emit(OpCodes.Throw); generator.MarkLabel(returnLabel); } else if (operation.GetType() == typeof(Multiplication)) { Multiplication multiplication = (Multiplication)operation; GenerateMethodBody(generator, multiplication.Argument1, functionRegistry); GenerateMethodBody(generator, multiplication.Argument2, functionRegistry); generator.Emit(OpCodes.Mul); } else if (operation.GetType() == typeof(Addition)) { Addition addition = (Addition)operation; GenerateMethodBody(generator, addition.Argument1, functionRegistry); GenerateMethodBody(generator, addition.Argument2, functionRegistry); generator.Emit(OpCodes.Add); } else if (operation.GetType() == typeof(Subtraction)) { Subtraction addition = (Subtraction)operation; GenerateMethodBody(generator, addition.Argument1, functionRegistry); GenerateMethodBody(generator, addition.Argument2, functionRegistry); generator.Emit(OpCodes.Sub); } else if (operation.GetType() == typeof(Division)) { Division division = (Division)operation; GenerateMethodBody(generator, division.Dividend, functionRegistry); GenerateMethodBody(generator, division.Divisor, functionRegistry); generator.Emit(OpCodes.Div); } else if (operation.GetType() == typeof(Modulo)) { Modulo modulo = (Modulo)operation; GenerateMethodBody(generator, modulo.Dividend, functionRegistry); GenerateMethodBody(generator, modulo.Divisor, functionRegistry); generator.Emit(OpCodes.Rem); } else if (operation.GetType() == typeof(Exponentiation)) { Exponentiation exponentation = (Exponentiation)operation; GenerateMethodBody(generator, exponentation.Base, functionRegistry); GenerateMethodBody(generator, exponentation.Exponent, functionRegistry); generator.Emit(OpCodes.Call, typeof(Math).GetMethod("Pow")); } else if (operation.GetType() == typeof(UnaryMinus)) { UnaryMinus unaryMinus = (UnaryMinus)operation; GenerateMethodBody(generator, unaryMinus.Argument, functionRegistry); generator.Emit(OpCodes.Neg); } else if (operation.GetType() == typeof(Function)) { Function function = (Function)operation; FunctionInfo functionInfo = functionRegistry.GetFunctionInfo(function.FunctionName); Type funcType = GetFuncType(functionInfo.NumberOfParameters); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Callvirt, typeof(FormulaContext).GetProperty("FunctionRegistry").GetGetMethod()); generator.Emit(OpCodes.Ldstr, function.FunctionName); generator.Emit(OpCodes.Callvirt, typeof(IFunctionRegistry).GetMethod("GetFunctionInfo", new Type[] { typeof(string) })); generator.Emit(OpCodes.Callvirt, typeof(FunctionInfo).GetProperty("Function").GetGetMethod()); generator.Emit(OpCodes.Castclass, funcType); for (int i = 0; i < functionInfo.NumberOfParameters; i++) GenerateMethodBody(generator, function.Arguments[i], functionRegistry); generator.Emit(OpCodes.Call, funcType.GetMethod("Invoke")); } else { throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation"); } }
public Func<Dictionary<string, double>, double> BuildFormula(Operation operation, IFunctionRegistry functionRegistry) { return variables => Execute(operation, functionRegistry, variables); }