Exemplo n.º 1
0
        public static double[] Calcular(int n, string fx, double e, string x_ini)
        {
            double[] xk   = x_ini.SplitToDoubles();
            double[] grad = Gradiente.CalculaGradiente(n, fx, x_ini.SplitToDoubles()).ToArray();
            double[] gk   = (double[])grad.Clone();
            double[] gk_1;
            double[] dk = gk.Negativo();
            double   beta;

            while (Interpretadores.NormaVetor(grad) > e)
            {
                for (int i = 0; i < n; i++)
                {
                    string xk_s = Interpretadores.GeraVetorY(xk, Interpretadores.LambdaVDirec(dk));
                    double lamb = Newton.Calcular(0, ((Interpretadores.GeraFy(fx, xk_s)).Replace(',', '.')).Replace("lamb", "x[1]"), 0.1);

                    xk   = Interpretadores.SubsLambda(lamb, xk_s.Replace(',', '.'));
                    gk_1 = Gradiente.CalculaGradiente(n, fx, xk).ToArray();
                    if (i >= n - 1)
                    {
                        break;
                    }
                    beta = GradConjugado.MultEscalar(gk_1, gk_1) / GradConjugado.MultEscalar(gk, gk);
                    dk   = Interpretadores.SomaVetor(gk_1.Negativo(), dk.MultConstante(beta));
                    gk   = (double[])gk_1.Clone();
                }
                grad = Gradiente.CalculaGradiente(n, fx, xk).ToArray();
            }
            return(xk);
        }
Exemplo n.º 2
0
        public static double[] Calcular(int n, string fx, double e, string x_ini)
        {
            double[] x0 = x_ini.SplitToDoubles();
            double[] xk;
            double[] gk = (double[])Gradiente.CalculaGradiente(n, fx, x0).ToArray().Clone();
            double[] gk_1;
            double[] dk;
            double[] qk;
            double[] pk;
            double[] xi;
            double   lambdak;

            double[,] Sk = MatrizSimetricaPositivaDefinida(n);
            int k, i;

            k = i = 0;
volta:
            xk = (double[])x0.Clone();
            while (Interpretadores.NormaVetor(gk) > e)
            {
                dk = GradConjugado.MultMatriz(Sk, gk.ToMatriz()).ToVector().Negativo();

                string vy = Interpretadores.GeraVetorY(xk, Interpretadores.LambdaVDirec(dk));
                string fy = Interpretadores.GeraFy(fx, vy.Replace(',', '.')).Replace("lamb", "x[1]");
                lambdak = Newton.Calcular(3, fy, 0.1);

                xk = Interpretadores.SubsLambda(lambdak, vy.Replace(',', '.'));

                if (k < n - 1)
                {
                    gk_1 = Gradiente.CalculaGradiente(n, fx, xk).ToArray();

                    qk = Interpretadores.SubtracaoVetor(gk_1, gk);

                    pk = dk.MultConstante(lambdak);


                    var parte1 = GradConjugado.MultMatriz(pk.ToMatriz(), pk.TranspVetor()).DivideConstante(GradConjugado.MultEscalar(pk, qk));
                    var parte2 = GradConjugado.MultMatriz(GradConjugado.MultMatriz(GradConjugado.MultMatriz(Sk, qk.ToMatriz()), qk.TranspVetor()), Sk).DivideConstante(GradConjugado.MultEscalar((GradConjugado.MultMatriz(qk.TranspVetor(), Sk)).ToVector(), qk));

                    Sk = SubtracaoMatriz(SomaMatriz(Sk, parte1), parte2);

                    k += 1;
                    gk = (double[])gk_1.Clone();
                }
                else
                {
                    xi = (double[])xk.Clone();
                    i += 1;
                    x0 = (double[])xk.Clone();
                    gk = Gradiente.CalculaGradiente(n, fx, x0).ToArray();
                    k  = 0;
                    goto volta;
                }
            }
            return(xk);
        }
Exemplo n.º 3
0
        public static double[] Calcular(string func, double[] xk, double erro, int n)
        {
            int    k = 0;
            double lambda, norma = 1000;

            double[] d, yk, vetNorma, x;
            vetNorma = new double[n];
            d        = new double[n];
            yk       = new double[n];
            string lambdaD, vetYj, Fy;

            do
            {
                k++;
                x  = (double[])xk.Clone();
                yk = (double[])xk.Clone();
                for (int j = 0; j < n; j++)
                {
                    /*Monta o vetor d*/
                    for (int b = 0; b < n; b++)
                    {
                        d[b] = 0;
                    }
                    d[j] = 1;
                    /**/
                    //multiplica lambda por d
                    lambdaD = Interpretadores.LambdaVDirec(d);
                    //vetor lambda*d + vetor yk
                    vetYj = Interpretadores.GeraVetorY(yk, lambdaD);
                    //substitui lambda por x nos lugares corretos -> Fy só com lambda de variável
                    Fy = Interpretadores.GeraFy(func, vetYj.Replace(',', '.'));
                    //Newton para calcular o valor de lambda
                    lambda = Newton.Calcular(0, (Fy.Replace("lamb", "x[1]")).Replace(',', '.'), 0.1);
                    //substitui o valor de lambda na função Fy -> gera vetor xk novo
                    yk = Interpretadores.SubsLambda(lambda, vetYj.Replace(',', '.'));
                }
                xk       = (double[])yk.Clone();
                vetNorma = Interpretadores.SubtracaoVetor(xk, x);
                //resultado da norma
                norma = Interpretadores.NormaVetor(vetNorma);
            } while (norma > erro);
            return(xk);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Minimiza F(x) utilizando o método do Gradiente.
        /// </summary>
        /// <param name="n">Número de variáveis.</param>
        /// <param name="fx">Função a ser minimizada.</param>
        /// <param name="e">Erro.</param>
        /// <param name="x_ini">X inicial.</param>
        /// <returns>Retorna o X ótimo.</returns>
        public static double[] Calcular(int n, string fx, double e, string x_ini)
        {
            int k = 0;

            double[] x         = Interpretadores.SplitToDoubles(x_ini);
            double[] gradiente = CalculaGradiente(n, fx, x).ToArray();
            double[] d         = new double[n];
            while (Math.Abs(Interpretadores.NormaVetor(gradiente)) >= e)
            {
                for (int i = 0; i < gradiente.Length; i++)
                {
                    d[i] = -gradiente[i];
                }
                string yj     = Interpretadores.GeraVetorY(x, Interpretadores.LambdaVDirec(d));
                string f      = Interpretadores.GeraFy(fx, yj);
                var    lambda = Newton.Calcular(0, (f.Replace("lamb", "x[1]")).Replace(',', '.'), 0.1);
                x         = Interpretadores.SubsLambda(lambda, yj.Replace(',', '.'));
                gradiente = CalculaGradiente(n, fx, x).ToArray();
                k        += 1;
            }

            return(x);
        }