public static RPN.Node AdditionSwap(RPN.Node node)
{
node[1, 1].Replace(1);
node.Swap(0, 1);
node.Replace(new RPN.Token("-", 2, RPN.Type.Operator));
return(node);
}
public static RPN.Node ComplexNodeAddition(RPN.Node node)
{
node[0].Replace(node[0, 1], new RPN.Node(0));
RPN.Node multiplication = new RPN.Node(new[] { node[1], new RPN.Node(2) },
new RPN.Token("*", 2, RPN.Type.Operator));
return(node);
}
public static RPN.Node ConstantComplex(RPN.Node node)
{
RPN.Node subtraction = new RPN.Node(new RPN.Node[] { node[1], node[0] }, new RPN.Token("-", 2, RPN.Type.Operator));
RPN.Node addition = new RPN.Node(new RPN.Node[] { subtraction, new RPN.Node(1) }, new RPN.Token("+", 2, RPN.Type.Operator));
RPN.Node multiplication = new RPN.Node(new RPN.Node[] { node[3], addition }, new RPN.Token("*", 2, RPN.Type.Operator));
return(multiplication);
}
public static RPN.Node increaseExponentTwo(RPN.Node node)
{
RPN.Node temp = node.Children[0].Children[0];
temp.Replace(temp.GetNumber() + 1);
node.Children[1].Children[0].Remove(new RPN.Node(1));
return(node);
}
public static RPN.Node increaseExponent(RPN.Node node)
{
node.Replace(node[0], new RPN.Node(1));
node.Replace(node[1, 0],
new RPN.Node(node[1, 0].GetNumber() + 1));
return(node);
}
public static RPN.Node PowerReduction(RPN.Node node)
{
int reduction = System.Math.Min((int)node[0, 0].GetNumber(), (int)node[1, 0].GetNumber()) - 1;
node[0, 0].Replace(node[0, 0].GetNumber() - reduction);
node[1, 0].Replace(node[1, 0].GetNumber() - reduction);
return(node);
}
public static bool PowerRunnable(RPN.Node node)
{
return((node[1].IsInteger(1) || node[1].IsNumber(0)) && //start point must be 0 or 1 since 0^(c) = 0 when c > 0.
node[3].IsExponent() &&
node[3, 0].IsInteger() &&
node[3, 0].IsGreaterThanNumber(0) && //ensures power is positive
node[3, 1].Matches(node[2]));
}
//This is what we want our end result to look like
/**
* AST Simplified Infix : {a-f,b-f,c-f,d-f}
* list [13 | 4 | Function | True | 7c563ab9893e876c49fcc316a78e6b6d]
* ├─- [12 | 2 | Operator | False | 281861c9d3dfdecb3ddffdc8930cb63e]
* │ ├─f [11 | 0 | Variable | False | 8fa14cdd754f91cc6554c9e71929cce7]
* │ └─d [10 | 0 | Variable | False | 8277e0910d750195b448797616e091ad]
* ├─- [9 | 2 | Operator | False | 4ad3c11a7d979f70332d8dbc8ab33f43]
* │ ├─f [8 | 0 | Variable | False | 8fa14cdd754f91cc6554c9e71929cce7]
* │ └─c [7 | 0 | Variable | False | 4a8a08f09d37b73795649038408b5f33]
* ├─- [6 | 2 | Operator | False | df41b29ce151a927ae80c6df545518c1]
* │ ├─f [5 | 0 | Variable | False | 8fa14cdd754f91cc6554c9e71929cce7]
* │ └─b [4 | 0 | Variable | False | 92eb5ffee6ae2fec3ad71c777531578f]
* └─- [3 | 2 | Operator | False | d5c11d5ccf6dc77d16eaf012db8813fa]
* ├─f [2 | 0 | Variable | False | 8fa14cdd754f91cc6554c9e71929cce7]
* └─a [1 | 0 | Variable | False | 0cc175b9c0f1b6a831c399e269772661]
*/
public static RPN.Node VectorFrontScalarBack(RPN.Node node)
{
RPN.Token operatorToken = node.Token;
return(node);
}
public static RPN.Node CoefficientReduction(RPN.Node node)
{
double coefficient = node[1, 1].GetNumber() - node[0, 1].GetNumber();
node[0].Replace(node[0, 1], new RPN.Node(0));
node[1].Replace(node[1, 1], new RPN.Node(coefficient));
return(node);
}
public static RPN.Node TanUnderToCot(RPN.Node node)
{
RPN.Node cot = new RPN.Node(new[] { node.Children[0].Children[0] },
new RPN.Token("cot", 1, RPN.Type.Function));
RPN.Node multiplication = new RPN.Node(new[] { cot, node.Children[1] },
new RPN.Token("*", 2, RPN.Type.Operator));
return(node);
}
public static bool FunctionToAdditionRunnable(RPN.Node node)
{
//(cos(x)^2)-(-1*(sin(x)^2))
//(cos(x)^2)-(-2*(sin(x)^2))
//((-2*(cos(x)^2))+(2*(sin(x)^2)))
return(!(node[0].IsMultiplication() && node[1].IsMultiplication()) && node[0].IsMultiplication() &&
node[0, 1].IsLessThanNumber(0));
}
public static RPN.Node dualNodeMultiplication(RPN.Node node)
{
double num1 = node[0, 1].GetNumber();
double num2 = node[1].GetNumber();
node[0].Replace(node[0, 1], new RPN.Node(1));
node.Replace(node[1], new RPN.Node(num1 * num2));
return(node);
}
public static RPN.Node ComplexCoefficient(RPN.Node node)
{
double sum = (node.Children[0].Children[1].GetNumber() +
node.Children[1].Children[1].GetNumber());
node.Children[1].Replace(node.Children[1].Children[1], new RPN.Node(sum));
node[0].Remove(new RPN.Node(0));
return(node);
}
public static RPN.Node LogExponentExpansion(RPN.Node node)
{
RPN.Node exponent = node.Children[0];
RPN.Node baseNode = exponent.Children[1];
RPN.Node power = exponent.Children[0];
RPN.Node log = new RPN.Node(new[] { baseNode.Clone(), node.Children[1] }, new RPN.Token("log", 2, RPN.Type.Function));
return(new Mul(power, log));
}
public static RPN.Node ZeroAddition(RPN.Node node)
{
if (node[0].IsNumber(0))
{
return(node[1]);
}
return(node[0]);
}
public static RPN.Node GCD(RPN.Node node)
{
double num1 = node.Children[0].GetNumber();
double num2 = node.Children[1].GetNumber();
double gcd = RPN.DoFunctions.Gcd(new double[] { num1, num2 });
node.Replace(node.Children[0], new RPN.Node((num1 / gcd)));
node.Replace(node.Children[1], new RPN.Node((num2 / gcd)));
return(node);
}
public static RPN.Node divisionTimesDivision(RPN.Node node)
{
RPN.Node top = new Mul(node[1, 1], node[0, 1]);
RPN.Node bottom = new Mul(node[1, 0], node[0, 0]);
RPN.Node division = new Div(top, bottom);
node.Children[0].Remove(division);
node.Children[1].Remove(new RPN.Node(1));
return(node);
}
public static bool increaseExponentRunnable(RPN.Node node)
{
/* *
* | f(x)
* | ^
* |
* | > Number
* | > f(x)
*/
return(node[1].IsExponent() && node[1, 0].IsNumber() && node[0].Matches(node[1, 1]));
}
public static bool TrigIdentitySinPlusCosRunnable(RPN.Node node)
{
return(node.IsAddition() &&
node[0].IsExponent() &&
node[1].IsExponent() &&
node[0, 0].IsNumber(2) &&
node[1, 0].IsNumber(2) &&
(node[0, 1].IsFunction("cos") || node[0, 1].IsFunction("sin")) &&
(node[1, 1].IsFunction("sin") || node[1, 1].IsFunction("cos")) &&
!node.ChildrenAreIdentical() &&
!node.ContainsDomainViolation() &&
node[0, 1, 0].Matches(node[1, 1, 0]));
}
public static bool increaseExponentTwoRunnable(RPN.Node node)
{
/**
* *
* | ^
* | c > 0
* | f(x)
* | *
* f(x)
*/
return(node[0].IsExponent() && node[1].IsMultiplication() &&
node[0, 0].IsGreaterThanNumber(0) && node[1, 0].Matches(node[0, 1]));
}
public static bool increaseExponentThreeRunnable(RPN.Node node)
{
/**
* *
* | > ^
* | ?
* | f(x)
* | > *
* ?
* f
*/
return(node[0].IsExponent() && node[1].IsMultiplication() &&
node[0, 1].Matches(node[1]));
}
public static RPN.Node ExponentToExponent(RPN.Node node)
{
RPN.Node multiply;
if (node[0].IsNumber() && node[1, 0].IsNumber())
{
multiply = new RPN.Node(node[0].GetNumber() * node[1, 0].GetNumber());
}
else
{
multiply = new Mul(node[1, 0], node[0]);
}
return(new Pow(node[1, 1], multiply));
}
public static RPN.Node expressionTimesDivision(RPN.Node node)
{
RPN.Node division;
RPN.Node expression;
if (node.Children[0].IsDivision())
{
division = node.Children[0];
expression = node.Children[1];
}
else
{
division = node.Children[1];
expression = node.Children[0];
}
RPN.Node numerator = division.Children[1];
RPN.Node multiply = new Mul(expression.Clone(), numerator.Clone());
numerator.Remove(multiply);
expression.Remove(new RPN.Node(1));
return(node);
}
public static RPN.Node Power(RPN.Node node)
{
RPN.Node power = node[3, 0].Clone();
RPN.Node end = node[0].Clone();
RPN.Token _fac = new RPN.Token("!", 1, RPN.Type.Operator);
RPN.Token _total = new RPN.Token("total", (int)power.GetNumber(), RPN.Type.Function);
RPN.Node total = new RPN.Node(_total);
double max = power.GetNumber();
RPN.Node numeratorAddition = new RPN.Node(power.GetNumber() + 1); //(p + 1)
for (int i = 0; i <= max; i++)
{
RPN.Node j = new RPN.Node(i);
RPN.Node subtraction = new RPN.Node(power.GetNumber() - j.GetNumber()); //(p - j)
RPN.Node addition = new RPN.Node(subtraction.GetNumber() + 1); //(p - j + 1)
RPN.Node exponent = new Pow(end.Clone(), addition.Clone()); //n^(p - j + 1)
RPN.Node bernoulli = Sum.getBernoulliNumber(i); //B(j)
RPN.Node numerator = new RPN.Node(new RPN.Node[] { numeratorAddition.Clone() }, _fac); //(p + 1)!
RPN.Node denominatorFactorial = new RPN.Node(new RPN.Node[] { addition.Clone() }, _fac); //(p - j + 1)!
RPN.Node jFactorial = new RPN.Node(new RPN.Node[] { j.Clone() }, _fac); //j!
RPN.Node denominator = new Mul(jFactorial, denominatorFactorial); // j! * (p - j + 1)!
RPN.Node fraction = new Div(numerator, denominator);
RPN.Node negativeOneExponent = new Pow(new RPN.Node(-1), j.Clone()); //(-1)^j
RPN.Node multiplication = new Mul(new Mul(negativeOneExponent, fraction), new Mul(bernoulli, exponent));
total.AddChild(multiplication);
}
return(new Div(total, numeratorAddition.Clone()));
}
public static bool setRule(RPN.Node node)
{
return(node.IsMultiplication());
}
public static RPN.Node multiplicationByZero(RPN.Node node)
{
return(new RPN.Node(0));
}
public static bool multiplicationByZeroRunnable(RPN.Node node)
{
return((node[1].IsNumber(0) || node[0].IsNumber(0)) && !node.ContainsDomainViolation());
}
public static RPN.Node multiplicationByOne(RPN.Node node)
{
return(node.Children[1].IsNumber(1) ? node[0] : node[1]);
}
public static bool multiplicationByOneRunnable(RPN.Node node)
{
return(node.Children[0].IsNumber(1) || node.Children[1].IsNumber(1));
}
public static RPN.Node negativeOneDistributed(RPN.Node node)
{
node[0].Swap(0, 1);
node[1].Replace(1);
return(node);
}
