protected override string VisitCall(Call F) { // Special case for differentiate. if (F.Target.Name == "D" && F.Arguments.Count() == 2) return @"\frac{d}{d" + Visit(F.Arguments.ElementAt(1)) + "}[" + Visit(F.Arguments.ElementAt(0)) + "]"; return Escape(F.Target.Name) + @"(" + String.Join(", ", F.Arguments.Select(i => Visit(i))) + @")"; }
/// <summary> /// Substitute the variables into the expressions. /// </summary> /// <param name="x0"></param> /// <param name="IsTransform"></param> /// <returns></returns> public virtual Expression Substitute(Call C, IDictionary<Expression, Expression> x0, bool IsTransform) { return ComputerAlgebra.Call.New(C.Target, C.Arguments.Select(i => i.Substitute(x0, IsTransform))); }
protected override Expression VisitCall(Call C) { C = (Call)base.VisitCall(C); try { if (C.Target.CanCall(C.Arguments)) { Expression call = C.Target.Call(C.Arguments); if (!ReferenceEquals(call, null)) return call; } } catch (Exception Ex) { exceptions.Add(Ex); } return C; }
protected override Expression VisitCall(Call F) { return F.Target.Substitute(F, x0, transform); }
/// <summary> /// Substitute the variables into the expressions. /// </summary> /// <param name="x0"></param> /// <param name="IsTransform"></param> /// <returns></returns> public virtual Expression Substitute(Call C, IDictionary <Expression, Expression> x0, bool IsTransform) { return(ComputerAlgebra.Call.New(C.Target, C.Arguments.Select(i => i.Substitute(x0, IsTransform)))); }
protected override Expression VisitCall(Call F) { return(F.Target.Substitute(F, x0, transform)); }
private static Expression D(Expression f, Expression t) { return(Call.D(f, t)); }
//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 string VisitCall(Call F) { string s = F.Target.Name + "[" + Join(F.Arguments, ", ") + "]"; return(s); }
/// <summary> /// Integrate expression with respect to x. /// </summary> /// <param name="f"></param> /// <param name="x"></param> /// <returns></returns> public static Expression Integrate(this Expression f, Expression x) { return(Call.I(f, x)); }