/// <summary> /// Rule: AddExpr -> MultExpr ((PLUSMINUS) MultExpr )* ; /// </summary> protected override object EvalAddExpr(ParseTree tree, params object[] paramlist) { if (GetNode(TokenType.PLUSMINUS) == null) { return((ExpressionBase)GetNode(TokenType.MultExpr).Eval(tree)); } var expressions = new Stack <ExpressionBase>(nodes.OfTokenType(TokenType.MultExpr).Select(n => n.Eval(tree)).Cast <ExpressionBase>().Reverse()); var operations = new Stack <string>(nodes.OfTokenType(TokenType.PLUSMINUS).Select(x => x.Token.Text).Reverse()); while (expressions.Count > 1) { var leftExpr = expressions.Pop(); var rightExpr = expressions.Pop(); var newExpr = new AddExpr { First = leftExpr, Second = rightExpr, Node = this, OperationText = operations.Pop() }; expressions.Push(newExpr); } return(expressions.First()); }
public Expr Add(AddExpr multi) { Expr result = null; multi.Args.Accumulate(x => { result = x.Visit(this); }, x => { result = Builder.Add(result, x.Visit(this)); }); return result; }
static void Main(string[] args) { Console.WriteLine("1_______________________________________________________________________________"); // (3*x^2 + 7) / (x + 5) 82 / 10 = 8.2 Expression exp = new DivExpr( new AddExpr( MonomialExpr.createObject(3, 2), ConstExpr.createObject(7)), new AddExpr( MonomialExpr.createObject(1, 1), ConstExpr.createObject(5))); Console.WriteLine("f(x)=" + exp.ToString()); Console.WriteLine("f(5)=" + exp.Evaluate(5)); Console.WriteLine("f'(x)=" + exp.Derive().ToString()); Console.WriteLine("2_______________________________________________________________________________"); // (0 + 10) - 0 * (x^1 + 0) Expression exp5 = new AddExpr(MonomialExpr.createObject(0, 2), ConstExpr.createObject(10)); Expression exp6 = new SubExpr(exp5, new MulExpr(ConstExpr.createObject(0), new AddExpr(MonomialExpr.createObject(1, 1), ConstExpr.createObject(0)))); Console.WriteLine("f(x)=" + exp6.ToString()); Console.WriteLine("f(2)=" + exp6.Evaluate(2)); Console.WriteLine("f'(x)=" + exp6.Derive().ToString()); Console.WriteLine("3_______________________________________________________________________________"); //(((x^2 + 2) / (x + 1)) + 10) / (x^2 + 5) Expression exp3 = new DivExpr( new AddExpr( MonomialExpr.createObject(1, 2), ConstExpr.createObject(2)), new AddExpr( MonomialExpr.createObject(1, 1), ConstExpr.createObject(1))); Expression exp4 = new DivExpr( new AddExpr( exp3, ConstExpr.createObject(10)), new AddExpr( MonomialExpr.createObject(1, 2), ConstExpr.createObject(5))); Console.WriteLine("f(x)=" + exp4.ToString()); Console.WriteLine("f(1)=" + exp4.Evaluate(1)); Console.WriteLine("f'(x)=" + exp4.Derive().ToString()); }
public dynamic Visit(AddExpr expr) { var left = _codeGen.Local(Visit((dynamic)expr.First)) as Operand; var right = _codeGen.Local(Visit((dynamic)expr.Second)) as Operand; switch (expr.Type) { case AddType.Plus: return(left + right); case AddType.Minus: return(left - right); default: throw new ArgumentOutOfRangeException(); } }
public dynamic Visit(AddExpr expr) { if (expr.Types.Contains(SymbolType.Bool)) { throw new ParseException("Невозможно применить эту операцию к Bool", expr.Node); } if (expr.Types.Contains(SymbolType.String)) { if (expr.Type == AddType.Minus) { throw new ParseException("Вычитание строк не поддерживается", expr.Node); } return(SymbolType.String); } if (expr.Types.Contains(SymbolType.Double)) { return(SymbolType.Double); } return(SymbolType.Integer); }
public dynamic Visit(AddExpr expr) { var node = new TreeNode("Expression") { Tag = expr.Node }; if (expr.First != null) { node.Nodes.Add(Visit((dynamic)expr.First)); } if (expr.Second != null) { node.Nodes.Add(Visit((dynamic)expr.Second)); } if (expr.Third != null) { node.Nodes.Add(Visit((dynamic)expr.Third)); } node.Text = expr.Type.ToString(); return(node); }
public void Visit(AddExpr addExpr, object[] args) { addExpr.FirstOp.Accept(this); addExpr.SecondOp.Accept(this); RightValue v1 = readRightValue(addExpr.FirstOp); RightValue v2 = readRightValue(addExpr.SecondOp); if (v1 is StringConst || v2 is StringConst) { StringConst result = new StringConst(); result.Value = v1.ToString() + v2.ToString(); addExpr.RightValue = result; //addExpr.DataType = DataType.String; } else { DataType resultType = readAlgoOperand(v1, v2, addExpr.Location); if (resultType == DataType.Int) { IntConst result = new IntConst(); result.Value = Convert.ToInt32(v1.GetValueObject()) + Convert.ToInt32(v2.GetValueObject()); addExpr.RightValue = result; //addExpr.DataType = DataType.Int; } else if (resultType == DataType.Float) { FloatConst result = new FloatConst(); result.Value = Convert.ToDouble(v1.GetValueObject()) + Convert.ToDouble(v2.GetValueObject()); addExpr.RightValue = result; //addExpr.DataType = DataType.Float; } else { throw new Exception(); } } }
private Expr parseAddExpr() { Expr expr = parseMulExpr(); while (true) { int token = parseToken(); switch (token) { case '+': expr = new AddExpr(expr, parseMulExpr()); break; case '-': expr = new SubExpr(expr, parseMulExpr()); break; default: _peekToken = token; return(expr); } } }
public dynamic Visit(AddExpr expr) { Visit((ExpressionBase)expr); if (OptimizeMode.ExpressionSimplify) { var left = expr.First as LiteralExpr; var right = expr.Second as LiteralExpr; if (left != null && right != null) { var literal = new LiteralExpr { Namespace = expr.Namespace, Node = expr.Node, SymbolType = expr.GetExprType() }; dynamic result; switch (expr.Type) { case AddType.Plus: result = left.Value + right.Value; break; case AddType.Minus: result = left.Value - right.Value; break; default: throw new ArgumentOutOfRangeException(); } if (literal.SymbolType == SymbolType.Integer) { result = Convert.ToInt32(result); } literal.Value = result; return(literal); } } return(expr); }
public dynamic Visit(AddExpr expr) { Visit((ExpressionBase)expr); return(null); }
/// <summary> /// Validate an additon expression. /// </summary> /// <param name="addex"> /// is the expression. </param> /// <returns> null. </returns> public virtual object visit(AddExpr addex) { printBinExpr("ADD", addex); return(null); }
protected IType CheckExpr(AddExpr expr) { IType a = CheckExpr(expr.Expr1); IType b = CheckExpr(expr.Expr2); if (!(a is NumericType) || !a.CompatibleWith(b)) { AddError(String.Format("Addition not possible. Incompatible types: '{0}', '{1}'. Only numeric types are supported.", a.ToString(), b.ToString()), true, expr.SourcePosition); return NumericType.Instance; } return (a is RealType || b is RealType) ? (IType)RealType.Instance : (IType)IntType.Instance; }
/// <param name="ex"> /// is the add expression. </param> /// <returns> a new function. </returns> public virtual object visit(AddExpr ex) { ex.left().accept(this); ex.right().accept(this); return(null); }
public Number Add(AddExpr multi) { return EvaluateMulti(multi, (x1, x2) => x1 + x2); }
/// <param name="e"> /// is the plus expression. </param> /// <returns> new add expression </returns> public virtual object visit(PlusExpr e) { AddExpr ae = new AddExpr(make_int_lit(0), e.arg()); return(ae.accept(this)); }
/// <param name="addex"> /// is the add expression. </param> /// <returns> a new function. </returns> public virtual object visit(AddExpr addex) { return(make_ArithOp(addex, new QName("fs", "plus", OpFunctionLibrary.XPATH_OP_NS))); }