/// <summary> /// Combines two types to create a new one /// </summary> /// <param name="right"></param> /// <returns></returns> public override Type CombineType(Type right, BinaryExpression.Operator Operator) { Type retVal = null; if (Operator == BinaryExpression.Operator.Mult) { if (FullName.CompareTo("Default.BaseTypes.Speed") == 0 && right.FullName.CompareTo("Default.BaseTypes.Time") == 0) { NameSpace nameSpace = EnclosingNameSpaceFinder.find(this); retVal = nameSpace.findTypeByName("Distance"); } } else { if (IsDouble()) { if (right == EFSSystem.DoubleType) { retVal = this; } } else { if (right == EFSSystem.IntegerType) { retVal = this; } } } return(retVal); }
/// <summary> /// Indicates that binary operation is valid for this type and the other type /// </summary> /// <param name="otherType"></param> /// <returns></returns> public override bool ValidBinaryOperation(BinaryExpression.Operator operation, Type otherType) { bool retVal = base.ValidBinaryOperation(operation, otherType); if (!retVal) { if (operation == BinaryExpression.Operator.Add || operation == BinaryExpression.Operator.Div || operation == BinaryExpression.Operator.Mult || operation == BinaryExpression.Operator.Sub) { // Allow implicit conversions IntegerType integerType = otherType as IntegerType; if (integerType != null) { retVal = true; } else { DoubleType doubleType = otherType as DoubleType; retVal = (doubleType != null); } } } return(retVal); }
/// <summary> /// Indicates that binary operation is valid for this type and the other type /// </summary> /// <param name="operation"></param> /// <param name="otherType"></param> /// <returns></returns> public override bool ValidBinaryOperation(BinaryExpression.Operator operation, Type otherType) { bool retVal; if (operation == BinaryExpression.Operator.Less || operation == BinaryExpression.Operator.LessOrEqual || operation == BinaryExpression.Operator.Greater || operation == BinaryExpression.Operator.GreaterOrEqual) { retVal = false; } else { retVal = base.ValidBinaryOperation(operation, otherType); } return(retVal); }
/// <summary> /// Combines two types to create a new one /// </summary> /// <param name="right"></param> /// <returns></returns> public override Type CombineType(Type right, BinaryExpression.Operator Operator) { Type retVal = null; if (Operator == BinaryExpression.Operator.Mult) { Range range = right as Range; if (range != null) { if (range.getPrecision() == acceptor.PrecisionEnum.aIntegerPrecision) { retVal = this; } } } 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 IValue PerformArithmericOperation(InterpretationContext context, IValue left, BinaryExpression.Operator operation, IValue right) // left +/-/*/div/exp right { DoubleValue retVal = null; double double1 = getValue(left); double double2 = getValue(right); switch (operation) { case BinaryExpression.Operator.Exp: retVal = new DoubleValue(this, Math.Pow(double1, double2)); break; case BinaryExpression.Operator.Mult: retVal = new DoubleValue(this, (double1 * double2)); break; case BinaryExpression.Operator.Div: if (double2 == 0) { throw new Exception("Division by zero"); } else { retVal = new DoubleValue(this, (double1 / double2)); } break; case BinaryExpression.Operator.Add: retVal = new DoubleValue(this, (double1 + double2)); break; case BinaryExpression.Operator.Sub: retVal = new DoubleValue(this, (double1 - double2)); break; } 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 IValue PerformArithmericOperation(InterpretationContext context, IValue left, BinaryExpression.Operator operation, IValue right) // left +/-/*/div/exp right { IntValue retVal = null; int int1 = getValue(left); int int2 = getValue(right); switch (operation) { case BinaryExpression.Operator.Exp: retVal = new IntValue(EFSSystem.IntegerType, (Decimal)Math.Pow((double)int1, (double)int2)); break; case BinaryExpression.Operator.Mult: retVal = new IntValue(EFSSystem.IntegerType, (int1 * int2)); break; case BinaryExpression.Operator.Div: if (int2 == 0) { throw new Exception("Division by zero"); } else { retVal = new IntValue(EFSSystem.IntegerType, (int1 / int2)); } break; case BinaryExpression.Operator.Add: retVal = new IntValue(EFSSystem.IntegerType, (int1 + int2)); break; case BinaryExpression.Operator.Sub: retVal = new IntValue(EFSSystem.IntegerType, (int1 - int2)); break; } 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 IValue PerformArithmericOperation(InterpretationContext context, IValue left, BinaryExpression.Operator operation, IValue right) // left +/-/*/div/exp right { IValue retVal = null; left = derefEnumForArithmeticOperation(left); right = derefEnumForArithmeticOperation(right); IntValue int1 = left as IntValue; IntValue int2 = right as 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> /// Indicates that binary operation is valid for this type and the other type /// </summary> /// <param name="otherType"></param> /// <returns></returns> public virtual bool ValidBinaryOperation(BinaryExpression.Operator operation, Type otherType) { bool retVal; if (operation == BinaryExpression.Operator.In || operation == BinaryExpression.Operator.NotIn) { Collection collectionType = otherType as Collection; if (collectionType != null) { retVal = Match(collectionType.Type); } else { retVal = Match(otherType); } } else { retVal = Match(otherType); } return(retVal); }
/// <summary> /// Combines two types to create a new one /// </summary> /// <param name="right"></param> /// <returns></returns> public virtual Type CombineType(Type right, BinaryExpression.Operator Operator) { return(null); }
/// <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 virtual IValue PerformArithmericOperation(InterpretationContext context, IValue left, BinaryExpression.Operator operation, IValue right) // left +/-/*/div/exp right { IValue retVal = null; Function leftFunction = left as Function; Function rigthFunction = right as Function; if (leftFunction != null) { if (rigthFunction == null) { if (leftFunction.Graph != null) { Graph graph = Graph.createGraph(Function.GetDoubleValue(right)); rigthFunction = graph.Function; } else { Surface surface = Surface.createSurface(Function.GetDoubleValue(right), leftFunction.Surface.XParameter, leftFunction.Surface.YParameter); rigthFunction = surface.Function; } } if (leftFunction.Graph != null) { IGraph tmp = null; switch (operation) { case BinaryExpression.Operator.Add: tmp = leftFunction.Graph.AddGraph(rigthFunction.Graph); break; case BinaryExpression.Operator.Sub: tmp = leftFunction.Graph.SubstractGraph(rigthFunction.Graph); break; case BinaryExpression.Operator.Mult: tmp = leftFunction.Graph.MultGraph(rigthFunction.Graph); break; case BinaryExpression.Operator.Div: tmp = leftFunction.Graph.DivGraph(rigthFunction.Graph); break; } Graph tmpGraph = tmp as Graph; if (tmpGraph != null) { retVal = tmpGraph.Function; } } else { Surface rightSurface = rigthFunction.GetSurface(leftFunction.Surface.XParameter, leftFunction.Surface.YParameter); Surface tmp = null; switch (operation) { case BinaryExpression.Operator.Add: tmp = leftFunction.Surface.AddSurface(rightSurface); break; case BinaryExpression.Operator.Sub: tmp = leftFunction.Surface.SubstractSurface(rightSurface); break; case BinaryExpression.Operator.Mult: tmp = leftFunction.Surface.MultiplySurface(rightSurface); break; case BinaryExpression.Operator.Div: tmp = leftFunction.Surface.DivideSurface(rightSurface); break; } retVal = tmp.Function; } } return(retVal); }
public override IValue PerformArithmericOperation(InterpretationContext context, IValue left, BinaryExpression.Operator operation, IValue right) { throw new Exception("Cannot perform arithmetic operation between " + left.LiteralName + " and " + right.LiteralName); }
public override IValue PerformArithmericOperation(InterpretationContext context, IValue left, BinaryExpression.Operator operation, IValue right) { ListValue retVal = null; switch (operation) { case BinaryExpression.Operator.Add: Collection leftType = left.Type as Collection; Collection rightType = right.Type as Collection; Collection returnType; if (leftType != null && rightType != null) { if (leftType is GenericCollection) { if (rightType is GenericCollection) { returnType = new GenericCollection(EFSSystem); } else { returnType = rightType; } } else { if (leftType == rightType) { returnType = leftType; } else if (leftType.Type == rightType.Type) { returnType = leftType; } else { throw new Exception("Cannot determine the collection type for expression"); } } ListValue leftValue = left as ListValue; ListValue rightValue = right as ListValue; if (leftValue != null && rightValue != null) { retVal = new ListValue(returnType, new List <IValue>()); foreach (IValue val in leftValue.Val) { if (!(val is EmptyValue)) { retVal.Val.Add(val.RightSide(null, true, true)); } } foreach (IValue val in rightValue.Val) { if (!(val is EmptyValue)) { retVal.Val.Add(val.RightSide(null, true, true)); } } } else { throw new Exception("Cannot add a collection to a single element"); } } break; } return(retVal); }