/// <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);
        }
Beispiel #3
0
        /// <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);
        }
Beispiel #4
0
        /// <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);
        }
Beispiel #6
0
        /// <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);
        }
Beispiel #8
0
        /// <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);
        }
Beispiel #9
0
        /// <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);
        }
Beispiel #14
0
        /// <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);
        }
Beispiel #15
0
        /// <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);
        }
Beispiel #16
0
        /// <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);
        }