コード例 #1
0
        public override void CreateDerivativeTree(BaseNode parent, bool isLeft = true)
        {
            MultiplicationNode multiplicationNode1 = new MultiplicationNode(Plotter.CloneTree(this.left), Plotter.CloneTree(this.right), null);
            MultiplicationNode multiplicationNode2 = new MultiplicationNode(Plotter.CloneTree(this.left), Plotter.CloneTree(this.right), null);
            SubstractionNode   substraction        = new SubstractionNode(multiplicationNode1, multiplicationNode2, null);
            PowerNode          power = new PowerNode(Plotter.CloneTree(this.right), new NumberNode(null, 2), null);
            DivisionNode       node  = new DivisionNode(substraction, power, null);

            if (parent != null)
            {
                if (isLeft)
                {
                    parent.left = node;
                }
                else
                {
                    parent.right = node;
                }
            }

            node.left.left.left.CreateDerivativeTree(node.left.left);
            node.left.right.right.CreateDerivativeTree(node.left.right, false);

            //Plotter.SetDerivativeRoot (node);
            SetDerivativeRoot(node);
        }
コード例 #2
0
        /// <summary>
        /// Clones a specified tree based on a given node 'root'
        /// </summary>
        /// <param name="root"></param>
        /// <returns></returns>
        public static BaseNode CloneTree(BaseNode root)
        {
            if (root == null)
            {
                return(null);
            }

            BaseNode newNode = null;

            if (root is SubstractionNode)
            {
                newNode = new SubstractionNode(root.value);
            }
            else if (root is MultiplicationNode)
            {
                newNode = new MultiplicationNode(root.value);
            }
            else if (root is SumNode)
            {
                newNode = new SumNode(root.value);
            }
            else if (root is DivisionNode)
            {
                newNode = new DivisionNode(root.value);
            }
            else if (root is NumberNode)
            {
                newNode = new NumberNode(null, (root as NumberNode).RealValue);
            }
            else if (root is BasicFunctionXNode)
            {
                newNode = new BasicFunctionXNode(root.value);
            }
            else if (root is SinNode)
            {
                newNode = new SinNode(root.value);
            }
            else if (root is CosNode)
            {
                newNode = new CosNode(root.value);
            }
            else if (root is PowerNode)
            {
                newNode = new PowerNode(root.value);
            }
            else if (root is ExponentNode)
            {
                newNode = new ExponentNode(root.value);
            }
            else if (root is LnNode)
            {
                newNode = new LnNode(root.value);
            }
            else if (root is FactorialNode)
            {
                newNode = new FactorialNode(root.value);
            }

            newNode.left  = CloneTree(root.left);
            newNode.right = CloneTree(root.right);
            return(newNode);
        }
