public object VisitExpression2(Expression2 expression2, object o) { if (expression2.Operator2 == null) { return(expression2.Expression3.Visit(this, o)); } var lv2IntyOpr = new List <string>() { "+", "-" }; var t1 = (VariableType.ValueTypeEnum)expression2.Expression1.Visit(this, o); var t2 = (VariableType.ValueTypeEnum)expression2.Expression3.Visit(this, o); if (t1 == VariableType.ValueTypeEnum.NOTHING || t2 == VariableType.ValueTypeEnum.NOTHING) { throw new Exception("<Nothing> not a valid operand for " + expression2.Operator2.Spelling + " operator"); } if (t1 != t2) { throw new Exception("The operands for a Operator2 operator must be of same type"); } if (lv2IntyOpr.Contains(expression2.Operator2.Spelling)) { if (t1 == VariableType.ValueTypeEnum.INTY) { return(VariableType.ValueTypeEnum.INTY); } else { throw new Exception("Operator " + expression2.Operator2.Spelling + " expexted inty operands"); } } else if ("or".Equals(expression2.Operator2.Spelling)) { if (t1 == VariableType.ValueTypeEnum.BOOLY) { return(VariableType.ValueTypeEnum.BOOLY); } else { throw new Exception("Operator " + expression2.Operator2.Spelling + " expexted booly operands"); } } throw new Exception("Something bad happened, code: 98465+4865"); }
private Expression1 ParseExpression1() { Expression2 expression2 = ParseExpression2(); Operator1 operator1 = null; Expression1 expression1 = null; if (Token.TokenType.OPERATOR_1 == _currentToken.TheTokenType) { operator1 = new Operator1(Accept(Token.TokenType.OPERATOR_1)); expression1 = ParseExpression1(); } return(new Expression1(expression2, operator1, expression1)); }
public static void Print(Expression2 e, StringBuilder sb) { if (e is DoubleExpression2 de) { sb.Append(de.Value); } else if (e is AdditionExpression2 ae) { sb.Append("("); Print(ae.Left, sb); Print(ae.Right, sb); sb.Append(")"); } }
public Value Eval() { var value1 = Expression1.Eval(); var value2 = Expression2.Eval(); return(value1 switch { IntegerValue => Operation switch { Operations.Plus => new IntegerValue(value1.AsInteger() + value2.AsInteger()), Operations.Minus => new IntegerValue(value1.AsInteger() - value2.AsInteger()), Operations.Multiply => new IntegerValue(value1.AsInteger() * value2.AsInteger()), Operations.Divide => new IntegerValue(value1.AsInteger() / value2.AsInteger()), _ => throw new ArgumentOutOfRangeException() },
override public void Pretty(PrettyBuilder builder, int outerPrecedence, bool opposite) { var precedence = Precedences[Operator]; var associativity = Associativities[Operator]; if (outerPrecedence > precedence || opposite && outerPrecedence == precedence) { builder.Append("("); } Expression1.Pretty(builder, precedence, associativity == Associativity.Right); builder.Append(Strings[Operator]); Expression2.Pretty(builder, precedence, associativity == Associativity.Left); if (outerPrecedence > precedence || opposite && outerPrecedence == precedence) { builder.Append(")"); } }
// public Expression Expression1; // public Expression Expression2; override public void Pretty(PrettyBuilder builder, int outerPrecedence, bool opposite) { if (outerPrecedence > 0) { builder.Append("("); builder.Indent(); builder.NewLine(); } Expression1.Pretty(builder, 0, false); builder.Append(", "); builder.NewLine(); Expression2.Pretty(builder, 0, false); if (outerPrecedence > 0) { builder.Unindent(); builder.NewLine(); builder.Append(")"); builder.NewLine(); } }
public override Type Typecheck(TypecheckingState state) { var type1 = Expression1.Typecheck(state); var type2 = Expression2.Typecheck(state); OperandType = type1; switch (Operator) { case BinaryOperator.Add: if (type1 != Type.NumType && type2 != Type.NumType) { TypeError("+ expects number operands"); } return(Type.NumType); case BinaryOperator.Sub: if (type1 != Type.NumType && type2 != Type.NumType) { TypeError("- expects number operands"); } return(Type.NumType); case BinaryOperator.Eq: if (type1 != type2) { TypeError("== expects operands of the same type"); } return(Type.BoolType); case BinaryOperator.Lt: if (type1 != Type.NumType && type2 != Type.NumType) { TypeError("- expects number operands"); } return(Type.BoolType); } throw new ImpossibleException(); }
/// <summary> /// 验证结果 /// </summary> /// <param name="value">待验证值</param> /// <returns></returns> public override ValidateResult Validate(object value) { ValidateResult r = new ValidateResult(); r.Valid = false; r.ErrorTextKey = this.ErrorText; int v = 0; if (Expression == null || value == null || !int.TryParse(value.ToString(), out v)) { return(r); } if (Expression2 != null && Validator.IsInteger(Expression.ToString()) && Validator.IsInteger(Expression2.ToString())) { r.Valid = v >= int.Parse(Expression.ToString()) && v <= int.Parse(Expression2.ToString()); } if (Expression2 == null && Validator.IsDecimal(Expression.ToString())) { r.Valid = v == int.Parse(Expression.ToString()); } return(r); }
static void Test() { string[] stExp = new string[9] { "log(4-2, 8)", " - 2.0+3-1.6+ 8.3 ", " 2.0*3.5-4.2/3", "(2.0-3)*(5/(3+3)-4.2)", "4^3^0.5-2^(3^2-2*3)", "log(4-2, 8)+lg(123)", "log(log(10,100), 8) + 1.2", "sin((ln(2)-2)*log(3, 2*3^2))", "-min(sin(ln(2.5^1.5+2*0.3)-1.3), cos(0.8^log(2,5)), 0.7^(5/2)) + max(1.8, 2, -2, 2.3, log(5, 118))" }; double[] expectedResult = new double[9] { Math.Log(8, 4 - 2), -2.0 + 3 - 1.6 + 8.3, 2.0 * 3.5 - 4.2 / 3, (2.0 - 3) * (5.0 / (3 + 3) - 4.2), Math.Pow(Math.Pow(4, 3), 0.5) - Math.Pow(2, (Math.Pow(3, 2) - 2 * 3)), Math.Log(8, 4 - 2) + Math.Log10(123), Math.Log(8, Math.Log(100, 10)) + 1.2, Math.Sin((Math.Log(2.0) - 2) * Math.Log(2.0 * Math.Pow(3.0, 2), 3)), -Math.Min(Math.Min(Math.Sin(Math.Log(Math.Pow(2.5, 1.5) + 2.0 * 0.3) - 1.3), Math.Cos(Math.Pow(0.8, Math.Log(5, 2)))), Math.Pow(0.7, 5.0 / 2)) + Math.Max(2.3, Math.Log(118, 5)) }; Expression2 exp; for (int i = 0; i < stExp.Length; i++) { exp = new Expression2(stExp[i]); double actual = exp.Result(); Console.WriteLine("{0}\n{1}", stExp[i], exp); System.Console.WriteLine("{0}! Expected: {1}, Actual: {2}\n", Math.Abs(actual - expectedResult[i]) < 1e-10 ? "Correct" : "Wrong", expectedResult[i], actual); } }
// public Expression Expression1; // public Expression Expression2; public override void Compile(GeneratorState state, Trac42Program program) { Expression1.Compile(state, program); program.Emit(new Instruction(Instruction.OPCODE.POP, 1)); Expression2.Compile(state, program); }
internal override double Evaluate() { return(Math.Pow(Expression1.Evaluate(), Expression2.Evaluate())); }
/// <summary> /// Возвращает текст выражения /// </summary> public override string ToText( ) { return(string.Format("{0}{1}{2}{3}{4}", Expression1.ToText( ), Compiler.GetOperator(Name).Signatures[0], Expression2.ToText( ), Compiler.GetOperator(Name).Signatures[1], Expression3.ToText( ))); }
internal override double Evaluate() { return(Expression1.Evaluate() / Expression2.Evaluate()); }
public static void Print(Expression2 e, StringBuilder sb) { actions[e.GetType()](e, sb); }
public Expression1(Expression2 expression2, Operator1 operator1, Expression1 expression1) { Expression2 = expression2; Operator1 = operator1; Expression1_ = expression1; }
// public BinaryOperator Operator; // public Expression Expression1; // public Expression Expression2; public override Expression Lift(LiftEnvironment env) { Expression1 = Expression1.Lift(env); Expression2 = Expression2.Lift(env); return(this); }
// public Expression Expression1; // public Expression Expression2; public override void FreeVariables(HashSet <string> boundVariables, HashSet <string> freeVariables) { Expression1.FreeVariables(boundVariables, freeVariables); Expression2.FreeVariables(boundVariables, freeVariables); }
public Expression2 Left, Right; // need to be public public AdditionExpression2(Expression2 left, Expression2 right) { Left = left ?? throw new ArgumentNullException(paramName: nameof(left)); Right = right ?? throw new ArgumentNullException(paramName: nameof(right)); }
// public Expression Expression1; // public Expression Expression2; public override Type Typecheck(TypecheckingState state) { Expression1.Typecheck(state); return(Expression2.Typecheck(state)); }
public override decimal Solve() { return(Expression1.Solve() / Expression2.Solve()); }
///-------------------------------------------------------------------------------- /// <summary>Evaluate expression associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="interpreterType">The type of interpretation to perform.</param> ///-------------------------------------------------------------------------------- public string GetExpressionValue(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, InterpreterTypeCode interpreterType) { string expression1Value = String.Empty; if (Expression1 != null) { expression1Value = Expression1.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType); } string expression2Value = String.Empty; if (Expression2 != null) { expression2Value = Expression2.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType); } if (String.IsNullOrEmpty(expression1Value)) { expression1Value = "null"; } if (String.IsNullOrEmpty(expression2Value)) { expression2Value = "null"; } long expression1Long; long expression2Long; double expression1Double; double expression2Double; if (Literal != null) { return(Literal.RawValue); } if (ModelProperty != null) { return(ModelProperty.GetPropertyStringValue(solutionContext, templateContext, modelContext, modelContext, interpreterType)); } if (ModelContext != null) { bool isValidContext; IDomainEnterpriseObject nodeContext = ModelContext.GetModelContext(solutionContext, templateContext, modelContext, out isValidContext); if (nodeContext == null) { return("null"); } else { if (nodeContext.ID == Guid.Empty || nodeContext.ID == null) { return("null"); } return(nodeContext.ID.ToString()); } } else if (CurrentItem != null) { IDomainEnterpriseObject nodeContext = CurrentItem.GetModelContext(solutionContext, templateContext, modelContext); if (nodeContext == null) { return("null"); } else { return(nodeContext.ID.ToString()); } } else if (SpecCurrentItem != null) { IDomainEnterpriseObject nodeContext = SpecCurrentItem.GetModelContext(solutionContext, templateContext, modelContext); if (nodeContext == null) { return("null"); } else { return(nodeContext.ID.ToString()); } } else if (Expression1 != null && Expression2 != null) { if (BinaryOperator != null) { switch (BinaryOperator.Operator) { case "||": if (Expression1.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType) || Expression2.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType)) { return("true"); } return("false"); case "&&": if (Expression1.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType) && Expression2.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType)) { return("true"); } return("false"); case "==": if (expression1Value == expression2Value) { return("true"); } return("false"); case "!=": if (expression1Value != expression2Value) { return("true"); } return("false"); case "<": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long < expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double < expression2Double) { return("true"); } } else { if (expression1Value.Length < expression2Value.Length) { return("true"); } } return("false"); case ">": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long > expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double > expression2Double) { return("true"); } } else { if (expression1Value.Length > expression2Value.Length) { return("true"); } } return("false"); case "<=": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long <= expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double <= expression2Double) { return("true"); } } else { if (expression1Value.Length <= expression2Value.Length) { return("true"); } } return("false"); case ">=": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long >= expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double >= expression2Double) { return("true"); } } else { if (expression1Value.Length >= expression2Value.Length) { return("true"); } } return("false"); default: return("false"); } } else if (MathOperator != null) { switch (MathOperator.Operator) { case "+": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { return((expression1Long + expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { return((expression1Double + expression2Double).ToString()); } else { return(expression1Value + expression2Value); } case "-": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { return((expression1Long - expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { return((expression1Double - expression2Double).ToString()); } else { return(expression1Value.Replace(expression2Value, "")); } case "*": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { return((expression1Long * expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { return((expression1Double * expression2Double).ToString()); } break; case "/": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true && expression2Long != 0) { return((expression1Long / expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true && expression2Double != 0.00) { return((expression1Double / expression2Double).ToString()); } break; default: break; } return("null"); } } else if (Expression1 != null) { return(Expression1.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType)); } return("null"); }
// public BinaryOperator Operator; // public Expression Expression1; // public Expression Expression2; override public void Prepass(PrepassState state) { Expression1.Prepass(state); Expression2.Prepass(state); }