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