protected override string VisitProduct(Product P)
{
int pr = Parser.Precedence(Operator.Multiply);
int sign = 1;
StringBuilder s = new StringBuilder();
foreach (Expression i in P.Terms)
{
if (i.Equals(-1))
{
sign *= -1;
}
else
{
if (s.Length > 0)
{
s.Append('*');
}
s.Append(Visit(i, pr));
}
}
if (sign == -1)
{
return("-" + s.ToString());
}
else
{
return(s.ToString());
}
}
protected override string VisitProduct(Product M)
{
int pr = Parser.Precedence(Operator.Multiply);
Expression N = Product.Numerator(M);
string minus = "";
if (IsNegative(N))
{
minus = "-";
N = -N;
}
string n = String.Join(" ", Product.TermsOf(N).Select(i => Visit(i, pr)));
string d = String.Join(" ", Product.TermsOf(Product.Denominator(M)).Select(i => Visit(i, pr)));
if (d != "1")
{
return(minus + Frac(n, d));
}
else
{
return(minus + n);
}
}
protected override string VisitUnary(Unary U)
{
int pr = Parser.Precedence(U.Operator);
return(Unary.ToStringPrefix(U.Operator)
+ Visit(U.Operand, pr)
+ Unary.ToStringPostfix(U.Operator));
}
protected override string VisitBinary(Binary B)
{
int pr = Parser.Precedence(B.Operator);
return(Visit(B.Left, pr)
+ Binary.ToString(B.Operator)
+ Visit(B.Right, pr));
}
protected string Visit(Expression E, int Precedence)
{
string v = Visit(E);
if (Parser.Precedence(E) < Precedence)
{
v = "(" + v + ")";
}
return(v);
}
protected override string VisitSum(Sum A)
{
int pr = Parser.Precedence(Operator.Add);
StringBuilder s = new StringBuilder();
s.Append(Visit(A.Terms.First(), pr));
foreach (Expression i in A.Terms.Skip(1))
{
string si = Visit(i, pr);
if (si[0] != '-')
{
s.Append("+");
}
s.Append(si);
}
return(s.ToString());
}
protected override string VisitSum(Sum S)
{
int pr = Parser.Precedence(Operator.Add);
StringBuilder s = new StringBuilder();
s.Append(Visit(S.Terms.First()));
foreach (Expression i in S.Terms.Skip(1))
{
string si = Visit(i, pr);
string nsi = Visit(-i, pr);
if (si.Length < nsi.Length)
{
s.Append(" + " + si);
}
else
{
s.Append(" - " + nsi);
}
}
return(s.ToString());
}
private static int Precedence(Expression x)
{
if (x is Sum)
{
return(Parser.Precedence(Operator.Add));
}
else if (x is Product)
{
return(Parser.Precedence(Operator.Multiply));
}
else if (x is Binary)
{
return(Parser.Precedence(((Binary)x).Operator));
}
else if (x is Unary)
{
return(Parser.Precedence(((Unary)x).Operator));
}
else if (x is Atom)
{
return(100);
}
return(Parser.Precedence(Operator.Equal));
}
protected override string VisitPower(Power P)
{
int pr = Parser.Precedence(Operator.Power);
return(Visit(P.Left, pr) + "^{" + Visit(P.Right, pr) + "}");
}
protected override string VisitUnary(Unary U)
{
return(ToString(U.Operator) + Visit(U.Operand, Parser.Precedence(U.Operator)));
}