/// <summary>
/// Provides the list of parameter whose value is a place holder
/// </summary>
/// <returns></returns>
public List <Parameter> PlaceHolders()
{
List <Parameter> retVal = new List <Parameter>();
for (int i = Values.Count - 1; i >= 0; i--)
{
Variables.Actual actual = Values[i] as Variables.Actual;
if (actual != null)
{
if (actual.Value is Values.PlaceHolder)
{
// Insert if no other parameter with the same name is present in the result
bool found = false;
foreach (Parameter param2 in retVal)
{
if (param2 == actual.Parameter)
{
found = true;
break;
}
}
if (!found)
{
retVal.Add(actual.Parameter);
}
}
}
}
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 an actual parameter based on this formal parameter and the value assigned to that parameter
/// </summary>
/// <returns></returns>
public Variables.Actual createActual()
{
Variables.Actual retVal = new Variables.Actual();
retVal.Name = Name;
retVal.Enclosing = Enclosing;
retVal.Parameter = this;
return(retVal);
}
/// <summary>
/// Creates the parameter value associationg according to actual parameters
/// </summary>
/// <param name="context">The interpretation context</param>
/// <param name="callable">The callable</param>
/// <param name="log">Indicates whether errors should be logged</param>
/// <returns></returns>
public Dictionary <Variables.Actual, Values.IValue> AssignParameterValues(InterpretationContext context, ICallable callable, bool log)
{
// Compute the unnamed actual parameter values
Dictionary <Variables.Actual, Values.IValue> retVal = new Dictionary <Variables.Actual, Values.IValue>();
if (callable.FormalParameters.Count == NamedActualParameters.Count + ActualParameters.Count)
{
int i = 0;
foreach (Expression expression in ActualParameters)
{
Parameter parameter = callable.FormalParameters[i] as Parameter;
Values.IValue val = expression.GetValue(context);
if (val != null)
{
Variables.Actual actual = parameter.createActual();
val = val.RightSide(actual, false);
retVal.Add(actual, val);
}
else
{
AddError("Cannot evaluate value for parameter " + i + " (" + expression.ToString() + ") of function " + callable.Name);
return(new Dictionary <Variables.Actual, Values.IValue>());
}
i = i + 1;
}
foreach (KeyValuePair <string, Expression> pair in NamedActualParameters)
{
Parameter parameter = callable.getFormalParameter(pair.Key);
Values.IValue val = pair.Value.GetValue(context);
if (val != null)
{
Variables.Actual actual = parameter.createActual();
val = val.RightSide(actual, false);
actual.Value = val;
retVal.Add(actual, val);
}
else
{
AddError("Cannot evaluate value for parameter " + pair.Key + " of function " + callable.Name);
return(new Dictionary <Variables.Actual, Values.IValue>());
}
}
}
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>
/// Provides the parameters whose value are place holders
/// </summary>
/// <param name="function">The function on which the call is performed</param>
/// <param name="parameterValues">The actual parameter values</param>
/// <returns></returns>
private List <Parameter> GetPlaceHolders(Functions.Function function, Dictionary <Variables.Actual, Values.IValue> parameterValues)
{
List <Parameter> retVal = new List <Parameter>();
foreach (KeyValuePair <Variables.Actual, Values.IValue> pair in parameterValues)
{
Variables.Actual actual = pair.Key;
Values.PlaceHolder placeHolder = pair.Value as Values.PlaceHolder;
if (placeHolder != null && actual.Parameter.Enclosing == function)
{
retVal.Add(actual.Parameter);
}
}
if (retVal.Count != parameterValues.Count || retVal.Count == 0)
{
retVal = null;
}
return(retVal);
}
/// <summary>
/// Creates an actual parameter based on this formal parameter and the value assigned to that parameter
/// </summary>
/// <returns></returns>
public Variables.Actual createActual()
{
Variables.Actual retVal = new Variables.Actual();
retVal.Name = Name;
retVal.Enclosing = Enclosing;
retVal.Parameter = this;
return retVal;
}
