Пример #1
0
        public override Node Clone()
        {
            Node newNode  = new NodeE();
            Node newNode1 = node1.Clone();

            newNode.AddNode1(newNode1);
            return(newNode);
        }
Пример #2
0
        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);
        }
Пример #3
0
        private Node combineNodes(Node cleanNode1, Node cleanNode2)
        {
            if (cleanNode1 is NodeNumber && cleanNode2 is NodeNumber)
            {
                int negOrPos = 0;
                if (((NodeNumber)cleanNode1).Number == ((NodeNumber)cleanNode2).Number)
                {
                    negOrPos = 1;
                }
                else if (((NodeNumber)cleanNode1).Number == -1 * ((NodeNumber)cleanNode2).Number)
                {
                    negOrPos = -1;
                }
                if (negOrPos != 0)
                {
                    if (cleanNode1.ContainsX() == cleanNode2.ContainsX() && cleanNode1.ContainsP() == cleanNode2.ContainsP())
                    {
                        Node newNumberNode;
                        newNumberNode = new NodeNumber(false, false, negOrPos);
                        return(newNumberNode);
                    }
                    else if (cleanNode1.ContainsX() == cleanNode2.ContainsX() && !cleanNode2.ContainsP())
                    {
                        Node newNumberNode;
                        newNumberNode = new NodeNumber(false, true, negOrPos);
                        return(newNumberNode);
                    }
                    else if (cleanNode1.ContainsP() == cleanNode2.ContainsP() && !cleanNode2.ContainsX())
                    {
                        Node newNumberNode;
                        newNumberNode = new NodeNumber(true, false, negOrPos);
                        return(newNumberNode);
                    }
                }
            }
            if (cleanNode1 is NodeNumber)
            {
                if (((NodeNumber)cleanNode1).Number == 0)
                {
                    Node newNumberNode;
                    newNumberNode = new NodeNumber(false, false, 0);
                    return(newNumberNode);
                }
                if (cleanNode2 is NodeFactorial)
                {
                    if (((NodeNumber)cleanNode1).Number == ((NodeFactorial)cleanNode2).GetValueForX(0))
                    {
                        return(new NodeNumber(cleanNode1.ContainsX(), cleanNode1.ContainsP(), 1));
                    }
                }
            }
            if (cleanNode2 is NodeNumber)
            {
                if (cleanNode1 is NodeFactorial)
                {
                    if (((NodeNumber)cleanNode2).Number == ((NodeFactorial)cleanNode1).GetValueForX(0))
                    {
                        Node nodeDiv = new NodeDivision();
                        nodeDiv.AddNode1(new NodeNumber(false, false, 1));
                        nodeDiv.AddNode2(new NodeNumber(cleanNode2.ContainsX(), cleanNode2.ContainsP(), 1));
                        return(nodeDiv);
                    }
                }
                if (((NodeNumber)cleanNode2).Number == 1 && !cleanNode2.ContainsP() && !cleanNode2.ContainsX())
                {
                    return(cleanNode1);
                }
            }

            //none of the nodes are numbers, so they need to be cleaned!
            Node trash;

            if (cleanNode2.SameAs(cleanNode1))
            {
                Node nodeNum = new NodeNumber(false, false, 1);
                return(nodeNum);
            }
            if ((cleanNode1 is NodePower && cleanNode2 is NodePower) || (cleanNode1 is NodeE && cleanNode2 is NodeE) || (cleanNode1 is NodeTimes && cleanNode2 is NodeTimes))
            {
                if (!(cleanNode1 is NodeE))
                {
                    if (cleanNode1.Node1.SameAs(cleanNode2.Node1))
                    {
                        if (cleanNode1 is NodePower)
                        {
                            NodePower nodePow = new NodePower();
                            NodeMinus nodeMin = new NodeMinus();
                            nodePow.AddNode1(cleanNode1.Node1);
                            nodePow.AddNode2(nodeMin);
                            nodeMin.AddNode1(cleanNode1.Node2);
                            nodeMin.AddNode2(cleanNode2.Node2);
                            nodePow.MakeNodeClean(null, out trash);
                            return(nodePow);
                        }
                        if (cleanNode1 is NodeTimes)
                        {
                            NodeDivision nodeDiv = new NodeDivision();
                            nodeDiv.AddNode1(cleanNode1.Node2);
                            nodeDiv.AddNode2(cleanNode2.Node2);
                            nodeDiv.MakeNodeClean(null, out trash);
                            return(nodeDiv);
                        }
                    }
                    else if (cleanNode1.Node1.SameAs(cleanNode2.Node2))
                    {
                        if (cleanNode1 is NodeTimes)
                        {
                            NodeDivision nodeDiv = new NodeDivision();
                            nodeDiv.AddNode1(cleanNode1.Node2);
                            nodeDiv.AddNode2(cleanNode2.Node1);
                            nodeDiv.MakeNodeClean(null, out trash);
                            return(nodeDiv);
                        }
                    }
                    else if (cleanNode1.Node2.SameAs(cleanNode2.Node1))
                    {
                        if (cleanNode1 is NodeTimes)
                        {
                            NodeDivision nodeDiv = new NodeDivision();
                            nodeDiv.AddNode1(cleanNode1.Node1);
                            nodeDiv.AddNode2(cleanNode2.Node2);
                            nodeDiv.MakeNodeClean(null, out trash);
                            return(nodeDiv);
                        }
                    }
                    else if (cleanNode1.Node2.SameAs(cleanNode2.Node2))
                    {
                        if (cleanNode1 is NodeTimes)
                        {
                            NodeDivision nodeDiv = new NodeDivision();
                            nodeDiv.AddNode1(cleanNode1.Node1);
                            nodeDiv.AddNode2(cleanNode2.Node1);
                            nodeDiv.MakeNodeClean(null, out trash);
                            return(nodeDiv);
                        }
                    }
                }
                else
                {
                    NodeE     nodeE   = new NodeE();
                    NodeMinus nodeMin = new NodeMinus();
                    nodeE.AddNode1(nodeMin);
                    nodeMin.AddNode1(cleanNode1.Node1);
                    nodeMin.AddNode2(cleanNode2.Node1);
                    nodeE.MakeNodeClean(null, out trash);
                    return(nodeE);
                }
            }

            return(null);
        }
