/// <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;
}
