public override Node GetDerivative() //O = original, D = derivative { Node node1O1 = node1.Clone(); Node node1D = node1.GetDerivative(); Node node2O1 = node2.Clone(); Node nodeTimes1 = new NodeTimes(); Node nodeTimes2 = new NodeTimes(); if (node2.ContainsX()) { Node thisNode = this.Clone(); Node node1O2 = node1.Clone(); Node node2D = node2.GetDerivative(); Node nodePlus = new NodePlus(); Node nodeLN = new NodeLN(); Node nodeDiv = new NodeDivision(); Node nodeTimes3 = new NodeTimes(); nodeTimes3.AddNode1(thisNode); nodeTimes3.AddNode2(nodePlus); nodePlus.AddNode1(nodeTimes1); nodePlus.AddNode2(nodeTimes2); nodeTimes1.AddNode1(node1D); nodeTimes1.AddNode2(nodeDiv); nodeDiv.AddNode1(node2O1); nodeDiv.AddNode2(node1O1); nodeTimes2.AddNode1(node2D); nodeTimes2.AddNode2(nodeLN); nodeLN.AddNode1(node1O2); return(nodeTimes3); } else { Node node2O2 = node2.Clone(); Node nodeNumberOne = new NodeNumber(false, false, 1); Node nodeMin = new NodeMinus(); Node nodePow = new NodePower(); nodeTimes2.AddNode1(nodePow); nodeTimes2.AddNode2(nodeTimes1); nodeTimes1.AddNode1(node2O1); nodeTimes1.AddNode2(node1D); nodePow.AddNode1(node1O1); nodePow.AddNode2(nodeMin); nodeMin.AddNode1(node2O2); nodeMin.AddNode2(nodeNumberOne); return(nodeTimes2); } }
private Node getMaclaurinSerieRecursiveAccurate(int counter, int order, Node curNode) { Node nodeTim = new NodeTimes(); Node nodeDiv = new NodeDivision(); Node nodeFac = new NodeFactorial(); Node nodePow = new NodePower(); double zeroValue = curNode.GetValueForX(0); nodeTim.AddNode1(nodeDiv); nodeTim.AddNode2(nodePow); nodeDiv.AddNode1(new NodeNumber(false, false, zeroValue)); nodeDiv.AddNode2(nodeFac); nodeFac.AddNode1(new NodeNumber(false, false, counter - 1)); nodePow.AddNode1(new NodeNumber(true, false, 1)); nodePow.AddNode2(new NodeNumber(false, false, counter - 1)); if (counter == order) { return(nodeTim); } else if (counter < order && counter > 0) { Node nodePlus = new NodePlus(); nodePlus.AddNode1(nodeTim); curNode = curNode.GetDerivative(); Node receivedReplacementNode; curNode = curNode.MakeNodeClean(null, out receivedReplacementNode); nodePlus.AddNode2(getMaclaurinSerieRecursiveAccurate(counter + 1, order, curNode)); return(nodePlus); } else { throw new Exception("Error while making Maclaurin serie: counter problem: " + counter); } }
public override Node GetDerivative() //O = original, D = derivative { Node nodeDiv = new NodeDivision(); Node nodeTimes1 = new NodeTimes(); Node nodeTimes2 = new NodeTimes(); Node nodeMin = new NodeMinus(); Node nodePow = new NodePower(); Node nodeNumber2 = new NodeNumber(false, false, 2); Node node1D = node1.GetDerivative(); Node node2D = Node2.GetDerivative(); Node node1O = node1.Clone(); Node node2O = node2.Clone(); Node node2O2 = node2.Clone(); //divison (head node) nodeDiv.AddNode1(nodeMin); nodeDiv.AddNode2(nodePow); //creating upper part of division nodeMin.AddNode1(nodeTimes1); nodeMin.AddNode2(nodeTimes2); nodeTimes1.AddNode1(node1D); nodeTimes1.AddNode2(node2O); nodeTimes2.AddNode1(node1O); nodeTimes2.AddNode2(node2D); //creating lower part of division nodePow.AddNode1(node2O2); nodePow.AddNode2(nodeNumber2); return(nodeDiv); }
private Node combineNodes(Node cleanNode1, Node cleanNode2) { if (cleanNode1 is NodeNumber && !(cleanNode2 is NodeNumber)) { if (((NodeNumber)cleanNode1).Number == 0) { return(cleanNode2); } } if (cleanNode2 is NodeNumber && !(cleanNode1 is NodeNumber)) { if (((NodeNumber)cleanNode2).Number == 0) { return(cleanNode1); } } if (cleanNode1 is NodeNumber && cleanNode2 is NodeNumber) { if (((NodeNumber)cleanNode1).Number == 0) { Node newNumberNode; newNumberNode = new NodeNumber(cleanNode2.ContainsX(), cleanNode2.ContainsP(), ((NodeNumber)cleanNode2).Number); return(newNumberNode); } else if (((NodeNumber)cleanNode2).Number == 0) { Node newNumberNode; newNumberNode = new NodeNumber(cleanNode1.ContainsX(), cleanNode1.ContainsP(), ((NodeNumber)cleanNode1).Number); return(newNumberNode); } else if (cleanNode1.ContainsX() == cleanNode2.ContainsX()) { if (cleanNode1.ContainsP() == cleanNode2.ContainsP()) { Node newNumberNode; newNumberNode = new NodeNumber(cleanNode1.ContainsX(), cleanNode1.ContainsP(), ((NodeNumber)cleanNode1).Number + ((NodeNumber)cleanNode2).Number); return(newNumberNode); } } } //none of the nodes are numbers, so they need to be cleaned! Node trash; if (cleanNode1 is NodeLN && cleanNode2 is NodeLN) { Node nodeln = new NodeLN(); Node nodeTim = new NodeTimes(); nodeTim.AddNode1(cleanNode1.Node1); nodeTim.AddNode2(cleanNode2.Node1); nodeln.AddNode1(nodeTim); nodeln.MakeNodeClean(null, out trash); return(nodeln); } return(null); }
public override Node Clone() { Node newNode = new NodeTimes(); Node newNode1 = node1.Clone(); Node newNode2 = node2.Clone(); newNode.AddNode1(newNode1); newNode.AddNode2(newNode2); return(newNode); }
public override Node GetDerivative() //O = original, D = derivative { Node node1O = node1.Clone(); Node node1D = node1.GetDerivative(); Node nodeE = new NodeE(); Node nodeTimes = new NodeTimes(); nodeTimes.AddNode1(nodeE); nodeTimes.AddNode2(node1D); nodeE.AddNode1(node1O); return(nodeTimes); }
public override Node GetDerivative() //O = original, D = derivative { Node node1O = node1.Clone(); Node node1D = node1.GetDerivative(); Node cosnode = new NodeCos(); Node timesnode = new NodeTimes(); timesnode.AddNode1(cosnode); timesnode.AddNode2(node1D); cosnode.AddNode1(node1O); return(timesnode); }
public override Node GetDerivative() //O = original, D = derivative { Node negativenode = new NodeNumber(false, false, -1); Node node1O = node1.Clone(); Node node1D = node1.GetDerivative(); Node sinnode = new NodeSin(); Node timesnode = new NodeTimes(); Node timesnode2 = new NodeTimes(); timesnode2.AddNode1(negativenode); timesnode2.AddNode2(timesnode); timesnode.AddNode1(sinnode); timesnode.AddNode2(node1D); sinnode.AddNode1(node1O); return(timesnode2); }
public override Node MakeNodeClean(Node prevNodeNumber, out Node replacementNode) { Node garbage; if (node1 is NodeLN && node2 is NodeLN) //exception { Node nodeDiv = new NodeDivision(); Node nodeln = new NodeLN(); nodeln.AddNode1(nodeDiv); nodeDiv.AddNode1(Node1.Node1); nodeDiv.AddNode2(node2.Node1); nodeln.MakeNodeClean(null, out garbage); replacementNode = null; return(nodeln); } else { Node nodePlus = new NodePlus(); nodePlus.AddNode1(node1); if (node2 is NodeNumber) { ((NodeNumber)node2).SwapPositivity(); nodePlus.AddNode2(node2); } else if (node2 is NodeMinus) { Node newNode2 = node2.MakeNodeClean(null, out garbage); //node2 is now nodeplus ((NodePlus)newNode2).SwapPositivity(); nodePlus.AddNode2(newNode2); } else { Node nodeTimes = new NodeTimes(); Node nodeNumber = new NodeNumber(false, false, -1); nodeTimes.AddNode1(nodeNumber); nodeTimes.AddNode2(node2); nodePlus.AddNode2(nodeTimes); } replacementNode = null; nodePlus.MakeNodeClean(null, out garbage); return(nodePlus); } }
public void SwapPositivity() { if (node1 is NodeNumber) { ((NodeNumber)node1).SwapPositivity(); } else if (node1 is NodeMinus) { ((NodeMinus)node1).SwapPositivity(); } else if (node1 is NodePlus) { ((NodePlus)node1).SwapPositivity(); } else { Node nodeTimes = new NodeTimes(); Node nodeNumber = new NodeNumber(false, false, -1); nodeTimes.AddNode1(nodeNumber); nodeTimes.AddNode2(node1); this.AddNode1(nodeTimes); } if (node2 is NodeNumber) { ((NodeNumber)node2).SwapPositivity(); } else if (node2 is NodeMinus) { ((NodeMinus)node2).SwapPositivity(); } else if (node2 is NodePlus) { ((NodePlus)node2).SwapPositivity(); } else { Node nodeTimes = new NodeTimes(); Node nodeNumber = new NodeNumber(false, false, -1); nodeTimes.AddNode1(nodeNumber); nodeTimes.AddNode2(node2); this.AddNode2(nodeTimes); } }
public override Node GetDerivative() //O = original, D = derivative { Node nodePlus = new NodePlus(); Node nodeTimes1 = new NodeTimes(); Node nodeTimes2 = new NodeTimes(); Node node1O = node1.Clone(); Node node1D = node1.GetDerivative(); Node node2O = node2.Clone(); Node node2D = node2.GetDerivative(); nodePlus.AddNode1(nodeTimes1); nodePlus.AddNode2(nodeTimes2); nodeTimes1.AddNode1(node1D); nodeTimes1.AddNode2(node2O); nodeTimes2.AddNode1(node2D); nodeTimes2.AddNode2(node1O); return(nodePlus); }
private Node GetPolyNode(List <double> polyPoints) { //create polyfunction nodes List <NodePolyFunction> polyFunctions = new List <NodePolyFunction>(); int totalPoints = polyPoints.Count / 2; int nOrder = totalPoints - 1; for (int i = 0; i < polyPoints.Count; i += 2) //each point { double ans = polyPoints[i + 1]; List <double> xValues = new List <double>(); for (int j = nOrder; j >= 0; j--) //each x value { double x = polyPoints[i]; if (x == 0) { x = 0.000000001; } xValues.Add(Math.Pow(x, j)); } NodePolyFunction newNode = new NodePolyFunction(xValues, ans); polyFunctions.Add(newNode); } //transform polyfunctions into ideal functions (1a + 0 + 0 = ?, 0 + 1b + 0 = ? etc.) for (int i = 0; i < polyFunctions.Count; i++) //make current x value equal to 1 of this function { double divNumber; divNumber = polyFunctions[i].xValues[i]; polyFunctions[i].divideBy(divNumber); for (int j = 0; j < polyFunctions.Count; j++)//make current x value equal to 0 of other functions { if (j != i) { double timesNumber; timesNumber = polyFunctions[j].xValues[i]; polyFunctions[j].minusBy(timesNumber, polyFunctions[i]); } } } //make the return node out of the ideal (poly) functions Node headNode = new NodePlus(); Node tempNode = headNode; for (int i = 0; i < polyFunctions.Count(); i++) { Node nodePow = new NodePower(); Node nodeTim = new NodeTimes(); Node nodeNum = new NodeNumber(false, false, polyFunctions[i].answer); Node nodeNumLow = new NodeNumber(true, false, 1); Node nodeNumUp = new NodeNumber(false, false, nOrder - i); nodeTim.AddNode1(nodeNum); nodeTim.AddNode2(nodePow); nodePow.AddNode1(nodeNumLow); nodePow.AddNode2(nodeNumUp); if (i <= polyFunctions.Count - 3) //normal { tempNode.AddNode1(nodeTim); Node nodePlus = new NodePlus(); tempNode.AddNode2(nodePlus); tempNode = nodePlus; } else if (i <= polyFunctions.Count - 2) //one before last one { tempNode.AddNode1(nodeTim); } else if (i <= polyFunctions.Count - 1) //last one { tempNode.AddNode2(nodeTim); } } return(headNode); }
private Node drawMaclaurinSerieFastRecursive(int counter, int order, double[] maclaurinValues, GraphDrawer drawer, Node prevCompletedNode) { NodeHolder nh; Node nodeTim = new NodeTimes(); Node nodeDiv = new NodeDivision(); Node nodeFac = new NodeFactorial(); Node nodePow = new NodePower(); double zeroValue = maclaurinValues[counter - 1]; nodeTim.AddNode1(nodeDiv); nodeTim.AddNode2(nodePow); nodeDiv.AddNode1(new NodeNumber(false, false, zeroValue)); nodeDiv.AddNode2(nodeFac); nodeFac.AddNode1(new NodeNumber(false, false, counter - 1)); nodePow.AddNode1(new NodeNumber(true, false, 1)); //X nodePow.AddNode2(new NodeNumber(false, false, counter - 1)); if (counter == order) { Node nodePlus = new NodePlus(); if (prevCompletedNode != null) { nodePlus.AddNode1(nodeTim); nodePlus.AddNode2(prevCompletedNode); prevCompletedNode = nodePlus.Clone(); nh = new NodeHolder(prevCompletedNode); } else { prevCompletedNode = nodeTim; nh = new NodeHolder(prevCompletedNode); } if (counter == 1) { drawer.drawFunction(nh, true); } else { drawer.drawFunction(nh, false); } return(nodeTim); } else if (counter < order && counter > 0) { Node nodePlus = new NodePlus(); if (prevCompletedNode != null) { nodePlus.AddNode1(nodeTim); nodePlus.AddNode2(prevCompletedNode); prevCompletedNode = nodePlus.Clone(); nh = new NodeHolder(prevCompletedNode); } else { prevCompletedNode = nodeTim; nh = new NodeHolder(prevCompletedNode); } if (counter == 1) { drawer.drawFunction(nh, true); } else { drawer.drawFunction(nh, false); } nodePlus.AddNode1(nodeTim); nodePlus.AddNode2(drawMaclaurinSerieFastRecursive(counter + 1, order, maclaurinValues, drawer, prevCompletedNode)); return(nodePlus); } else { throw new Exception("Error while making Maclaurin serie: counter problem: " + counter); } }