Пример #4
0
        private Node combineNodes(Node cleanNode1, Node cleanNode2)
        {
            if (cleanNode1 is NodeNumber && !(cleanNode2 is NodeNumber))
            {
                if (((NodeNumber)cleanNode1).Number == 0)
                {
                    Node newNumberNode;
                    newNumberNode = new NodeNumber(false, false, 0);
                    return(newNumberNode);
                }
                else if (((NodeNumber)cleanNode1).Number == 1 && !cleanNode1.ContainsX() && !cleanNode1.ContainsP())
                {
                    return(cleanNode2);
                }
                else if (cleanNode2 is NodePower)
                {
                    if (cleanNode2.Node1 is NodeNumber)
                    {
                        if (((NodeNumber)cleanNode1).ContainsX() == ((NodeNumber)cleanNode2.Node1).ContainsX())
                        {
                            //check if nodePower.Node1(lower) has only 1x and node has (somenumber)x
                        }
                    }
                }
            }
            if (cleanNode2 is NodeNumber && !(cleanNode1 is NodeNumber))
            {
                if (((NodeNumber)cleanNode2).Number == 0)
                {
                    Node newNumberNode;
                    newNumberNode = new NodeNumber(false, false, 0);
                    return(newNumberNode);
                }
                else if (((NodeNumber)cleanNode2).Number == 1 && !cleanNode2.ContainsX() && !cleanNode2.ContainsP())
                {
                    return(cleanNode1);
                }
            }
            if (cleanNode1 is NodeNumber && cleanNode2 is NodeNumber)
            {
                if (cleanNode1.ContainsX() != cleanNode2.ContainsX())     //one has X
                {
                    if (cleanNode1.ContainsP() != cleanNode2.ContainsP()) //one has P
                    {
                        Node newNumberNode;
                        newNumberNode = new NodeNumber(true, true, ((NodeNumber)cleanNode1).Number * ((NodeNumber)cleanNode2).Number);
                        return(newNumberNode);
                    }
                    else if (!cleanNode1.ContainsP()) //both have not P
                    {
                        Node newNumberNode;
                        newNumberNode = new NodeNumber(true, false, ((NodeNumber)cleanNode1).Number * ((NodeNumber)cleanNode2).Number);
                        return(newNumberNode);
                    }
                }
                else if (!cleanNode1.ContainsX())                         //both have not X
                {
                    if (cleanNode1.ContainsP() != cleanNode2.ContainsP()) //one has P
                    {
                        Node newNumberNode;
                        newNumberNode = new NodeNumber(false, true, ((NodeNumber)cleanNode1).Number * ((NodeNumber)cleanNode2).Number);
                        return(newNumberNode);
                    }
                    else if (!cleanNode1.ContainsP()) //both have not P
                    {
                        Node newNumberNode;
                        newNumberNode = new NodeNumber(false, false, ((NodeNumber)cleanNode1).Number * ((NodeNumber)cleanNode2).Number);
                        return(newNumberNode);
                    }
                }
            }
            //none of the nodes are numbers, so they need to be cleaned!
            Node trash;

            if (cleanNode2.SameAs(cleanNode1))
            {
                Node nodePow = new NodePower();
                nodePow.AddNode1(cleanNode1);
                nodePow.AddNode2(new NodeNumber(false, false, 2));
                nodePow.MakeNodeClean(null, out trash);
                return(nodePow);
            }
            if ((cleanNode1 is NodePower && cleanNode2 is NodePower) || (cleanNode1 is NodeE && cleanNode2 is NodeE) || (cleanNode1 is NodeLN && cleanNode2 is NodeLN))
            {
                if (cleanNode1.Node1.SameAs(cleanNode2.Node1))
                {
                    if (cleanNode1 is NodePower)
                    {
                        Node nodePow  = new NodePower();
                        Node nodePlus = new NodePlus();
                        nodePow.AddNode1(cleanNode1.Node1);
                        nodePow.AddNode2(nodePlus);
                        nodePlus.AddNode1(cleanNode1.Node2);
                        nodePlus.AddNode2(cleanNode2.Node2);
                        nodePow.MakeNodeClean(null, out trash);
                        return(nodePow);
                    }
                }
                if (cleanNode1 is NodeE)
                {
                    Node nodeE    = new NodeE();
                    Node nodePlus = new NodePlus();
                    nodeE.AddNode1(nodePlus);
                    nodePlus.AddNode1(cleanNode1.Node1);
                    nodePlus.AddNode2(cleanNode2.Node1);
                    nodeE.MakeNodeClean(null, out trash);
                    return(nodeE);
                }
            }

            return(null);
        }