private void ExecucaoExemploSimpson()
        {
            FuncoesSimpson funcSimp = new FuncoesSimpson();
            ExemploFuncoes funcExemplos = new ExemploFuncoes();
            double a = 0, b = 0.8;
            int n = 4, nParImpar = 5;
            bool exercicio = false;

            Console.WriteLine("Utilizacao das funcoes para o exemplo:");
            Console.WriteLine();
            Console.WriteLine(equacaoExemplo);
            Console.WriteLine();

            Console.WriteLine("Resultado 1/3 = " + Math.Round(funcSimp.CalculaSimp13(a, b, exercicio, 12), 6)); //OK Exemplo
            Console.WriteLine();

            Console.WriteLine("Resultado 1/3 Multiplo = " + Math.Round(funcSimp.CalculaSimp13m(a, b, n, exercicio), 6));// OK Exemplo
            Console.WriteLine();

            Console.WriteLine("Resultado 3/8 = " + Math.Round(funcSimp.CalculaSimp38(a, b, exercicio), 6)); //OK Exemplo
            Console.WriteLine();

            Console.WriteLine("Resultado Regra Multipla Par e Impar = " + Math.Round(funcSimp.CalculaSimpInt(a, b, nParImpar, exercicio), 6));// OK Exemplo
            Console.WriteLine();
        }
        /// <summary>
        /// Calcula a regra de simpson 1/3 utilizando os limites e selecionando entre exemplo ou exercicio
        /// </summary>
        /// <param name="a">limite inferior</param>
        /// <param name="b">limite superior</param>
        /// <param name="exercicio">seleção de funcao de exemplo ou exercicio</param>
        /// <returns>double</returns>
        public double CalculaSimp13(double a, double b, bool exercicio, int nvezes)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            double solucao = 0;
            funcaoUtilizada = new ExemploFuncoes();
            double h = CalculaH(b, a, nvezes);
            double[] xValue = new double[3];
            xValue[0] = 0;
            for(int i = 1; i < xValue.Length; i++)
            {
                xValue[i] = h * i;
            }
            if (exercicio)
            {
                solucao = 2 * h * (funcaoUtilizada.FuncaoExercicio(xValue[0]) + 4 * funcaoUtilizada.FuncaoExercicio(xValue[1]) + funcaoUtilizada.FuncaoExercicio(xValue[2])) / 6;
            }
            else
            {
                for (int i = 0; i < nvezes; i++)
                {
                    solucao += 2 * h * (funcaoUtilizada.FuncaoExemplo(xValue[0]) + 4 * funcaoUtilizada.FuncaoExemplo(xValue[1]) + funcaoUtilizada.FuncaoExemplo(xValue[2])) / 6;
                }
            }
            sw.Stop();
            tempoSimp13 = sw.Elapsed;

            return solucao;
        }
        /// <summary>
        /// Funcao utilizada para calcular o Exercicio 24.1 do Livro necessario para a AV1
        /// </summary>
        /// <param name="ti">Valor inicial da temperatura</param>
        /// <param name="te">Valor final da temperatura</param>
        /// <param name="n">numero de segmentos(calculado pela h dado pelo livro)</param>
        /// <returns>double regra do trapezio</returns>
        public double CalculaExercicioAV1_24_1(double ti, double te, double n)
        {
            double h = CalculaH(te, ti, n);
            //funcao1 = new ExemploFuncoes();
            funcao1 = new Funcoes.ExemploFuncoes();

            soma = funcao1.FuncaoExercicioAv1_24_1(ti);

            for (int i = 1; i < n; i++)
            {
                soma += 2 * funcao1.FuncaoExercicioAv1_24_1(ti + h * i);
            }
            soma += funcao1.FuncaoExercicioAv1_24_1(te);

            solucao = h * soma / 2;

            return Math.Round(solucao, 4);
        }
        /// <summary>
        /// Funcao utilizada para calcular a regra do trapezio quando a equação esta disponivel. Utilizada em Romberg
        /// </summary>
        /// <param name="n">numero de segmentos</param>
        /// <param name="a">limite inical</param>
        /// <param name="b">limite final</param>
        /// <returns>double funcao calculada</returns>
        public double CalculaRegraEq(int n, double a, double b)
        {
            funcao1 = new ExemploFuncoes();
            double solucao = 0;

            double h = (b - a) / n;
            double x = a;
            double soma = funcao1.FuncaoExemplo(x);

            for (int i = 1; i < n; i++)
            {
                x += h;
                soma += 2 * funcao1.FuncaoExemplo(x);
            }
            soma += funcao1.FuncaoExemplo(b);
            solucao = (b - a) * soma / (2 * n);

            return solucao;
        }
        private void ExecucaoExercicioSimpson()
        {
            FuncoesSimpson funcSimp = new FuncoesSimpson();
            ExemploFuncoes funcExemplos = new ExemploFuncoes();
            double a = 0, b = 10;
            int n = 10;
            int nEq = 256;
            bool exercicio = true;

            Console.WriteLine("Utilizacao das funcoes para o exercicio:");
            Console.WriteLine();
            Console.WriteLine(equacaoExercicio);
            Console.WriteLine();

            Console.WriteLine("Resultado 1/3 = " + Math.Round(funcSimp.CalculaSimp13(a, b, exercicio, 100), 6)); //OK Exercicio
            Console.WriteLine("O sistema levou " + funcSimp.tempoSimp13 + " para ser resolvido");
            Console.WriteLine();

            Console.WriteLine("Resultado 1/3 Multiplo = " + Math.Round(funcSimp.CalculaSimp13m(a, b, n, exercicio), 6)); //OK Exercicio
            Console.WriteLine("O sistema levou " + funcSimp.tempoSimp13m + " para ser resolvido");
            Console.WriteLine();

            Console.WriteLine("Resultado 3/8 = " + Math.Round(funcSimp.CalculaSimp38(a, b, exercicio), 6)); //OK Exercicio
            Console.WriteLine("O sistema levou " + funcSimp.tempoSimp38 + " para ser resolvido");
            Console.WriteLine();

            Console.WriteLine("Resultado Regra Multipla Par e Impar = " + Math.Round(funcSimp.CalculaSimpInt(a, b, n, exercicio), 6));// OK Exercicio
            Console.WriteLine("O sistema levou " + funcSimp.tempoSimpInt + " para ser resolvido");
            Console.WriteLine();

            //Exercicio Romberg
            Console.WriteLine("Aplicação no exemplo 21.1 como solicitado na aula 3");
            Console.WriteLine("Resultado Regra 1/3 quando a funcao e conhecida = " + Math.Round(funcSimp.CalculaSimpEq(nEq, 0, 0.8), 6));// OK Exercicio
            Console.WriteLine("O utilizando " + nEq + " segmentos");
            Console.WriteLine("O sistema levou " + funcSimp.tempoSimpInt + " para ser resolvido");

            Console.WriteLine();
        }
        //Exemplo Livro
        public double CalculaRegraExemplo(double xi, double xe, double n)
        {
            double h = CalculaH(xe, xi, n);
            //funcao1 = new ExemploFuncoes();
            funcao1 = new Funcoes.ExemploFuncoes();

            soma = funcao1.FuncaoExemplo(xi);

            for (int i = 1; i < n; i++)
            {
                soma += 2 * funcao1.FuncaoExemplo(xi + h * i);
            }
            soma += funcao1.FuncaoExemplo(xe);

            solucao = h * soma / 2;

            return Math.Round(solucao, 4);
        }
        //Exercicio Livro
        public double CalculaRegraExercicio(double xi, double xe, double n)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();

            double h = CalculaH(xe, xi, n);

            Console.WriteLine("h = " + h + " | " + " n = " + n);
            //funcao1 = new ExemploFuncoes();
            funcao1 = new Funcoes.ExemploFuncoes();

            //Funcao Paraquedista
            soma = funcao1.FuncaoExercicio(xi);

            for (int i = 1; i < n; i++)
            {
                soma += 2 * funcao1.FuncaoExercicio(xi + h * i);
            }
            soma += funcao1.FuncaoExercicio(xe);

            solucao = h * soma / 2;

            sw.Stop();

            tempoTrapezio = sw.Elapsed;

            return Math.Round(solucao, 5);
        }
        /// <summary>
        /// Calcula Regra de simpson tanto para par quanto para impar
        /// </summary>
        /// <param name="a">double limite inicial</param>
        /// <param name="b">double limite final</param>
        /// <param name="n">numero de segmentos</param>
        /// <param name="exercicio">seleção de funcao de exemplo ou exercicio</param>
        /// <returns>double</returns>
        public double CalculaSimpInt(double a, double b, int n, bool exercicio)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            double h = 0, soma = 0, solucao = 0;
            double[] xValues = new double[n + 1];
            int impar = 0, m = 0;

            trap = new RegraDoTrapezio.RegraDoTrapezio();
            funcaoUtilizada = new ExemploFuncoes();

            h = (b - a) / n;
            xValues[0] = 0;
            for(int i = 1; i < xValues.Length; i++)
            {
                xValues[i] = h * i;
            }

            //adicao de selecao de exemplo ou exercicio
            if (exercicio)
            {
                if (n == 1)
                {
                    soma = trap.CalculaRegraSimples(h, funcaoUtilizada.FuncaoExercicio(xValues[n - 1]), funcaoUtilizada.FuncaoExercicio(xValues[n]));
                }
                else
                {
                    m = n;
                    impar = n % 2;
                    if (impar > 0 && n > 1)
                    {
                        soma += CalculaSimp38(h, funcaoUtilizada.FuncaoExercicio(xValues[n - 3]), funcaoUtilizada.FuncaoExercicio(xValues[n - 2]), funcaoUtilizada.FuncaoExercicio(xValues[n - 1]), funcaoUtilizada.FuncaoExercicio(xValues[n]));
                        m = n - 3;
                    }
                    if (m > 1)
                    {
                        soma += CalculaSimp13m(h, m, true);
                    }
                }
                solucao = soma;
            }
            else
            {
                if (n == 1)
                {
                    soma = trap.CalculaRegraSimples(h, funcaoUtilizada.FuncaoExemplo(xValues[n - 1]), funcaoUtilizada.FuncaoExemplo(xValues[n]));
                }
                else
                {
                    m = n;
                    impar = n % 2;
                    if (impar > 0 && n > 1)
                    {
                        soma += CalculaSimp38(h, funcaoUtilizada.FuncaoExemplo(xValues[n - 3]), funcaoUtilizada.FuncaoExemplo(xValues[n - 2]), funcaoUtilizada.FuncaoExemplo(xValues[n - 1]), funcaoUtilizada.FuncaoExemplo(xValues[n]));
                        m = n - 3;
                    }
                    if (m > 1)
                    {
                        soma += CalculaSimp13m(h, m, false);
                    }
                }
                solucao = soma;
            }
            sw.Stop();
            tempoSimpInt = sw.Elapsed;
            return solucao;
        }
        /// <summary>
        /// Funcao utilizada para se calcula a regra de 1/3 quando a funcao esta disponivel. Utilizada em Romberg.
        /// </summary>
        /// <param name="n">numero de segmentos</param>
        /// <param name="a">limite inical</param>
        /// <param name="b">limite final</param>
        /// <returns>doulbe funcao 1/3 para equacao</returns>
        public double CalculaSimpEq(int n, double a, double b)
        {
            funcaoUtilizada = new ExemploFuncoes();
            double solucao = 0;

            double h = (b - a) / n;
            double x = a;
            double soma = funcaoUtilizada.FuncaoExemplo(x);
            for (int i = 1; i < n - 2; i += 2)
            {
                x += h;
                soma += 4 * funcaoUtilizada.FuncaoExemplo(x);
                x += h;
                soma += 2 * funcaoUtilizada.FuncaoExemplo(x);
            }
            x += h;
            soma += 4 * funcaoUtilizada.FuncaoExemplo(x);
            soma += funcaoUtilizada.FuncaoExemplo(b);
            solucao = (b - a) * soma / (3 * n);

            return solucao;
        }
        /// <summary>
        /// Calcula a regra de simpson 3/8 utilizando os limites e selecionando entre exemplo ou exercicio
        /// </summary>
        /// <param name="a">limite inferior</param>
        /// <param name="b">limite superior</param>
        /// <param name="exercicio">seleção de funcao de exemplo ou exercicio</param>
        /// <returns>double</returns>
        public double CalculaSimp38(double a, double b, bool exercicio)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            double solucao = 0;
            funcaoUtilizada = new ExemploFuncoes();
            double h = CalculaH(b, a, 3);
            double[] xValue = new double[4];
            xValue[0] = 0;
            for (int i = 1; i < xValue.Length; i++)
            {
                xValue[i] = h * i;
            }

            if (exercicio)
            {
                solucao = 3 * h * (funcaoUtilizada.FuncaoExercicio(xValue[0]) + 3 * (funcaoUtilizada.FuncaoExercicio(xValue[1]) + funcaoUtilizada.FuncaoExercicio(xValue[2])) + funcaoUtilizada.FuncaoExercicio(xValue[3])) / 8;
            }
            else
            {
                solucao = 3 * h * (funcaoUtilizada.FuncaoExemplo(xValue[0]) + 3 * (funcaoUtilizada.FuncaoExemplo(xValue[1]) + funcaoUtilizada.FuncaoExemplo(xValue[2])) + funcaoUtilizada.FuncaoExemplo(xValue[3])) / 8;
            }
            sw.Stop();
            tempoSimp38 = sw.Elapsed;
            return solucao;
        }
        /// <summary>
        /// Funcao utilizada para calcular o exercicio 24.1 da página 566 Simpson
        /// </summary>
        /// <param name="ti">Temperatura Inicial</param>
        /// <param name="tf">Temperatura Final</param>
        /// <param name="inc">Incremento de temperatura</param>
        /// <param name="g">gramas de materia a ser elevados</param>
        /// <returns>double quantidade de calor Delta H</returns>
        public double CalculaSimp13mAV1_24_1(double ti, double tf, double inc, double g)
        {
            double soma = 0, solucao = 0;
            int n = 0;
            double valorCalculado = ti;
            double[] xValues = new double[10];

            while (valorCalculado <= tf)
            {
                xValues[n] = valorCalculado;
                valorCalculado += inc;
                n++;
            }
            --n;

            double h = CalculaH(tf, ti, n);

            funcaoUtilizada = new ExemploFuncoes();
            soma = funcaoUtilizada.FuncaoExercicioAv1_24_1(xValues[0], g);

            for (int i = 1; i < n - 2; i += 2)
            {
                soma = soma + 4 * funcaoUtilizada.FuncaoExercicioAv1_24_1(xValues[i], g) + 2 * funcaoUtilizada.FuncaoExercicioAv1_24_1(xValues[i + 1], g);

            }

            soma = soma + 4 * funcaoUtilizada.FuncaoExercicioAv1_24_1(xValues[n - 1], g) + funcaoUtilizada.FuncaoExercicioAv1_24_1(xValues[n], g);

            solucao = h * soma / 3;

            return solucao;
        }
        /// <summary>
        /// Calcula a regra multipla de simpson 1/3
        /// </summary>
        /// <param name="h">media da altura entre os pontos a e b</param>
        /// <param name="n">numero de segmentos</param>
        /// <param name="exercicio">seleção de funcao de exemplo ou exercicio</param>
        /// <returns>double</returns>
        public double CalculaSimp13m(double h, int n, bool exercicio)
        {
            double soma = 0, solucao = 0;
            double[] xValues = new double[n+1];
            funcaoUtilizada = new ExemploFuncoes();

            xValues[0] = 0;
            for(int i = 1; i < xValues.Length; i++)
            {
                xValues[i] = Math.Round(h * i, 2);
            }

            funcaoUtilizada = new ExemploFuncoes();

            //adicao de selecao de exemplo ou exercicio
            if (exercicio)
            {
                soma = funcaoUtilizada.FuncaoExercicio(0);

                for (int i = 1; i < n - 2; i += 2)
                {
                    soma = soma + 4 * funcaoUtilizada.FuncaoExercicio(xValues[i]) + 2 * funcaoUtilizada.FuncaoExercicio(xValues[i + 1]);

                }

                soma = soma + 4 * funcaoUtilizada.FuncaoExercicio(xValues[n - 1]) + funcaoUtilizada.FuncaoExercicio(xValues[n]);

                solucao = h * soma / 3;
            }
            else
            {
                soma = funcaoUtilizada.FuncaoExemplo(0);

                for (int i = 1; i < n - 2; i += 2)
                {
                    soma = soma + 4 * funcaoUtilizada.FuncaoExemplo(xValues[i]) + 2 * funcaoUtilizada.FuncaoExemplo(xValues[i + 1]);

                }

                soma = soma + 4 * funcaoUtilizada.FuncaoExemplo(xValues[n - 1]) + funcaoUtilizada.FuncaoExemplo(xValues[n]);

                solucao = h * soma / 3;
            }

            return solucao;
        }
        /// <summary>
        /// Calcula a regra multipla de simpson 1/3 utilizando os limites e selecionando entre exemplo ou exercicio
        /// </summary>
        /// <param name="a">limite inferior</param>
        /// <param name="b">limite superior</param>
        /// <param name="n">numero de segmentos</param>
        /// <param name="exercicio">seleção de funcao de exemplo ou exercicio</param>
        /// <returns>double</returns>
        public double CalculaSimp13m(double a, double b, int n, bool exercicio)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            double soma = 0, solucao = 0;
            double[] xValues = new double[n + 1];
            double h = CalculaH(b, a, n);
            funcaoUtilizada = new ExemploFuncoes();

            xValues[0] = 0;
            for (int i = 1; i < xValues.Length; i++)
            {
                xValues[i] = Math.Round(h * i, 2);
            }

            funcaoUtilizada = new ExemploFuncoes();

            //adicao de selecao de exemplo ou exercicio
            if (exercicio)
            {
                soma = funcaoUtilizada.FuncaoExercicio(0);

                for (int i = 1; i < n - 2; i += 2)
                {
                    soma = soma + 4 * funcaoUtilizada.FuncaoExercicio(xValues[i]) + 2 * funcaoUtilizada.FuncaoExercicio(xValues[i + 1]);

                }

                soma = soma + 4 * funcaoUtilizada.FuncaoExercicio(xValues[n - 1]) + funcaoUtilizada.FuncaoExercicio(xValues[n]);

                solucao = h * soma / 3;
            }
            else
            {
                soma = funcaoUtilizada.FuncaoExemplo(0);

                for (int i = 1; i < n - 2; i += 2)
                {
                    soma = soma + 4 * funcaoUtilizada.FuncaoExemplo(xValues[i]) + 2 * funcaoUtilizada.FuncaoExemplo(xValues[i + 1]);

                }

                soma = soma + 4 * funcaoUtilizada.FuncaoExemplo(xValues[n - 1]) + funcaoUtilizada.FuncaoExemplo(xValues[n]);

                solucao = h * soma / 3;
            }

            sw.Stop();
            tempoSimp13m = sw.Elapsed;

            return solucao;
        }