private double TermoIntegral(double x,double media,double desvioPadrao)
        {
            double precisaoRequerida = 1e-10;
                int numeroDeIntervalosAutoQuad = 10;
                double limiteInferiorAutoQuad = 0.000001;
                double limiteSuperiorAutoQuad = x;
                AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

                Integral.Funcao funcaoInicialVezesPolinomio = delegate(double u)
                {
                    var xg = media/Math.Exp(0.5*Math.Log(desvioPadrao)*Math.Log(desvioPadrao));

                    return (1/(u*Math.Log(desvioPadrao)*Math.Pow(2*Math.PI,0.5)))*Math.Exp(-Math.Log(u/xg)/(2*Math.Log(desvioPadrao)*Math.Log(desvioPadrao)));
                };

                double valorAutoquad;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                if (!autoQuad.Calcular(funcaoInicialVezesPolinomio, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    Trace.WriteLine("Precisão não foi atingida na AutoQuad. Precisão atingida = "+precisaoAutoquad+" Precisão requerida = "+precisaoRequerida);

                return valorAutoquad;
        }
        private double TermoIntegral(double x,double media,double desvioPadrao)
        {
            double precisaoRequerida = 1e-10;
                int numeroDeIntervalosAutoQuad = 10;
                double limiteInferiorAutoQuad = 0.0;
                double limiteSuperiorAutoQuad = x;
                AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

                Integral.Funcao funcaoInicialVezesPolinomio = delegate(double u)
                {
                    return Math.Exp(-Math.Pow((u - media), 2)/(2*Math.Pow(desvioPadrao, 2)));
                };

                double valorAutoquad;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                if (!autoQuad.Calcular(funcaoInicialVezesPolinomio, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    throw new Exception("Precisão não foi atingida na AutoQuad");

                return valorAutoquad;
        }
        public FuncaoHidrocraqueamento(int numeroDePontos, double media, double desvioPadrao)
        {
            autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 15);
            funcaoIntegracaoE = FuncaoPkKVezesPolinomio;
            funcaoDeMomento = FuncaoVezesPolinomio;

            this.numeroDePontos = numeroDePontos;
            this.desvioPadrao = desvioPadrao;
            this.media = media;

            CalcularPesosEAbscissas();
        }
Exemplo n.º 4
0
        public FixedPoint(int N,double limiteInferior,double limiteSuperior,
            Integral.Funcao bf, Integral.Funcao an, FuncaoDupla fp,
            Integral.Funcao D, Integral.Funcao funcaoInicial)
        {
            autoQuad = new AutoQuad(10, limiteInferior, limiteSuperior, precisaoRequerida, 10);
            this.funcaoInicial = funcaoInicial;
            this.an = an;
            this.bf = bf;
            this.fp = fp;
            this.D = D;
            this.N = N;

            x0 = limiteInferior;
            xf = limiteSuperior;
        }
Exemplo n.º 5
0
        private double FatorDeNormalizacao()
        {
            double valorAutoquad;
            double valorComPrecisaoAutoquad;
            double precisaoAutoquad;

            double precisaoRequerida = 1e-13;

            AutoQuad autoQuad = new AutoQuad(10, Mmin, Mmax, precisaoRequerida, 10);

            if (
                !autoQuad.Calcular(FuncaoGamma, out valorAutoquad, out valorComPrecisaoAutoquad,
                    out precisaoAutoquad))
                throw new Exception("Erro no cálculo da AutoQuad");

            if (precisaoAutoquad > precisaoRequerida)
                throw new Exception("Precisão não foi atingida na AutoQuad");

            return valorAutoquad;
        }
Exemplo n.º 6
0
        private List<double[]> CalcularMomentosAnaliticosNumericosCSTREspecieA(MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, int numeroDePontos, int numeroDePassosDeTempo, double passoDeTempo)
        {
            List<double[]> momentosAnaliticos = new List<double[]>(numeroDePassosDeTempo);

            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                var t = i;

                double[] momentos = new double[numeroDePontos];

                for (int j = 0; j < momentos.Length; j++)
                {
                    var k = j;

                    Integral.Funcao funcaoDeMomento = delegate(double I)
                    {
                        Integral.Funcao funcaoBase = delegate
                        {
                            return ((q0 / V) * FuncaoCSTREspecieAEntrada(I) * (Math.Exp(tempo[t]) - 1) +
                                    FuncaoCSTREspecieAInicial(I) * (q / V + KI(I))) /
                                   ((q / V + KI(I)) * Math.Exp(tempo[t]));
                        };

                        return funcaoBase(I) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, I, k);
                    };

                    double valorAutoquad;
                    double valorComPrecisaoAutoquad;
                    double precisaoAutoquad;

                    if (!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                        throw new Exception("Erro no cálculo da AutoQuad");

                    if (precisaoAutoquad > precisaoRequerida)
                        throw new Exception("Precisão não foi atingida na AutoQuad");

                    momentos[j] = valorAutoquad;

                }

                momentosAnaliticos.Add(momentos);
            }
            return momentosAnaliticos;
        }
Exemplo n.º 7
0
        private List<double[]> CalcularMomentosAnaliticosMukhatar()
        {
            List<double[]> momentosAnaliticos = new List<double[]>();

            AutoQuad autoQuad = new AutoQuad(10, 0.0001, 1000.0, 1e-12, 10);
            autoQuad.LimiteInferior = 0.0001;
            autoQuad.LimiteSuperior = 1.0;

            for (double t = 0.0; t < numeroDePassosDeTempo; t=t+0.001)
            {
                double[] m0 = new double[2 * numeroDePontos];

                for (int i = 0; i < m0.Length; i++)
                {
                    var t1 = t;
                    Integral.Funcao funcaoDeMomento = x => FuncaoAnaliticaMukhtar(x,t1) * MomentosBase.Polinomio(MomentosBase.MetodoCoeficientesDosMomentos.Wheeler, x, i);

                    double valorAutoquad;
                    double valorComPrecisaoAutoquad;
                    double precisaoAutoquad;
                    if (
                        !autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
                            out precisaoAutoquad))
                        throw new Exception("Erro no cálculo da AutoQuad");

                    if (precisaoAutoquad > 1e-12)
                        Trace.WriteLine("Precisão não foi atingida na AutoQuad. Valor da precisao atingida = " + precisaoAutoquad);

                    m0[i] = valorAutoquad;
                }

                momentosAnaliticos.Add(m0);
            }

            return momentosAnaliticos;
        }
Exemplo n.º 8
0
        private List<double[]> CalcularMomentosAnaliticosHidrogenacao_ComMomentoZeroAnalitico()
        {
            List<double[]> momentosAnaliticos = new List<double[]>(numeroDePassosDeTempo);

            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;

                var t = i;

                double[] momentos = new double[numeroDePontos];

                for (int j = 0; j < momentos.Length; j++)
                {
                    if (j == 0)
                    {
                        momentos[j] = ObterMomentoZeroHidrogenacao_ComMomentoZeroAnalitico(tempo[i]);
                        continue;
                    }

                    var k = j;

                    Integral.Funcao funcaoDeMomento = delegate(double I)
                    {
                        Integral.Funcao funcaoBase = delegate
                        {
                            return FuncaoInicialDoMomentoZeroAnalitico(I) * Math.Exp(-I * tempo[t]);
                        };

                        return funcaoBase(I) * MomentosBase.Polinomio(MomentosBase.MetodoCoeficientesDosMomentos.Wheeler, I, k);
                    };

                    double valorAutoquad;
                    double valorComPrecisaoAutoquad;
                    double precisaoAutoquad;

                    if (!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                        throw new Exception("Erro no cálculo da AutoQuad");

                    if (precisaoAutoquad > precisaoRequerida)
                        MessageBox.Show("Precisão não foi atingida na AutoQuad");

                    momentos[j] = valorAutoquad;
                }

                momentosAnaliticos.Add(momentos);
            }
            return momentosAnaliticos;
        }
Exemplo n.º 9
0
        private List<double[]> CalcularMomentosAnaliticosEspecieBHidrogenacao()
        {
            List<double[]> momentosAnaliticos = new List<double[]>(numeroDePassosDeTempo);

            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;

                var t = i;

                double[] momentos = new double[numeroDePontos];

                for (int j = 0; j < momentos.Length; j++)
                {
                    var k = j;

                    Integral.Funcao funcaoDeMomento = delegate(double I)
                    {
                        Integral.Funcao funcaoBase = delegate
                        {
                            return FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem(I) * (1 - Math.Exp(-KI(I) * tempo[t]));
                        };

                        Integral.Funcao binomio = delegate
                        {
                            return Funcao.CalcularBinomioDeNewton(I, FuncaoDelta(I), k);
                        };

                        return funcaoBase(I) * binomio(I);
                    };

                    double valorAutoquad;
                    double valorComPrecisaoAutoquad;
                    double precisaoAutoquad;

                    if (!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                        throw new Exception("Erro no cálculo da AutoQuad");

                    if (precisaoAutoquad > precisaoRequerida)
                        MessageBox.Show("Precisão não foi atingida na AutoQuad");

                    //momentos[j] = Integral.CalcularIntegralImpropriaMidInf(funcaoDeMomento, limiteMinimo,
                    //   limiteMaximo, 10);

                    momentos[j] = valorAutoquad;

                }

                momentosAnaliticos.Add(momentos);

            }
            return momentosAnaliticos;
        }
Exemplo n.º 10
0
        private double CalcularIntegralFuncaoInicialVezesPolinomio(MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, int ordemDoPolinomio)
        {
            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

            Integral.Funcao funcaoInicialVezesPolinomio = delegate(double I)
            {
                return FuncaoCSTREspecieAInicial(I) *
                           MomentosBase.Polinomio(metodoCoeficientesDosMomentos, I, ordemDoPolinomio);
            };

            double valorAutoquad;
            double valorComPrecisaoAutoquad;
            double precisaoAutoquad;

            if (!autoQuad.Calcular(funcaoInicialVezesPolinomio, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                throw new Exception("Erro no cálculo da AutoQuad");

            if (precisaoAutoquad > precisaoRequerida)
                throw new Exception("Precisão não foi atingida na AutoQuad");

            return valorAutoquad;
        }
Exemplo n.º 11
0
        private double[] CalcularMomentosIniciaisMukkhatar()
        {
            double[] m0 = new double[2 * numeroDePontos];

            for (int i = 0; i < m0.Length; i++)
            {
                AutoQuad autoQuad = new AutoQuad(10, 0.0001, 1000.0, 1e-12, 10);

                autoQuad.LimiteInferior = 0.0001;
                autoQuad.LimiteSuperior = 1.0;

                Integral.Funcao funcaoDeMomento = x => FuncaoMukhtar(x) * MomentosBase.Polinomio(MomentosBase.MetodoCoeficientesDosMomentos.Wheeler, x, i);

                double valorAutoquad;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;
                if (
                    !autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
                        out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > 1e-12)
                    Trace.WriteLine("Precisão não foi atingida na AutoQuad. Valor da precisao atingida = " + precisaoAutoquad);

                m0[i] = valorAutoquad;
            }

            return m0;
        }
Exemplo n.º 12
0
        private List<double[]> CalcularMomentosAnaliticosEspecieAHidrogenacao(MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, int numeroDePassosDeTempo, double t0, double passoDeTempo,
           double limiteMaximo, double limiteMinimo, int numeroDePontos)
        {
            List<double[]> momentosAnaliticos = new List<double[]>(numeroDePassosDeTempo);

            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(15, 0.0, 100, precisaoRequerida, 10);

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;

                var t = i;

                double[] momentos = new double[numeroDePontos];

                for (int j = 0; j < momentos.Length; j++)
                {
                    var k = j;

                    Integral.Funcao funcaoDeMomento = delegate(double I)
                    {
                        Integral.Funcao funcaoBase = delegate
                        {
                            return FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem(I) * Math.Exp(-KI(I) * tempo[t]);
                        };

                        return funcaoBase(I) * MomentosBase.Polinomio(MomentosBase.MetodoCoeficientesDosMomentos.PDA, I, k);
                    };

                    double valorAutoquad = 0.0;
                    double valorComPrecisaoAutoquad;
                    double precisaoAutoquad;

                    if (!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                        throw new Exception("Erro no cálculo da AutoQuad");

                    if (precisaoAutoquad > precisaoRequerida)
                        MessageBox.Show("Precisão não foi atingida na AutoQuad");

                    //momentos[j] =valorAutoquad+ Integral.CalcularIntegralImpropriaMidInf(funcaoDeMomento, limiteMinimo,
                    //    limiteMaximo,
                    //    10);
                    momentos[j] = valorAutoquad;

                }

                momentosAnaliticos.Add(momentos);
            }
            return momentosAnaliticos;
        }
Exemplo n.º 13
0
        public void AtribuirCampos()
        {
            metodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;
            funcaoDeMomentoInicial = FuncaoDeMomentoInicial;
            autoQuad = new AutoQuad(10, 0.0, 1.0, precisaoRequerida, 10);

            numeroDePontos = 7;
            deltaN = 4;

            Lmin = 0.0;
            Lmax = 1.0;

            limiteInferiorDistribuicao = Lmin;
            limiteSuperiorDistribuicao = Lmax;

            //Parâmetros do Hidrocraqueamento

            //Valores dos parâmetros para T = 324 C

            alfa = 1.35;
            //kMax = 1.35; //1/hora;
            kMax = 1.35;
            a0 = 6.41;
            a1 = 28.15;
            delta = 2.6667e-05;

            //Valores dos parâmetros para T = 342 C

            //alfa = 0.40;
            //kMax = 8.08; //1/hora;
            //a0 = 6.00;
            //a1 = 3.80;
            //delta = 9.05e-07;

            //Valores dos parâmetros para T = 354 C

            //alfa = 0.314;
            //kMax = 32.08; //1/hora;
            //a0 = 5.82;
            //a1 = 3.60;
            //delta = 9.05e-07;

            funcaoEVezesPolinomio = FuncaoEVezesPolinomio;
        }
Exemplo n.º 14
0
        public void AtribuirCampos()
        {
            metodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;
            funcaoDeMomentoInicial = FuncaoDeMomentoInicial;
            autoQuad = new AutoQuad(10, 0.0, 1.0, precisaoRequerida, 10);
            autoQuadS0 = new AutoQuad2(10,0.0,1.0,precisaoRequerida,10);

            numeroDePontos = 5;
            deltaN = 2;

            numeroDePontosInicial = 5;
            deltaNInicial = 2;

            //Parâmetros da distribuição inicial
            x0 = 6.0;
            aP = 99.7373819939209;
            alfaGama = 2.11974361925893;
            beta = 8.60867323342265;

            Lmin = 6.0;
            Lmax = 69.5;

            limiteInferiorDistribuicao = Lmin;
            limiteSuperiorDistribuicao = Lmax;

            //Parâmetros do Hidrocraqueamento

            //Valores dos parâmetros para T = 324 C

            alfa = 0.5;

               // alfa = 0.35;
            kMax = 2.64; //1/hora;
            a0 = 8.14;
            a1 = 4.68;
            delta = 7.05e-07;

            //Valores dos parâmetros para T = 342 C

            //alfa = 0.40;
            //kMax = 8.08; //1/hora;
            //a0 = 6.00;
            //a1 = 3.80;
            //delta = 9.05e-07;

            //Valores dos parâmetros para T = 354 C

            //alfa = 0.314;
            //kMax = 32.08; //1/hora;
            //a0 = 5.82;
            //a1 = 3.60;
            //delta = 9.05e-07;

            funcaoEVezesPolinomio = FuncaoEVezesPolinomio;
        }
Exemplo n.º 15
0
        private double[] CalcularMomentosIniciaisMcCoy(int numeroDePontos, Integral.Funcao funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos)
        {
            double[] m0 = new double[numeroDePontos];

            for (int i = 0; i < m0.Length; i++)
            {
                var i1 = i;

                Integral.Funcao funcaoDeMomento =
                    x => funcaoInicial(x) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, x, i1);

                double valorAutoquad = 0.0;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                double precisaoRequerida = 1e-14;

                AutoQuad autoQuad = new AutoQuad(15, 125.0, 1200, precisaoRequerida, 15);

                if (
                    !autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
                        out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    MessageBox.Show("Precisão não foi atingida na AutoQuad");

                if (i == 1) fatorNormalizacao = valorAutoquad;

                m0[i] = valorAutoquad;
            }

            for (int i = 0; i < m0.Length; i++)
            {
                m0[i] = m0[i] / fatorNormalizacao;
            }

            return m0;
        }
Exemplo n.º 16
0
        private double[] CalcularMomentosIniciaisMcCoyCSTR(int numeroDePontos, Integral.Funcao funcaoInicial)
        {
            double[] m0 = new double[numeroDePontos];

            for (int i = 0; i < m0.Length; i++)
            {
                var i1 = i;

                Integral.Funcao funcaoDeMomento =
                    x => funcaoInicial(x) * MomentosBase.Polinomio(MomentosBase.MetodoCoeficientesDosMomentos.PDA, x, i1);

                double valorAutoquad = 0.0;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                double precisaoRequerida = 1e-10;

                AutoQuad autoQuad = new AutoQuad(10, 125.0, 10000, precisaoRequerida, 15);

                if (
                    !autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
                        out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    throw new Exception("Precisão não foi atingida na AutoQuad");

                m0[i] = valorAutoquad;
            }

            return m0;
        }
Exemplo n.º 17
0
        private double[] CalcularMomentosIniciais(Integral.Funcao funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos)
        {
            var fator = FatorDeNormalizacao();

            double[] m0 = new double[2 * m];

            for (int i = 0; i < m0.Length; i++)
            {
                var i1 = i;

                Integral.Funcao funcaoDeMomento =
                    x => funcaoInicial(x) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, x, i1);

                double valorAutoquad;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                double precisaoRequerida = 1e-13;

                AutoQuad autoQuad = new AutoQuad(10, Mmin, Mmax, precisaoRequerida, 10);

                if (
                    !autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
                        out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    throw new Exception("Precisão não foi atingida na AutoQuad");

                m0[i] = valorAutoquad/fator;
            }

            return m0;
        }
Exemplo n.º 18
0
        protected double[] CalcularMomentosIniciais(MetodoCoeficientesDosMomentos metodoCoeficientes)
        {
            double[] m0 = new double[numeroDePontos];

            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(15,125, 1000, precisaoRequerida, 10);

            autoQuad.LimiteInferior = 125;
            autoQuad.LimiteSuperior = 1000;

            for (int i = 0; i < m0.Length; i++)
            {
                var i1 = i;

                Integral.Funcao funcaoDeMomento = x => funcao(x) * Polinomio(metodoCoeficientes, x, i1);

                double valorAutoquad;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                if (!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    throw new Exception("Precisão não foi atingida na AutoQuad");

                m0[i] = valorAutoquad;

                //m0[i] = Integral.CalcularIntegralImpropriaMidInf(funcaoDeMomento, limiteMinimo, limiteMaximo, numeroMaximoDePontos);
            }

            return m0;
        }
Exemplo n.º 19
0
        private double IntegralDoPolinomioVezesFuncao(int ordemDoPolinomio)
        {
            double valorAutoquad;
            double valorComPrecisaoAutoquad;
            double precisaoAutoquad;

            double precisaoRequerida = 1e-13;

            Integral.Funcao funcao = delegate(double y)
            {
                return FuncaoGammaNormalizada(y)*AlgLib.LegendreCalculate(ordemDoPolinomio, 2*y - 1);
            };

            AutoQuad autoQuad = new AutoQuad(10, 0, 1, precisaoRequerida, 10);

            if (
                !autoQuad.Calcular(funcao, out valorAutoquad, out valorComPrecisaoAutoquad,
                    out precisaoAutoquad))
                throw new Exception("Erro no cálculo da AutoQuad");

            if (precisaoAutoquad > precisaoRequerida)
                throw new Exception("Precisão não foi atingida na AutoQuad");

            return (2*ordemDoPolinomio+1)*valorAutoquad;
        }