Exemple #1
0
        private Node GenerateMaclaurinSeriesPolynomial(double x, int order)
        {
            if (order == 0)
            {
                return(this);
            }
            if (order == 1)
            {
                return(new PlusSign(new MultiplicationSign(ReturnDerivative(x), new VariableNode()), this));
            }
            VariableNode      variableNode = new VariableNode();
            NaturalNumberNode orderNode    = new NaturalNumberNode(order);
            CaretSign         caretSign    = new CaretSign(variableNode, orderNode);
            Node f0 = ReturnDerivative(x);

            for (int i = 1; i < order; i++)
            {
                f0 = f0.ReturnDerivative(x);
            }
            MultiplicationSign multiplicationSign = new MultiplicationSign(caretSign, new RationalNumberNode(f0.Calculate(0)));
            FactorialFunction  factorialFunction  = new FactorialFunction(orderNode);
            DivisionSign       divisionSign       = new DivisionSign(multiplicationSign, factorialFunction);

            return(new PlusSign(divisionSign, ReturnMaclaurinSeriesPolynomial(x, order - 1)));
        }
Exemple #2
0
        public double ReturnMaclaurinSeries(double x, int order)
        {
            if (order == 0)
            {
                return(Calculate(0));
            }
            if (order == 1)
            {
                return(ReturnDerivative(x).Calculate(0) * x + Calculate(0));
            }
            VariableNode      variableNode = new VariableNode();
            NaturalNumberNode orderNode    = new NaturalNumberNode(order);
            CaretSign         caretSign    = new CaretSign(variableNode, orderNode);
            Node f0 = ReturnDerivative(x);

            for (int i = 1; i < order; i++)
            {
                f0 = f0.ReturnDerivative(x);
            }
            MultiplicationSign multiplicationSign = new MultiplicationSign(caretSign, new RationalNumberNode(f0.Calculate(0)));
            FactorialFunction  factorialFunction  = new FactorialFunction(orderNode);
            DivisionSign       divisionSign       = new DivisionSign(multiplicationSign, factorialFunction);

            return(divisionSign.Calculate(x) + ReturnMaclaurinSeries(x, order - 1));
        }
Exemple #3
0
        public override Node ReturnDerivative(double x)
        {
            NaturalNumberNode zero                = new NaturalNumberNode(0);
            SineFunction      sineNode            = new SineFunction(child.Copy());
            MinusSign         minusNode           = new MinusSign(zero, sineNode);
            Node childDerivative                  = child.ReturnDerivative(x);
            MultiplicationSign multiplicationSign = new MultiplicationSign(minusNode, childDerivative);

            return(multiplicationSign);
        }
        public override Node ReturnDerivative(double x)
        {
            MultiplicationSign multiplicationSignA = new MultiplicationSign(leftNode.ReturnDerivative(x), rightNode.Copy());
            MultiplicationSign multiplicationSignB = new MultiplicationSign(leftNode.Copy(), rightNode.ReturnDerivative(x));
            MinusSign          minusSign           = new MinusSign(multiplicationSignA, multiplicationSignB);
            NaturalNumberNode  naturalNumberNode   = new NaturalNumberNode(2);
            CaretSign          caretSign           = new CaretSign(rightNode.Copy(), naturalNumberNode);
            DivisionSign       division            = new DivisionSign(minusSign, caretSign);

            return(division);
        }
Exemple #5
0
        private PlusSign[] ReturnNewtonIndeterminates(int order)
        {
            PlusSign[]         funcs = new PlusSign[order + 1];
            HNode              hNode = new HNode();
            NaturalNumberNode  orderNode;
            MultiplicationSign multiplicationSign;
            VariableNode       variableNode = new VariableNode();

            for (int i = 0; i <= order; i++)
            {
                orderNode          = new NaturalNumberNode(order - i);
                multiplicationSign = new MultiplicationSign(orderNode, hNode);
                funcs[i]           = new PlusSign(variableNode, multiplicationSign);
            }
            return(funcs);
        }
Exemple #6
0
        public double ReturnNewtonMaclaurinSeries(double x, int order)
        {
            if (order == 0)
            {
                return(Calculate(0));
            }
            if (order == 1)
            {
                return(ReturnNewtonDerivative(0) * x + Calculate(0));
            }
            VariableNode       variableNode       = new VariableNode();
            NaturalNumberNode  orderNode          = new NaturalNumberNode(order);
            CaretSign          caretSign          = new CaretSign(variableNode, orderNode);
            RationalNumberNode f0                 = new RationalNumberNode(CalculatePolynomialDerivative(0, order));
            MultiplicationSign multiplicationSign = new MultiplicationSign(caretSign, f0);
            FactorialFunction  factorialFunction  = new FactorialFunction(orderNode);
            DivisionSign       divisionSign       = new DivisionSign(multiplicationSign, factorialFunction);

            return(divisionSign.Calculate(x) + ReturnNewtonMaclaurinSeries(x, order - 1));
        }
