//P is // if next is a unary operator // const op := unary(next) // consume // q := prec( op ) // const t := Exp( q ) // return mkNode( op, t ) // else if next = "(" // consume // const t := Exp( 0 ) // expect ")" // return t // else if next is a v // const t := mkLeaf( next ) // consume // return t // else // error private Expression P() { Operator op = new Operator(); if (tokens.Tok == "+") { // Skip unary +. tokens.Consume(); return(P()); } else if (IsUnaryPreOperator(tokens.Tok, ref op)) { // Unary operator. tokens.Consume(); Expression t = Exp(Precedence(op)); return(Unary.New(op, t)); } else if (tokens.Tok == "(") { // Group. tokens.Consume(); Expression t = Exp(0); tokens.Expect(")"); return(t); } else if (tokens.Tok == "{") { // Set. tokens.Consume(); return(Set.New(L(",", "}"))); } else if (tokens.Tok == "[") { // Matrix. tokens.Consume(); List <List <Expression> > entries = new List <List <Expression> >(); while (tokens.Tok == "[") { tokens.Consume(); entries.Add(L(",", "]")); } tokens.Expect("]"); return(Matrix.New(entries)); } else { string tok = tokens.Consume(); decimal dec = 0; double dbl = 0.0; if (decimal.TryParse(tok, NumberStyles.Float, culture, out dec)) { return(Constant.New(dec)); } if (double.TryParse(tok, NumberStyles.Float, culture, out dbl)) { return(Constant.New(dbl)); } else if (tok == "True") { return(Constant.New(true)); } else if (tok == "False") { return(Constant.New(false)); } else if (tok == "\u221E" || tok == "oo") { return(Constant.New(Real.Infinity)); } else if (tokens.Tok == "[") { // Bracket function call. tokens.Consume(); List <Expression> args = L(",", "]"); return(Call.New(Resolve(tok, args), args)); } else if (tokens.Tok == "(") { // Paren function call. tokens.Consume(); List <Expression> args = L(",", ")"); return(Call.New(Resolve(tok, args), args)); } else { return(Resolve(tok)); } } }
protected override Expression VisitUnary(Unary U) { // Logic operators are mostly constant. if (U.IsLogicOp) return 0; return base.VisitUnary(U); }
protected override Expression VisitUnary(Unary U) { Expression O = Visit(U.Operand); Real? C = AsReal(O); switch (U.Operator) { case Operator.Not: if (IsTrue(C)) return Constant.New(false); else if (IsFalse(C)) return Constant.New(true); break; } return Unary.New(U.Operator, O); }
protected override int VisitUnary(Unary U) { return(Visit(U.Operand) + 1); }
protected virtual T VisitUnary(Unary U) { return(VisitUnknown(U)); }
protected override bool VisitUnary(Unary U) { return(Visit(U.Operand)); }
public static LazyExpression operator -(Expression L, Expression R) { return(new LazyExpression(Sum.New(L, Unary.Negate(R)))); }
public static LazyExpression operator !(Expression O) { return(new LazyExpression(Unary.Not(O))); }
protected override PrettyString VisitUnary(Unary U) { return(PrettyString.ConcatColumns(Unary.ToStringPrefix(U.Operator), Visit(U.Operand), Unary.ToStringPostfix(U.Operator))); }
public Expression Solve(Expression x) { return(Unary.Negate(Sum.New(this.Where(i => !i.Key.Equals(x)).Select(i => Product.New(i.Key, i.Value)))) / this[x]); }
protected override string VisitUnary(Unary U) { return(ToString(U.Operator) + Visit(U.Operand, Parser.Precedence(U.Operator))); }
protected override string VisitUnary(Unary U) { return ToString(U.Operator) + Visit(U.Operand, Parser.Precedence(U.Operator)); }
public static LazyExpression operator -(LazyExpression L, LazyExpression R) { return(new LazyExpression(Sum.New(L.value, Unary.Negate(R.value)))); }