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); }