/// <summary> /// Provides the surface of this function if it has been statically defined /// </summary> /// <param name="context">the context used to create the surface</param> /// <returns></returns> public override Surface createSurface(Interpreter.InterpretationContext context) { Surface retVal = null; Values.IValue firstValue = context.findOnStack(First).Value; Values.IValue secondValue = context.findOnStack(Second).Value; Surface firstSurface = createSurfaceForValue(context, firstValue); if (firstSurface != null) { Surface secondSurface = createSurfaceForValue(context, secondValue); if (secondSurface != null) { retVal = firstSurface.Min(secondSurface); } else { Log.Error("Cannot create surface for " + Second.ToString()); } } else { Log.Error("Cannot create surface for " + First.ToString()); } return(retVal); }
/// <summary> /// Provides the graph of this function if it has been statically defined /// </summary> /// <param name="context">the context used to create the graph</param> /// <returns></returns> public virtual Graph createGraph(Interpreter.InterpretationContext context, Parameter parameter) { Graph retVal = Graph; if (retVal == null) { try { Interpreter.InterpretationContext ctxt = new Interpreter.InterpretationContext(context); if (Cases.Count > 0) { // For now, just create graphs for functions using 0 or 1 parameter. if (FormalParameters.Count == 0) { Values.IValue value = Evaluate(ctxt, new Dictionary <Variables.Actual, Values.IValue>()); retVal = Graph.createGraph(value, parameter); } else if (FormalParameters.Count == 1) { Parameter param = (Parameter)FormalParameters[0]; int token = ctxt.LocalScope.PushContext(); Values.IValue actualValue = null; if (parameter != null) { Variables.IVariable actual = ctxt.findOnStack(parameter); if (actual != null) { actualValue = actual.Value; } else { actualValue = new Values.PlaceHolder(parameter.Type, 1); } ctxt.LocalScope.setParameter(param, actualValue); } retVal = createGraphForParameter(ctxt, param); if (getCacheable() && actualValue is Values.PlaceHolder) { Graph = retVal; } ctxt.LocalScope.PopContext(token); } else { Values.IValue value = Evaluate(ctxt, new Dictionary <Variables.Actual, Values.IValue>()); retVal = Graph.createGraph(value, parameter); } } } catch (Exception e) { AddError("Cannot create graph of function, reason : " + e.Message); } } return(retVal); }
/// <summary> /// Provides the value associated to this Expression /// </summary> /// <param name="instance">The instance on which the value is computed</param> /// <param name="localScope">The local scope used to compute the value of this expression</param> /// <param name="globalFind">Indicates that the search should be performed globally</param> /// <returns></returns> public override Values.IValue GetValue(InterpretationContext context) { Values.StructureValue retVal = null; Types.Structure structureType = Structure.GetExpressionType() as Types.Structure; if (structureType != null) { retVal = new Values.StructureValue(structureType, Root); foreach (KeyValuePair <string, Expression> pair in Associations) { Values.IValue val = pair.Value.GetValue(new InterpretationContext(context)); Variables.Variable var = (Variables.Variable)Generated.acceptor.getFactory().createVariable(); var.Name = pair.Key; var.Value = val; var.Enclosing = retVal; retVal.set(var); } } else { AddError("Cannot determine structure type for " + ToString()); } 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> /// 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.IValue retVal = null; Constants.EnumValue enumValue = left as Constants.EnumValue; if (enumValue != null) { left = enumValue.Value; } enumValue = right as Constants.EnumValue; if (enumValue != null) { right = enumValue.Value; } Values.IntValue int1 = left as Values.IntValue; Values.IntValue int2 = right as Values.IntValue; if (int1 == null || int2 == null) { retVal = EFSSystem.DoubleType.PerformArithmericOperation(context, left, Operation, right); } else { retVal = EFSSystem.IntegerType.PerformArithmericOperation(context, left, Operation, right); } 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); Function function = (Function)Generated.acceptor.getFactory().createFunction(); function.Name = "MINSURFACE (" + getName(First) + ", " + getName(Second) + ")"; function.Enclosing = EFSSystem; function.Surface = createSurface(context); Parameter parameterX = (Parameter)Generated.acceptor.getFactory().createParameter(); parameterX.Name = "X"; parameterX.Type = EFSSystem.DoubleType; function.appendParameters(parameterX); Parameter parameterY = (Parameter)Generated.acceptor.getFactory().createParameter(); parameterY.Name = "Y"; parameterY.Type = EFSSystem.DoubleType; function.appendParameters(parameterY); function.ReturnType = EFSSystem.DoubleType; retVal = function; context.LocalScope.PopContext(token); return(retVal); }
/// <summary> /// Provides the textual representation of the namable provided /// </summary> /// <param name="namable"></param> /// <returns></returns> public String explainNamable(INamable namable) { String retVal = ""; if (namable != null) { retVal = namable.Name; Function fonction = namable as Function; if (fonction != null) { if (fonction.Graph != null) { retVal = fonction.Graph.ToString(); } else if (fonction.Surface != null) { retVal = fonction.Surface.ToString(); } } else { Values.IValue value = namable as Values.IValue; if (value != null) { retVal = value.LiteralName; } } } return(retVal); }
/// <summary> /// Provides all the steps used to get the value of the expression /// </summary> /// <returns></returns> public ExplanationPart Explain() { ExplanationPart retVal = new ExplanationPart(Root); currentExplanation = retVal; try { explain = true; InterpretationContext context = new InterpretationContext(); Values.IValue value = GetValue(context); if (value != null) { retVal.Message = ToString() + " = " + explainNamable(value); } else { retVal.Message = "Cannot evaluate value for " + ToString(); } } finally { explain = false; } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="variable"></param> /// <param name="previousValue"></param> /// <param name="newValue"></param> public Change(Variables.IVariable variable, Values.IValue previousValue, Values.IValue newValue) { Variable = variable; PreviousValue = previousValue; NewValue = newValue; Applied = false; }
/// <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> /// Sets up the runner before performing a test case /// </summary> public void Setup() { try { Generated.ControllersManager.NamableController.DesactivateNotification(); // Setup the execution environment Setuper setuper = new Setuper(EFSSystem); foreach (DataDictionary.Dictionary dictionary in EFSSystem.Dictionaries) { setuper.visit(dictionary); } // Clears all caches Utils.FinderRepository.INSTANCE.ClearCache(); // Builds the list of functions that will require a cache for their graph FunctionCacheCleaner = new FunctionGraphCache(EFSSystem); // Setup the step Expression expression = EFSSystem.Parser.Expression(SubSequence.Frame, SubSequence.Frame.getCycleDuration()); Values.IValue value = expression.GetValue(new InterpretationContext(SubSequence.Frame)); Step = Functions.Function.getDoubleValue(value); } finally { Generated.ControllersManager.NamableController.ActivateNotification(); } }
/// <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 = EFSSystem.EmptyValue; Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue; if (value != null) { int token = PrepareIteration(context); for (int i = value.Val.Count - 1; i >= 0; i--) { Values.IValue v = value.Val[i]; if (v != EFSSystem.EmptyValue) { IteratorVariable.Value = v; if (conditionSatisfied(context)) { retVal = IteratorVariable.Value; break; } } NextIteration(); } EndIteration(context, 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; 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 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 = EFSSystem.BoolType.True; Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue; if (value != null) { int token = PrepareIteration(context); if (Condition != null) { foreach (Values.IValue v in value.Val) { if (v != EFSSystem.EmptyValue) { IteratorVariable.Value = v; if (!conditionSatisfied(context)) { retVal = EFSSystem.BoolType.False; break; } } NextIteration(); } } EndIteration(context, 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; try { recursionCount += 1; if (recursionCount > 10) { System.Diagnostics.Debugger.Break(); } int token = context.LocalScope.PushContext(); AssignParameters(context, actuals); Function function = (Function)Generated.acceptor.getFactory().createFunction(); function.Name = "MIN (" + getName(First) + ", " + getName(Second) + ")"; function.Enclosing = EFSSystem; Parameter parameter = (Parameter)Generated.acceptor.getFactory().createParameter(); parameter.Name = "X"; parameter.Type = EFSSystem.DoubleType; function.appendParameters(parameter); function.ReturnType = EFSSystem.DoubleType; function.Graph = createGraph(context, parameter); retVal = function; context.LocalScope.PopContext(token); } finally { recursionCount -= 1; } return(retVal); }
public override bool CompareForEquality(Values.IValue left, Values.IValue right) // left == right { bool retVal = base.CompareForEquality(left, right); if (!retVal) { if (left.Type == right.Type) { Values.StructureValue leftValue = left as Values.StructureValue; Values.StructureValue rightValue = right as Values.StructureValue; if (left != null && right != null) { retVal = true; foreach (KeyValuePair <string, Variables.IVariable> pair in leftValue.SubVariables) { Variables.IVariable leftVar = pair.Value; Variables.IVariable rightVar = rightValue.getVariable(pair.Key); if (leftVar.Type != null) { retVal = leftVar.Type.CompareForEquality(leftVar.Value, rightVar.Value); if (!retVal) { break; } } } } } } return(retVal); }
public override bool Contains(Values.IValue first, Values.IValue other) { bool retVal = false; Values.ListValue listValue = first as Values.ListValue; if (listValue != null) { foreach (Values.IValue value in listValue.Val) { StateMachine stateMachine = value.Type as StateMachine; if (stateMachine != null) { if (stateMachine.Contains(value, other)) { retVal = true; break; } } else { if (value.Type.CompareForEquality(value, other)) { retVal = true; break; } } } } return(retVal); }
/// <summary> /// Creates a surface for an Ivalue provided /// </summary> /// <param name="xParam"></param> /// <param name="yParam"></param> /// <param name="iValue"></param> /// <returns></returns> public static Surface createSurface(Parameter xParam, Parameter yParam, Values.IValue iValue) { Surface retVal = null; if (retVal == null) { Functions.Function function = iValue as Function; if (function != null) { retVal = function.Surface; if (retVal == null) { Graph graph = function.Graph; if (graph != null) { retVal = new Surface(xParam, yParam); Segment segment = new Segment(0, double.MaxValue, graph); retVal.AddSegment(segment); } } } } if (retVal == null) { retVal = new Surface(xParam, yParam); Segment segment = new Segment(0, double.MaxValue, Graph.createGraph(iValue, yParam)); retVal.AddSegment(segment); } 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); Function function = (Function)Generated.acceptor.getFactory().createFunction(); function.Name = "AddIncrement ( Function => " + getName(Function) + ", Value => " + getName(Increment) + ")"; function.Enclosing = EFSSystem; Parameter parameter = (Parameter)Generated.acceptor.getFactory().createParameter(); parameter.Name = "X"; parameter.Type = EFSSystem.DoubleType; function.appendParameters(parameter); function.ReturnType = EFSSystem.DoubleType; function.Graph = createGraph(context, parameter); retVal = function; context.LocalScope.PopContext(token); return(retVal); }
/// <summary> /// Provides the graph of this function if it has been statically defined /// </summary> /// <param name="context">the context used to create the graph</param> /// <returns></returns> public override Graph createGraph(Interpreter.InterpretationContext context, Parameter parameter) { Graph retVal = null; Values.IValue firstValue = context.findOnStack(First).Value; Values.IValue secondValue = context.findOnStack(Second).Value; Graph firstGraph = createGraphForValue(context, firstValue, parameter); if (firstGraph != null) { Graph secondGraph = createGraphForValue(context, secondValue, parameter); if (secondGraph != null) { retVal = firstGraph.Max(secondGraph); } else { Log.Error("Cannot create graph for " + Second.ToString()); } } else { Log.Error("Cannot create graph for " + First.ToString()); } 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; Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue; if (value != null) { int token = PrepareIteration(context); context.LocalScope.setVariable(AccumulatorVariable); AccumulatorVariable.Value = InitialValue.GetValue(context); foreach (Values.IValue v in value.Val) { if (v != EFSSystem.EmptyValue) { IteratorVariable.Value = v; if (conditionSatisfied(context)) { AccumulatorVariable.Value = IteratorExpression.GetValue(context); } } NextIteration(); } EndIteration(context, token); retVal = AccumulatorVariable.Value; } else { AddError("Cannot evaluate list value " + ListExpression.ToString()); } 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> /// Creates the graph for a value /// </summary> /// <param name="value"></param> /// <returns></returns> public static Graph createGraphForValue(Values.IValue value) { Graph retVal = new Graph(); double val = Functions.Function.getDoubleValue(value); retVal.addSegment(new Graph.Segment(0, double.MaxValue, new Graph.Segment.Curve(0.0, val, 0.0))); return(retVal); }
public override bool Greater(Values.IValue left, Values.IValue right) // left > right { bool retVal = false; double double1 = getValue(left); double double2 = getValue(right); retVal = double1 > double2; return(retVal); }
public override bool Less(Values.IValue left, Values.IValue right) // left < right { bool retVal = false; double double1 = getValue(left); double double2 = getValue(right); retVal = double1 < double2; return(retVal); }
/// <summary> /// Provides the changes performed by this statement /// </summary> /// <param name="context">The context on which the changes should be computed</param> /// <param name="changes">The list to fill with the changes</param> /// <param name="explanation">The explanatino to fill, if any</param> /// <param name="apply">Indicates that the changes should be applied immediately</param> public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply) { Variables.IVariable variable = ListExpression.GetVariable(context); if (variable != null) { // HacK : ensure that the value is a correct rigth side // and keep the result of the right side operation Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue; variable.Value = listValue; if (listValue != null) { Values.ListValue newListValue = new Values.ListValue(listValue); int i = 0; foreach (Values.IValue current in newListValue.Val) { IteratorVariable.Value = current; if (conditionSatisfied(context)) { break; } i += 1; } if (i < newListValue.Val.Count) { Values.IValue value = Value.GetValue(context); if (value != null) { newListValue.Val[i] = value; Rules.Change change = new Rules.Change(variable, variable.Value, newListValue); changes.Add(change, apply); explanation.SubExplanations.Add(new ExplanationPart(Root, change)); } else { Root.AddError("Cannot find value for " + Value.ToString()); } } else { Root.AddError("Cannot find value in " + ListExpression.ToString() + " which satisfies " + Condition.ToString()); } } else { Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value"); } } else { Root.AddError("Cannot find variable for " + ListExpression.ToString()); } }
/// <summary> /// Inserts a value in the result set /// </summary> /// <param name="newListValue"></param> /// <param name="value"></param> private void InsertInResult(Values.ListValue newListValue, Values.IValue value) { if (Position == PositionEnum.Last) { newListValue.Val.Insert(0, value); } else { newListValue.Val.Add(value); } }
/// <summary> /// Provides the values whose name matches the name provided /// </summary> /// <param name="index">the index in names to consider</param> /// <param name="names">the simple value names</param> public virtual Values.IValue findValue(string[] names, int index) { Values.IValue retVal = null; if (index == names.Length - 1) { retVal = getValue(names[index]); } 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; Interpreter.Expression expression = EFSSystem.Parser.Expression(this, image); if (expression != null) { retVal = expression.GetValue(new Interpreter.InterpretationContext(this)); } return(retVal); }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(Utils.INamable instance, Filter.AcceptableChoice expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { Value = Type.getValue(Image); if (Value == null) { AddError("Cannot evaluate " + ToString() + " as a number"); } } return retVal; }
/// <summary> /// Clears the caches for this function /// </summary> public void ClearCache() { CachedValue = null; Graph = null; Surface = null; }
/// <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; }