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);
}
public static double[] Calcular(int n, string fx, double e, string x_ini)
{
double[] xk = Interpretadores.SplitToDoubles(x_ini);
double[] x = new double[n];
for (int i = 0; i < x.Length; i++)
{
x[i] = double.MaxValue;
}
double[] Grad = Gradiente.CalculaGradiente(n, fx, xk).ToArray();
double[] W;
double[,] Hess;
while (Math.Abs(Interpretadores.NormaVetor(Grad)) >= e)
{
Hess = Hessiano(n, fx, xk);
for (int i = 0; i < Grad.Length; i++)
{
Grad[i] = -Grad[i];
}
W = MétodosSistemasLineares.SistemaLinearTriangularSuperior(n, Hess, Grad);
for (int i = 0; i < xk.Length; i++)
{
x[i] = xk[i];
}
xk = Interpretadores.SomaVetor(xk, W);
if (Interpretadores.NormaVetor(Interpretadores.SubtracaoVetor(xk, x)) <= e)
{
break;
}
Grad = Gradiente.CalculaGradiente(n, fx, xk).ToArray();
}
return(xk);
}
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);
}
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);
}
/// <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);
}
public static double[] Calcular(int n, double e, string fx, string x_ini)
{
var aux = Interpretadores.SplitToDoubles(x_ini);
double[,] xk = new double[n, 1];
double[] xk_1 = (double[])xk.ToVector().Clone();
double[] gk = new double[n];
double[] gk_1 = new double[n];
double[] dk = new double[n];
double[] dk_1 = new double[n];
double[,] Hess;
double lambda, beta;
//Passa x_ini para matriz para poder multiplicar
for (int i = 0; i < xk.GetLength(0); i++)
{
xk[i, 0] = aux[i];
}
//g0
Passo1:
gk = Gradiente.CalculaGradiente(n, fx, xk.ToVector()).ToArray();
gk_1 = (double[])gk.Clone();
for (int i = 0; i < gk.Length; i++)
{
dk[i] = -gk[i];
}
for (int k = 0; k < n; k++)
{
Hess = NewtonMulti.Hessiano(2, fx, xk.ToVector());
double[,] dk_transp = dk.TranspVetor();
double[,] dk_Hess = MultMatriz(dk_transp, Hess);
double[] dk_H_assist = dk_Hess.ToVector();
lambda = -(MultEscalar(gk, dk) / MultEscalar(dk_H_assist, dk));
xk_1 = Interpretadores.SomaVetor(xk.ToVector(), dk.MultConstante(lambda));
gk_1 = Gradiente.CalculaGradiente(n, fx, xk_1).ToArray();
if (k == n - 1)
{
if (Interpretadores.NormaVetor(gk_1) <= e)
{
break;
}
else
{
for (int i = 0; i < xk.Length; i++)
{
xk[i, 0] = xk_1[i];
}
goto Passo1;
}
}
beta = MultEscalar(MultMatriz(gk_1.TranspVetor(), Hess).ToVector(), dk) / MultEscalar(dk_H_assist, dk);
dk_1 = Interpretadores.SomaVetor(gk_1.Negativo(), dk.MultConstante(beta));
dk = (double[])dk_1.Clone();
gk = (double[])gk_1.Clone();
for (int i = 0; i < xk.Length; i++)
{
xk[i, 0] = xk_1[i];
}
}
return(xk_1);
}