コード例 #3
0
        /// <summary>
        /// Creates tree based on an input string and root node
        /// </summary>
        /// <param name="s"></param>
        /// <param name="baseNode"></param>
        public void CreateTree(string s, BaseNode baseNode)
        {
            // if the string is empty, we don't do anything. This is the base case to leave the recursion
            if (s == string.Empty)
            {
                return;
            }

            // if it's 's', or '+', or whatever, we create a dedicated class (watch first case to see the logic)
            if (s[0] == 's')
            {
                SinNode node = new SinNode(s, baseNode); // dedicated class
                baseNode.Insert(node);                   // we insert it to the current head node
                CreateTree(node.value, node);            // we change the head node to the newly created one
            }
            else if (s[0] == 'c')
            {
                CosNode node = new CosNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '*')
            {
                // same as in the first 'if'
                MultiplicationNode node = new MultiplicationNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '+')
            {
                // same as in the first 'if'
                SumNode node = new SumNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '/')
            {
                DivisionNode node = new DivisionNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '-' && !(s[1] >= '0' && s[1] <= '9'))
            {
                SubstractionNode node = new SubstractionNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == 'l')
            {
                LnNode node = new LnNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '^')
            {
                PowerNode node = new PowerNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == 'e')
            {
                ExponentNode node = new ExponentNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '!')
            {
                FactorialNode node = new FactorialNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == 'p' || (s[0] >= '0' && s[0] <= '9'))
            {
                // stuff below just parses number
                string toParseIntoNumber = string.Empty;
                int    counter           = 0;

                if (s[0] == 'p')
                {
                    toParseIntoNumber = "p";
                }
                else
                {
                    while ((s[counter] >= '0' && s[counter] <= '9') || s[counter] == '.')
                    {
                        toParseIntoNumber += s[counter];
                        counter++;
                    }
                }

                if (toParseIntoNumber.Contains('.'))
                {
                    toParseIntoNumber = toParseIntoNumber.Replace('.', ',');
                }

                string @newS = string.Empty;

                for (int i = (s[0] == 'p' ? 1 : counter); i < s.Length; i++)
                {
                    newS += s[i];
                }

                // same stuff as in the first 'if'
                NumberNode node = new NumberNode(newS, baseNode, toParseIntoNumber);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '-' && (s[1] >= '0' && s[1] <= '9'))
            {
                // negative number
                s = Plotter.GetStringFromIndex(s, 1);

                string toParseIntoNumber = string.Empty;
                int    counter           = 0;

                if (s[0] == 'p')
                {
                    toParseIntoNumber = "p";
                }
                else
                {
                    do
                    {
                        toParseIntoNumber += s[counter];
                        counter++;
                    } while (counter < s.Length && ((s[counter] >= '0' && s[counter] <= '9') || s[counter] == '.'));
                }

                if (toParseIntoNumber.Contains('.'))
                {
                    toParseIntoNumber = toParseIntoNumber.Replace('.', ',');
                }

                string @newS = string.Empty;

                for (int i = (s[0] == 'p' ? 1 : counter); i < s.Length; i++)
                {
                    newS += s[i];
                }

                NumberNode node = new NumberNode(newS, baseNode, "-" + toParseIntoNumber);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == 'x')
            {
                // same as in the first 'if'
                BasicFunctionXNode node = new BasicFunctionXNode(s, baseNode);
                baseNode.Insert(node);
                CreateTree(node.value, node);
            }
            else if (s[0] == '(' || s[0] == ' ')
            {
                s = GetStringFromIndex(s, 1);  // practically delete that ( or ' '
                CreateTree(s, baseNode);
            }
            else if (s[0] == ')')
            {
                // count how many times ')' appears, let this number be 'i', then our head node is gonna go 'i' levels up

                int i = 0;

                while (s[i] == ')' && (s[i] != ',' || s[i] != ' '))
                {
                    i++;
                    if (i == s.Length)
                    {
                        break;
                    }
                }

                for (int j = 0; j < i; j++)
                {
                    if (baseNode.parent != null)
                    {
                        baseNode = baseNode.parent;
                    }
                    else
                    {
                        throw new Exception("Eror in your input");
                    }
                }


                s = GetStringFromIndex(s, i);
                CreateTree(s, baseNode);
            }
            else if (s[0] == ',')
            {
                if (baseNode.parent == null)
                {
                    throw new Exception("Error in your input");
                }

                // go one level up
                baseNode = baseNode.parent;
                s        = GetStringFromIndex(s, 1);
                CreateTree(s, baseNode);
            }
        }