Exemple #7
0
        private Node ReturnNewtonPolynomial(double x, int order)
        {
            Operator sign = null;

            int[]      coefficients   = ReturnIndeterminateCoefficients(order);
            PlusSign[] indeterminates = ReturnNewtonIndeterminates(order);

            if (order == 0)
            {
                return(new RationalNumberNode(Calculate(indeterminates[0].Calculate(x))));
            }
            if (order == 1)
            {
                return(new MinusSign(new RationalNumberNode(Calculate(indeterminates[0].Calculate(x))), new RationalNumberNode(Calculate(indeterminates[1].Calculate(x)))));
            }

            NaturalNumberNode  naturalNumberNode  = new NaturalNumberNode(coefficients[0]);
            MultiplicationSign multiplicationSign = new MultiplicationSign(naturalNumberNode, new RationalNumberNode(Calculate(indeterminates[0].Calculate(x))));

            sign = multiplicationSign;

            for (int i = 1; i <= order; i++)
            {
                naturalNumberNode  = new NaturalNumberNode(Math.Abs(coefficients[i]));
                multiplicationSign = new MultiplicationSign(naturalNumberNode, new RationalNumberNode(Calculate(indeterminates[i].Calculate(x))));
                if (i % 2 == 0)
                {
                    sign = new PlusSign(sign, multiplicationSign);
                }
                else
                {
                    sign = new MinusSign(sign, multiplicationSign);
                }
            }
            return(sign);
        }
        private Node Parse(ref string s)
        {
            Node a;
            Node b;
            char op = ' ';

            if (s[0] == '+' || s[0] == '-' || s[0] == '*' || s[0] == '/' || s[0] == '^')
            {
                op = s[0];
                s  = s.Substring(1);
                SkipCharacter(ref s, '(');
                a = Parse(ref s);
                SkipCharacter(ref s, ',');
                b = Parse(ref s);
                SkipCharacter(ref s, ')');
                if (op == '+')
                {
                    return(new PlusSign(a, b));
                }
                else if (op == '-')
                {
                    return(new MinusSign(a, b));
                }
                else if (op == '*')
                {
                    return(new MultiplicationSign(a, b));
                }
                else if (op == '/')
                {
                    return(new DivisionSign(a, b));
                }
                else
                {
                    return(new CaretSign(a, b));
                }
            }
            else if (s[0] == 's' || s[0] == 'c' || s[0] == 'e' || s[0] == 'l' || s[0] == '!')
            {
                op = s[0];
                s  = s.Substring(1);
                SkipCharacter(ref s, '(');
                a = Parse(ref s);
                SkipCharacter(ref s, ')');
                if (op == 's')
                {
                    return(new SineFunction(a));
                }
                else if (op == 'c')
                {
                    return(new CosineFunction(a));
                }
                else if (op == 'e')
                {
                    return(new ExponentialFunction(a));
                }
                else if (op == 'l')
                {
                    return(new LogarithmFunction(a));
                }
                else
                {
                    return(new FactorialFunction(a));
                }
            }
            else if (s[0] == 'n' || s[0] == 'r')
            {
                op = s[0];
                s  = s.Substring(1);
                SkipCharacter(ref s, '(');
                string tempS = s.Split(')')[0];
                tempS = tempS.Replace(',', '.');
                if (op == 'n')
                {
                    if (tempS.Contains('.') || tempS.Contains('-'))
                    {
                        throw new IsNotValidNaturalNumberException();
                    }
                }
                s = s.Substring(s.IndexOf(')') + 1);
                if (op == 'n')
                {
                    return(new NaturalNumberNode(int.Parse(tempS)));
                }
                else
                {
                    return(new RationalNumberNode(float.Parse(tempS)));
                }
            }
            else if (s[0] == 'p')
            {
                s = s.Substring(1);
                return(new PiNode());
            }
            else if (s[0] == 'x')
            {
                s = s.Substring(1);
                return(new VariableNode());
            }
            else if (char.IsDigit(s[0]))
            {
                string number = s[0].ToString();
                s = s.Substring(1);
                while (s.Length > 0)
                {
                    if (!char.IsDigit(s[0]))
                    {
                        break;
                    }
                    number += s[0];
                    s       = s.Substring(1);
                }
                a = new NaturalNumberNode(int.Parse(number));
                return(a);
            }
            throw new InvalidExpressionException();
        }