/// <summary> /// Provides the double value according to the value provided /// </summary> /// <param name="value"></param> /// <returns></returns> public static double getDoubleValue(Values.IValue value) { double retVal = 0; if (!(value is Values.EmptyValue)) { Constants.EnumValue enumValue = value as Constants.EnumValue; if (enumValue != null) { value = enumValue.Value; } Values.IntValue intValue = value as Values.IntValue; if (intValue != null) { retVal = (double)intValue.Val; } else { Values.DoubleValue doubleValue = value as Values.DoubleValue; if (doubleValue != null) { retVal = doubleValue.Val; } else if (value != null) { throw new Exception("Value " + value.Name + " cannot be converted to double"); } } } return(retVal); }
/// <summary> /// Creates the graph associated to the parameter provided /// </summary> /// <param name="value">The value for which the graph must be created</param> /// <returns></returns> protected Graph createGraphForValue(Interpreter.InterpretationContext context, Values.IValue value, Parameter parameter = null) { Graph retVal = new Graph(); Function function = value as Function; if (function != null) { if (parameter == null) { parameter = (Parameter)function.FormalParameters[0]; int token = context.LocalScope.PushContext(); context.LocalScope.setGraphParameter(parameter); retVal = function.createGraph(context, parameter); context.LocalScope.PopContext(token); } else { retVal = function.createGraph(context, parameter); } } else { Values.DoubleValue val = value as Values.DoubleValue; retVal.addSegment(new Graph.Segment(0, double.MaxValue, new Graph.Segment.Curve(0.0, val.Val, 0.0))); } return(retVal); }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="actuals">the actual parameters values</param> /// <param name="localScope">the values of local variables</param> /// <returns>The value for the function application</returns> public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = null; int token = context.LocalScope.PushContext(); AssignParameters(context, actuals); Functions.Function function = context.findOnStack(Function).Value as Functions.Function; if (function != null) { double speed = Functions.Function.getDoubleValue(context.findOnStack(Speed).Value); Parameter parameter = (Parameter)function.FormalParameters[0]; int token2 = context.LocalScope.PushContext(); context.LocalScope.setGraphParameter(parameter); Graph graph = function.createGraph(context, (Parameter)function.FormalParameters[0]); context.LocalScope.PopContext(token2); retVal = new Values.DoubleValue(EFSSystem.DoubleType, graph.SolutionX(speed)); } else { Log.Error("Cannot get function for " + Function.ToString()); } context.LocalScope.PopContext(token); return(retVal); }
/// <summary> /// Compares two ranges for equality /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> public override bool CompareForEquality(Values.IValue left, Values.IValue right) { bool retVal = false; Values.IntValue int1 = left as Values.IntValue; Values.IntValue int2 = right as Values.IntValue; if (int1 != null && int2 != null) { retVal = (int1.Val == int2.Val); } else { Values.DoubleValue double1 = left as Values.DoubleValue; Values.DoubleValue double2 = right as Values.DoubleValue; if (double1 != null && double2 != null) { retVal = Types.DoubleType.CompareDoubleForEquality(double1.Val, double2.Val);; } else { retVal = base.CompareForEquality(left, right); } } return(retVal); }
/// <summary> /// Gets a value based on its image /// </summary> /// <param name="image"></param> /// <returns></returns> public override Values.IValue getValue(string image) { System.Globalization.CultureInfo info = System.Globalization.CultureInfo.InvariantCulture; Values.DoubleValue retVal = new Values.DoubleValue(this, double.Parse(image, info.NumberFormat)); return(retVal); }
/// <summary> /// Provides the value associated to this Expression /// </summary> /// <param name="context">The context on which the value must be found</param> /// <returns></returns> public override Values.IValue GetValue(InterpretationContext context) { Values.IValue retVal = null; if (Term != null) { retVal = Term.GetValue(context); } else { if (NOT.CompareTo(UnaryOp) == 0) { Values.BoolValue b = Expression.GetValue(context) as Values.BoolValue; if (b != null) { if (b.Val) { retVal = EFSSystem.BoolType.False; } else { retVal = EFSSystem.BoolType.True; } } else { AddError("Expression " + Expression.ToString() + " does not evaluate to boolean"); } } else if (MINUS.CompareTo(UnaryOp) == 0) { Values.IValue val = Expression.GetValue(context); Values.IntValue intValue = val as Values.IntValue; if (intValue != null) { retVal = new Values.IntValue(intValue.Type, -intValue.Val); } else { Values.DoubleValue doubleValue = val as Values.DoubleValue; if (doubleValue != null) { retVal = new Values.DoubleValue(doubleValue.Type, -doubleValue.Val); } } if (retVal == null) { AddError("Cannot negate value for " + Expression.ToString()); } } else { retVal = Expression.GetValue(context); } } return(retVal); }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="actuals">the actual parameters values</param> /// <param name="localScope">the values of local variables</param> /// <returns>The value for the function application</returns> public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = null; AssignParameters(context, actuals); Graph graph = createGraphForValue(context, context.findOnStack(FunctionA).Value); if (graph != null) { foreach (Graph.Segment segment in graph.Segments) { if (segment.Expression.a == 0.0) { double speed = segment.Expression.v0; Function function = context.findOnStack(FunctionB).Value as Function; if (function.FormalParameters.Count > 0) { Parameter functionParameter = function.FormalParameters[0] as Parameter; Variables.Actual actual = functionParameter.createActual(); actual.Value = new Values.DoubleValue(EFSSystem.DoubleType, speed); Dictionary <Variables.Actual, Values.IValue> values = new Dictionary <Variables.Actual, Values.IValue>(); values[actual] = new Values.DoubleValue(EFSSystem.DoubleType, speed); Values.IValue solution = function.Evaluate(context, values); double doubleValue = getDoubleValue(solution); if (doubleValue >= segment.Start && doubleValue <= segment.End) { retVal = new Values.DoubleValue(EFSSystem.DoubleType, doubleValue); break; } } else { Log.Error("The FunctionB doesn't have any parameter"); break; } } else { Log.Error("The FunctionA is not a step function"); break; } } } else { Log.Error("Cannot create graph for " + FunctionA.ToString()); } if (retVal == null) { Log.Error("Cannot compute the intersection of " + FunctionA.ToString() + " and " + FunctionB.ToString()); } return(retVal); }
/// <summary> /// Parses the image and provides the corresponding value /// </summary> /// <param name="image"></param> /// <returns></returns> public override Values.IValue getValue(string image) { Values.IValue retVal = null; if (Char.IsLetter(image[0]) || image[0] == '_') { retVal = findEnumValue(image); if (retVal == null) { Log.Error("Cannot create range value from " + image); } } else { try { switch (getPrecision()) { case Generated.acceptor.PrecisionEnum.aIntegerPrecision: { Decimal val = Decimal.Parse(image); Decimal min = MinValueAsLong; Decimal max = MaxValueAsLong; if (val >= min && val <= max) { retVal = new Values.IntValue(this, val); } } break; case Generated.acceptor.PrecisionEnum.aDoublePrecision: { System.Globalization.CultureInfo info = System.Globalization.CultureInfo.InvariantCulture; double val = getDouble(image); double min = MinValueAsDouble; double max = MaxValueAsDouble; if (val >= min && val <= max && image.IndexOf('.') >= 0) { retVal = new Values.DoubleValue(this, val); } break; } } } catch (Exception exception) { Log.Error("Cannot create range value", exception); } } return(retVal); }
/// <summary> /// Converts a value in this type /// </summary> /// <param name="value">The value to convert</param> /// <returns></returns> public Values.IValue convert(Values.IValue value) { Values.IValue retVal = null; Constants.EnumValue enumValue = value as Constants.EnumValue; if (enumValue != null && enumValue.Range != null) { retVal = findEnumValue(enumValue.Name); if (retVal == null) { Log.Error("Cannot convert " + enumValue.Name + " to " + FullName); } } else { try { switch (getPrecision()) { case Generated.acceptor.PrecisionEnum.aIntegerPrecision: { Decimal val = getValueAsInt(value); Decimal min = MinValueAsLong; Decimal max = MaxValueAsLong; if (val >= min && val <= max) { retVal = new Values.IntValue(this, val); } } break; case Generated.acceptor.PrecisionEnum.aDoublePrecision: { double val = getValueAsDouble(value); double min = MinValueAsDouble; double max = MaxValueAsDouble; if (val >= min && val <= max) { retVal = new Values.DoubleValue(this, val); } break; } } } catch (Exception exception) { Log.Error("Cannot convert range value", exception); } } return(retVal); }
/// <summary> /// Provides the double value from the IValue provided /// </summary> /// <param name="val"></param> /// <returns></returns> private double getValue(Values.IValue val) { double retVal = 0; Constants.EnumValue enumValue = val as Constants.EnumValue; if (enumValue != null) { val = enumValue.Value; } Values.DoubleValue vd = val as Values.DoubleValue; if (vd != null) { retVal = vd.Val; } else { Values.IntValue vi = val as Values.IntValue; if (vi != null) { retVal = (double)vi.Val; } else { Functions.Function function = val as Functions.Function; if (function != null) { Functions.Graph graph = function.Graph; if (graph != null) { if (graph.Segments.Count == 1) { retVal = graph.Val(0); } } } } } return(retVal); }
/// <summary> /// Creates the graph of the function on which the increment function has been added /// </summary> /// <param name="context">the context used to evaluate the function</param> /// <param name="increment">The increment function do add</param> /// <returns></returns> public Graph AddIncrement(Interpreter.InterpretationContext context, Functions.Function increment) { Graph retVal = new Graph(); if (IsFlat() && increment.FormalParameters.Count == 1) { Parameter parameter = (Parameter)increment.FormalParameters[0]; foreach (Segment segment in Segments) { Dictionary <Variables.Actual, Values.IValue> actuals = new Dictionary <Variables.Actual, Values.IValue>(); Variables.Actual actual = parameter.createActual(); actuals[actual] = new Values.DoubleValue(increment.EFSSystem.DoubleType, segment.Expression.v0); Values.IValue result = increment.Evaluate(context, actuals); Segment newSegment = new Segment(segment); newSegment.Expression.v0 = segment.Expression.v0 + Function.getDoubleValue(result); retVal.addSegment(newSegment); } } return(retVal); }
/// <summary> /// Creates the surface associated to the value provided /// </summary> /// <param name="value"></param> /// <returns></returns> protected Surface createSurfaceForValue(Interpreter.InterpretationContext context, Values.IValue value) { Surface retVal = null; Function function = value as Function; if (function != null) { retVal = function.createSurface(context); } else { Values.DoubleValue val = value as Values.DoubleValue; Graph graph = new Graph(); graph.addSegment(new Graph.Segment(0, double.MaxValue, new Graph.Segment.Curve(0, val.Val, 0))); retVal = new Functions.Surface(null, null); retVal.AddSegment(new Surface.Segment(0, double.MaxValue, graph)); } return(retVal); }
/// <summary> /// Performs the arithmetic operation based on the type of the result /// </summary> /// <param name="context">The context used to perform this operation</param> /// <param name="left"></param> /// <param name="Operation"></param> /// <param name="right"></param> /// <returns></returns> public override Values.IValue PerformArithmericOperation(Interpreter.InterpretationContext context, Values.IValue left, Interpreter.BinaryExpression.OPERATOR Operation, Values.IValue right) // left +/-/*/div/exp right { Values.DoubleValue retVal = null; double double1 = getValue(left); double double2 = getValue(right); switch (Operation) { case Interpreter.BinaryExpression.OPERATOR.EXP: retVal = new Values.DoubleValue(this, Math.Pow(double1, double2)); break; case Interpreter.BinaryExpression.OPERATOR.MULT: retVal = new Values.DoubleValue(this, (double1 * double2)); break; case Interpreter.BinaryExpression.OPERATOR.DIV: if (double2 == 0) { throw new Exception("Division by zero"); } else { retVal = new Values.DoubleValue(this, (double1 / double2)); } break; case Interpreter.BinaryExpression.OPERATOR.ADD: retVal = new Values.DoubleValue(this, (double1 + double2)); break; case Interpreter.BinaryExpression.OPERATOR.SUB: retVal = new Values.DoubleValue(this, (double1 - double2)); break; } return(retVal); }
/// <summary> /// Provides the value as a decimal value /// </summary> /// <param name="value"></param> /// <returns></returns> private Decimal getValueAsInt(Values.IValue value) { Decimal retVal; Values.IntValue intVal = value as Values.IntValue; if (intVal != null) { retVal = intVal.Val; } else { Values.DoubleValue doubleVal = value as Values.DoubleValue; if (doubleVal != null) { retVal = new Decimal(Math.Round(doubleVal.Val)); } else { throw new Exception("Cannot convert value " + value + " to " + FullName); } } return(retVal); }
/// <summary> /// Provides the value as a double value /// </summary> /// <param name="value"></param> /// <returns></returns> private Double getValueAsDouble(Values.IValue value) { Double retVal; Values.IntValue intVal = value as Values.IntValue; if (intVal != null) { retVal = Decimal.ToDouble(intVal.Val); } else { Values.DoubleValue doubleVal = value as Values.DoubleValue; if (doubleVal != null) { retVal = doubleVal.Val; } else { throw new Exception("Cannot convert value " + value + " to " + FullName); } } return(retVal); }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="actuals">the actual parameters values</param> /// <returns>The value for the function application</returns> public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = null; int token = context.LocalScope.PushContext(); AssignParameters(context, actuals); Values.DoubleValue value = context.findOnStack(Value).Value as Values.DoubleValue; Values.DoubleValue multiple = context.findOnStack(Multiple).Value as Values.DoubleValue; if (value != null && multiple != null) { double res = Math.Floor(value.Val); while (res > 0 && res % multiple.Val != 0) { res--; } retVal = new Values.DoubleValue(ReturnType, res); } context.LocalScope.PopContext(token); return(retVal); }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="actuals">the actual parameters values</param> /// <returns>The value for the function application</returns> public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary<Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = null; int token = context.LocalScope.PushContext(); AssignParameters(context, actuals); Values.DoubleValue value = context.findOnStack(Value).Value as Values.DoubleValue; Values.DoubleValue multiple = context.findOnStack(Multiple).Value as Values.DoubleValue; if (value != null && multiple != null) { double res = Math.Floor(value.Val); while (res > 0 && res % multiple.Val != 0) { res--; } retVal = new Values.DoubleValue(ReturnType, res); } context.LocalScope.PopContext(token); return retVal; }
/// <summary> /// Gets a value based on its image /// </summary> /// <param name="image"></param> /// <returns></returns> public override Values.IValue getValue(string image) { System.Globalization.CultureInfo info = System.Globalization.CultureInfo.InvariantCulture; Values.DoubleValue retVal = new Values.DoubleValue(this, double.Parse(image, info.NumberFormat)); return retVal; }
// left +/-/*/div/exp right /// <summary> /// Performs the arithmetic operation based on the type of the result /// </summary> /// <param name="context">The context used to perform this operation</param> /// <param name="left"></param> /// <param name="Operation"></param> /// <param name="right"></param> /// <returns></returns> public override Values.IValue PerformArithmericOperation(Interpreter.InterpretationContext context, Values.IValue left, Interpreter.BinaryExpression.OPERATOR Operation, Values.IValue right) { Values.DoubleValue retVal = null; double double1 = getValue(left); double double2 = getValue(right); switch (Operation) { case Interpreter.BinaryExpression.OPERATOR.EXP: retVal = new Values.DoubleValue(this, Math.Pow(double1, double2)); break; case Interpreter.BinaryExpression.OPERATOR.MULT: retVal = new Values.DoubleValue(this, (double1 * double2)); break; case Interpreter.BinaryExpression.OPERATOR.DIV: if (double2 == 0) throw new Exception("Division by zero"); else retVal = new Values.DoubleValue(this, (double1 / double2)); break; case Interpreter.BinaryExpression.OPERATOR.ADD: retVal = new Values.DoubleValue(this, (double1 + double2)); break; case Interpreter.BinaryExpression.OPERATOR.SUB: retVal = new Values.DoubleValue(this, (double1 - double2)); break; } return retVal; }
/// <summary> /// Provides the value associated to this Expression /// </summary> /// <param name="context">The context on which the value must be found</param> /// <returns></returns> public override Values.IValue GetValue(InterpretationContext context) { Values.IValue retVal = null; if (Term != null) { retVal = Term.GetValue(context); } else { if (NOT.CompareTo(UnaryOp) == 0) { Values.BoolValue b = Expression.GetValue(context) as Values.BoolValue; if (b != null) { if (b.Val) { retVal = EFSSystem.BoolType.False; } else { retVal = EFSSystem.BoolType.True; } } else { AddError("Expression " + Expression.ToString() + " does not evaluate to boolean"); } } else if (MINUS.CompareTo(UnaryOp) == 0) { Values.IValue val = Expression.GetValue(context); Values.IntValue intValue = val as Values.IntValue; if (intValue != null) { retVal = new Values.IntValue(intValue.Type, -intValue.Val); } else { Values.DoubleValue doubleValue = val as Values.DoubleValue; if (doubleValue != null) { retVal = new Values.DoubleValue(doubleValue.Type, -doubleValue.Val); } } if (retVal == null) { AddError("Cannot negate value for " + Expression.ToString()); } } else { retVal = Expression.GetValue(context); } } return retVal; }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="actuals">the actual parameters values</param> /// <param name="localScope">the values of local variables</param> /// <returns>The value for the function application</returns> public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary<Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = null; int token = context.LocalScope.PushContext(); AssignParameters(context, actuals); Functions.Function function = context.findOnStack(Function).Value as Functions.Function; if (function != null) { double speed = Functions.Function.getDoubleValue(context.findOnStack(Speed).Value); Parameter parameter = (Parameter)function.FormalParameters[0]; int token2 = context.LocalScope.PushContext(); context.LocalScope.setGraphParameter(parameter); Graph graph = function.createGraph(context, (Parameter)function.FormalParameters[0]); context.LocalScope.PopContext(token2); retVal = new Values.DoubleValue(EFSSystem.DoubleType, graph.SolutionX(speed)); } else { Log.Error("Cannot get function for " + Function.ToString()); } context.LocalScope.PopContext(token); return retVal; }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="actuals">the actual parameters values</param> /// <param name="localScope">the values of local variables</param> /// <returns>The value for the function application</returns> public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary<Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = null; AssignParameters(context, actuals); Graph graph = createGraphForValue(context, context.findOnStack(FunctionA).Value); if (graph != null) { foreach (Graph.Segment segment in graph.Segments) { if (segment.Expression.a == 0.0) { double speed = segment.Expression.v0; Function function = context.findOnStack(FunctionB).Value as Function; if (function.FormalParameters.Count > 0) { Parameter functionParameter = function.FormalParameters[0] as Parameter; Variables.Actual actual = functionParameter.createActual(); actual.Value = new Values.DoubleValue(EFSSystem.DoubleType, speed); Dictionary<Variables.Actual, Values.IValue> values = new Dictionary<Variables.Actual, Values.IValue>(); values[actual] = new Values.DoubleValue(EFSSystem.DoubleType, speed); Values.IValue solution = function.Evaluate(context, values); double doubleValue = getDoubleValue(solution); if (doubleValue >= segment.Start && doubleValue <= segment.End) { retVal = new Values.DoubleValue(EFSSystem.DoubleType, doubleValue); break; } } else { Log.Error("The FunctionB doesn't have any parameter"); break; } } else { Log.Error("The FunctionA is not a step function"); break; } } } else { Log.Error("Cannot create graph for " + FunctionA.ToString()); } if (retVal == null) { Log.Error("Cannot compute the intersection of " + FunctionA.ToString() + " and " + FunctionB.ToString()); } return retVal; }
/// <summary> /// Converts a value in this type /// </summary> /// <param name="value">The value to convert</param> /// <returns></returns> public Values.IValue convert(Values.IValue value) { Values.IValue retVal = null; Constants.EnumValue enumValue = value as Constants.EnumValue; if (enumValue != null && enumValue.Range != null) { retVal = findEnumValue(enumValue.Name); if (retVal == null) { Log.Error("Cannot convert " + enumValue.Name + " to " + FullName); } } else { try { switch (getPrecision()) { case Generated.acceptor.PrecisionEnum.aIntegerPrecision: { Decimal val = getValueAsInt(value); Decimal min = MinValueAsLong; Decimal max = MaxValueAsLong; if (val >= min && val <= max) { retVal = new Values.IntValue(this, val); } } break; case Generated.acceptor.PrecisionEnum.aDoublePrecision: { double val = getValueAsDouble(value); double min = MinValueAsDouble; double max = MaxValueAsDouble; if (val >= min && val <= max) { retVal = new Values.DoubleValue(this, val); } break; } } } catch (Exception exception) { Log.Error("Cannot convert range value", exception); } } return retVal; }
/// <summary> /// Parses the image and provides the corresponding value /// </summary> /// <param name="image"></param> /// <returns></returns> public override Values.IValue getValue(string image) { Values.IValue retVal = null; if (Char.IsLetter(image[0]) || image[0] == '_') { retVal = findEnumValue(image); if (retVal == null) { Log.Error("Cannot create range value from " + image); } } else { try { switch (getPrecision()) { case Generated.acceptor.PrecisionEnum.aIntegerPrecision: { Decimal val = Decimal.Parse(image); Decimal min = MinValueAsLong; Decimal max = MaxValueAsLong; if (val >= min && val <= max) { retVal = new Values.IntValue(this, val); } } break; case Generated.acceptor.PrecisionEnum.aDoublePrecision: { System.Globalization.CultureInfo info = System.Globalization.CultureInfo.InvariantCulture; double val = getDouble(image); double min = MinValueAsDouble; double max = MaxValueAsDouble; if (val >= min && val <= max && image.IndexOf('.') >= 0) { retVal = new Values.DoubleValue(this, val); } break; } } } catch (Exception exception) { Log.Error("Cannot create range value", exception); } } return retVal; }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="localScope">the values of local variables</param> /// <returns>The value for the function application</returns> public virtual Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary<Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = CachedValue; if (retVal == null) { int token = context.LocalScope.PushContext(); AssignParameters(context, actuals); if (Cases.Count > 0) { // Statically defined function foreach (Case aCase in Cases) { if (aCase.EvaluatePreConditions(context)) { retVal = aCase.Expression.GetValue(context); break; } } } else if (Surface != null && FormalParameters.Count == 2) { double x = 0.0; double y = 0.0; Parameter formal1 = (Parameter)FormalParameters[0]; Parameter formal2 = (Parameter)FormalParameters[1]; foreach (KeyValuePair<Variables.Actual, Values.IValue> pair in actuals) { if (pair.Key.Parameter == formal1) { x = Functions.Function.getDoubleValue(pair.Value); } if (pair.Key.Parameter == formal2) { y = Functions.Function.getDoubleValue(pair.Value); } } retVal = new Values.DoubleValue(EFSSystem.DoubleType, Surface.Val(x, y)); } else if (Graph != null && FormalParameters.Count < 2) { if (FormalParameters.Count == 0) { retVal = new Values.DoubleValue(EFSSystem.DoubleType, Graph.Val(0)); } else if (FormalParameters.Count == 1) { double x = 0.0; Parameter formal = (Parameter)FormalParameters[0]; foreach (KeyValuePair<Variables.Actual, Values.IValue> pair in actuals) { if (pair.Key.Parameter == formal) { x = Functions.Function.getDoubleValue(pair.Value); } } retVal = new Values.DoubleValue(EFSSystem.DoubleType, Graph.Val(x)); } } context.LocalScope.PopContext(token); if (getCacheable() && actuals.Count == 0) { CachedValue = retVal; } } return retVal; }
/// <summary> /// Provides the value of the function /// </summary> /// <param name="instance">the instance on which the function is evaluated</param> /// <param name="localScope">the values of local variables</param> /// <returns>The value for the function application</returns> public virtual Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals) { Values.IValue retVal = CachedValue; if (retVal == null) { int token = context.LocalScope.PushContext(); AssignParameters(context, actuals); if (Cases.Count > 0) { // Statically defined function foreach (Case aCase in Cases) { if (aCase.EvaluatePreConditions(context)) { retVal = aCase.Expression.GetValue(context); break; } } } else if (Surface != null && FormalParameters.Count == 2) { double x = 0.0; double y = 0.0; Parameter formal1 = (Parameter)FormalParameters[0]; Parameter formal2 = (Parameter)FormalParameters[1]; foreach (KeyValuePair <Variables.Actual, Values.IValue> pair in actuals) { if (pair.Key.Parameter == formal1) { x = Functions.Function.getDoubleValue(pair.Value); } if (pair.Key.Parameter == formal2) { y = Functions.Function.getDoubleValue(pair.Value); } } retVal = new Values.DoubleValue(EFSSystem.DoubleType, Surface.Val(x, y)); } else if (Graph != null && FormalParameters.Count < 2) { if (FormalParameters.Count == 0) { retVal = new Values.DoubleValue(EFSSystem.DoubleType, Graph.Val(0)); } else if (FormalParameters.Count == 1) { double x = 0.0; Parameter formal = (Parameter)FormalParameters[0]; foreach (KeyValuePair <Variables.Actual, Values.IValue> pair in actuals) { if (pair.Key.Parameter == formal) { x = Functions.Function.getDoubleValue(pair.Value); } } retVal = new Values.DoubleValue(EFSSystem.DoubleType, Graph.Val(x)); } } context.LocalScope.PopContext(token); if (getCacheable() && actuals.Count == 0) { CachedValue = retVal; } } return(retVal); }