コード例 #4
0
        public override void CreateDerivativeTree(BaseNode parent, bool isLeft = true)
        {
            if (this.right is NumberNode && this.left is BasicFunctionXNode)
            {
                var lesser           = (right as NumberNode).RealValue - 1;
                BasicFunctionXNode x = new BasicFunctionXNode("", null);
                MultiplicationNode multiplication = new MultiplicationNode(new NumberNode(null, (right as NumberNode).RealValue),
                                                                           new PowerNode(x, new NumberNode(null, lesser), null), null);

                if (parent != null)
                {
                    if (isLeft)
                    {
                        parent.left = multiplication;
                    }
                    else
                    {
                        parent.right = multiplication;
                    }
                }

                SetDerivativeRoot(multiplication);
                return;
            }
            else
            {
                if (this.right is NumberNode && this.left is NumberNode)
                {
                    // if both this.left and this.right are numbers, return 0 for its just a number and it's anyway gon be 0
                    NumberNode node = new NumberNode(parent, 0);

                    if (parent != null)
                    {
                        if (isLeft)
                        {
                            parent.left = node;
                        }
                        else
                        {
                            parent.right = node;
                        }
                    }

                    //Plotter.SetDerivativeRoot (node);
                    SetDerivativeRoot(node);
                    return;
                }
                else if (this.right is NumberNode && !(this.left is NumberNode))
                {
                    // f(x) ^ (some number)
                    // if left one some function
                    double nMinus1 = ((NumberNode)this.right).RealValue - 1;
                    var    value   = ((NumberNode)this.right).RealValue;

                    if (value == 1)
                    {
                        var node = Plotter.CloneTree(this);

                        if (parent != null)
                        {
                            if (isLeft)
                            {
                                parent.left = node;
                            }
                            else
                            {
                                parent.right = node;
                            }
                        }

                        node.left.CreateDerivativeTree(node);
                        SetDerivativeRoot(node);
                        return;
                    }

                    PowerNode          power          = new PowerNode(Plotter.CloneTree(this.left), new NumberNode(null, nMinus1), null);
                    MultiplicationNode multiplication = new MultiplicationNode(new NumberNode(null, value), Plotter.CloneTree(this.left), null);

                    // if the f(x) is more complicated than just 'x', we do additional calculation
                    if (!(multiplication.right is BasicFunctionXNode))
                    {
                        MultiplicationNode node = new MultiplicationNode(multiplication, Plotter.CloneTree(this.left), parent);
                        node.right.CreateDerivativeTree(multiplication, false);

                        if (parent != null)
                        {
                            if (isLeft)
                            {
                                parent.left = node;
                            }
                            else
                            {
                                parent.right = node;
                            }
                        }

                        //Plotter.SetDerivativeRoot (node);
                        SetDerivativeRoot(node);
                        return;
                    }

                    multiplication.parent = parent;

                    if (parent != null)
                    {
                        if (isLeft)
                        {
                            parent.left = multiplication;
                        }
                        else
                        {
                            parent.right = multiplication;
                        }
                    }

                    //Plotter.SetDerivativeRoot (multiplication);
                    SetDerivativeRoot(multiplication);
                    return;
                }
                else if (!(this.right is NumberNode) && (this.left is NumberNode))
                {
                    // (some number) ^ f(x)

                    var value = ((NumberNode)this.left).RealValue;

                    if (this.right is BasicFunctionXNode)
                    {
                        // simple function
                        PowerNode          power = new PowerNode(new NumberNode(null, value), new BasicFunctionXNode(""), null);
                        LnNode             ln    = new LnNode(new NumberNode(null, value), null);
                        MultiplicationNode node  = new MultiplicationNode(power, ln, parent);

                        if (parent != null)
                        {
                            if (isLeft)
                            {
                                parent.left = node;
                            }
                            else
                            {
                                parent.right = node;
                            }
                        }

                        //Plotter.SetDerivativeRoot (node);
                        SetDerivativeRoot(node);
                        return;
                    }
                    else
                    {
                        // function is more complicated
                        PowerNode          power          = new PowerNode(new NumberNode(null, value), this.right, null);
                        LnNode             ln             = new LnNode(new NumberNode(null, value), null);
                        MultiplicationNode multiplication = new MultiplicationNode(power, ln, parent);
                        MultiplicationNode node           = new MultiplicationNode(multiplication, Plotter.CloneTree(this.right), parent);
                        node.right.CreateDerivativeTree(node, false);

                        if (parent != null)
                        {
                            if (isLeft)
                            {
                                parent.left = node;
                            }
                            else
                            {
                                parent.right = node;
                            }
                        }

                        //Plotter.SetDerivativeRoot (node);
                        SetDerivativeRoot(node);
                        return;
                    }
                }
                else if (!(this.right is NumberNode) && !(this.left is NumberNode))
                {
                    // neither is a number
                    // CASE: f(x) ^ g(x)
                    // d(f(x) ^ g(x))/dx = e^(g(x)*ln(f(x)) * d((g(x)*f(x)))/dx )
                    // this.left = f(x), this.right = g(x)

                    LnNode             lnFx                       = new LnNode(Plotter.CloneTree(this.left), null);                                                                // create ln(f(x))
                    MultiplicationNode multiplication             = new MultiplicationNode(Plotter.CloneTree(this.right), lnFx, null);                                             // create g(x)*ln(f(x))
                    PowerNode          ePower                     = new PowerNode(new NumberNode(null, Math.E), multiplication, null);                                             // create e^(g(x)*ln(f(x)))
                    MultiplicationNode derivativeOfMultiplication = new MultiplicationNode(Plotter.CloneTree(multiplication.left), Plotter.CloneTree(multiplication.right), null); // do the derivative of g(x)*ln(f(x))
                    MultiplicationNode node                       = new MultiplicationNode(ePower, derivativeOfMultiplication, parent);                                            // put it all together

                    node.right.CreateDerivativeTree(node, false);                                                                                                                  // take a derivative

                    if (parent != null)
                    {
                        if (isLeft)
                        {
                            parent.left = node;
                        }
                        else
                        {
                            parent.right = node;
                        }
                    }

                    //Plotter.SetDerivativeRoot (node);
                    SetDerivativeRoot(node);
                    return;
                }
            }
        }