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(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);
}
