/// <summary>Line search algorithm</summary>
/// <param name="f">Function to be searched</param>
/// <param name="x">Current point</param>
/// <param name="deltaX">Search direction</param>
/// <param name="gradF">Gradient of F</param>
/// <param name="temp">Temporary vector to store current direction</param>
/// <param name="HessF">Hessian of F</param>
private static void BackTrack(C2Function f, floatLinalg.floatVector x, floatLinalg.floatVector deltaX,
floatLinalg.floatVector gradF, ref floatLinalg.floatVector temp, ref floatLinalg.floatSymPosDefMatrix HessF)
{
float t = 1;
float alphagradFdeltaX = floatLinalg.BLAS.Dot(gradF, deltaX, ref temp) * Config.alpha;
floatLinalg.floatVector dum = null;
float valF = f(x, false, ref dum, ref HessF);
//temp holds f(x+t*deltax)
floatLinalg.BLAS.LinearCombination(1, x, t, deltaX, ref temp);
float valFupdt = f(temp, false, ref dum, ref HessF);
while ((t > 0) && (float.IsNaN(valFupdt) || valFupdt > valF + t * alphagradFdeltaX))
{
floatLinalg.BLAS.LinearCombination(1, x, t, deltaX, ref temp);
valFupdt = f(temp, false, ref dum, ref HessF);
t *= Config.beta;
}
if (t > 0)
{
//Consolidates deltaX
floatLinalg.BLAS.LinearCombination(1, temp, -1, x, ref deltaX);
//Updates x
floatLinalg.BLAS.CopyVector(temp, x);
}
}
/// <summary>Computes the unconstrained minimum of function F in x0.Length dimensions</summary>
/// <param name="CLx">Solution x and initial guess</param>
/// <param name="F">Function to be minimized</param>
/// <param name="iters">Number of iterations</param>
/// <param name="HessF">Holder of hessian of F</param>
/// <param name="gradF">Holder of gradient of F</param>
/// <param name="temp">Temporary vector of dimension n</param>
/// <param name="deltaX">X search direction</param>
/// <param name="A">Equality constraint matrix</param>
/// <param name="b">Equality constraint rhs</param>
/// <param name="AinvHAt">Holder of A*inv(H)*A'</param>
/// <param name="tempAinvMatrix">Temporary matrix for computation of inv(H)*A'</param>
/// <param name="temp2">Temporary vector of length n</param>
/// <param name="AinvHrhs">Temporary vector</param>
/// <param name="rPri">Primal residual</param>
/// <param name="tempC">Temporary vector of length C</param>
/// <param name="CLDeltaNu">Search direction in Nu</param>
/// <param name="Atnu">A times nu</param>
/// <param name="onesC">Vector of ones of dimension C</param>
public static float[] Solve(floatLinalg.floatVector CLx, C2Function F, out int iters,
floatLinalg.floatSymPosDefMatrix HessF, floatLinalg.floatVector gradF, floatLinalg.floatVector temp, floatLinalg.floatVector deltaX,
floatLinalg.floatMatrix A, floatLinalg.floatVector b, floatLinalg.floatSymPosDefMatrix AinvHAt, floatLinalg.floatMatrix tempAinvMatrix,
floatLinalg.floatVector temp2, floatLinalg.floatVector AinvHrhs, floatLinalg.floatVector rPri, floatLinalg.floatVector tempC, floatLinalg.floatVector CLDeltaNu,
floatLinalg.floatVector Atnu, floatLinalg.floatVector onesC)
{
float lambda = 1E30f; //, lambdaPrev = 2E30f;
iters = 0;
while (lambda > Config.eps && iters < Config.MaxIterations)
{
//Computes gradient and hessian
F(CLx, true, ref gradF, ref HessF);
HessF.IsCholeskyFactorized = false;
//Search direction is minus gradient
floatLinalg.BLAS.LinearCombination(0, CLx, -1, gradF, ref temp);
if (A == null)
{
//Finds Newton step without equality constraints
deltaX = HessF.LinearSolve(temp, false, ref deltaX);
//HessF.CLcholDec.ReadFromDeviceTo(HessF.cholDec);
//HessF.Write("C:\\oct\\PP.txt");
//temp.Write("C:\\oct\\q.txt");
//deltaX.ReadFromDevice();
}
else
{
//Solves KKT system [Hpd A'; A 0] = [temp; rPri]. Remember that rPri was computed as -Ax+b
//primal residual, -rPri
floatLinalg.BLAS.MatrVecProdSumVec(A, CLx, -1, b, 1, ref rPri);
//A inv(H) A'
floatLinalg.BLAS.ComputeAinvHTranspA(A, HessF, ref AinvHAt, ref tempAinvMatrix, false);
//A inv(H) temp
HessF.LinearSolve(temp, false, ref temp2);
floatLinalg.BLAS.MatrVecProd(A, temp2, 1, ref AinvHrhs);
//Ainv(H)temp - rpri
floatLinalg.BLAS.LinearCombination(1, AinvHrhs, -1, rPri, ref tempC);
//Solves for deltaNu
AinvHAt.LinearSolve(tempC, false, ref CLDeltaNu);
//Procceeds to deltaX = invH * (deltaX - AtDeltanu)
floatLinalg.BLAS.MatrTraspVecMult(A, new floatLinalg.floatDiag(onesC), CLDeltaNu, ref Atnu);
floatLinalg.BLAS.LinearCombination(-1, Atnu, 1, temp, ref temp2);
HessF.LinearSolve(temp2, false, ref deltaX);
}
//Finds step that leads to decrement
BackTrack(F, CLx, deltaX, gradF, ref temp, ref HessF);
////////DEBUG
//if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL)
//{
// HessF.CLValues.ReadFromDeviceTo(HessF.Values);
// HessF.CLcholDec.ReadFromDeviceTo(HessF.cholDec);
//}
////CLx.CLValues.ReadFromDeviceTo(CLx.Values);
////deltaX.CLValues.ReadFromDeviceTo(deltaX.Values);
//gradF.ReadFromDevice();
//deltaX.ReadFromDevice();
//CLx.ReadFromDevice();
lambda = (float)Math.Sqrt(-floatLinalg.BLAS.Dot(gradF, deltaX, ref temp));
iters++;
}
if (CLCalc.CLAcceleration == CLCalc.CLAccelerationType.UsingCL) CLx.CLValues.ReadFromDeviceTo(CLx.Values);
return CLx.Values;
}
/// <summary>Computes the unconstrained minimum of function F in x0.Length dimensions subject to equality constraint Ax=b</summary>
/// <param name="x0">Start point. Problem dimension is assumed to be x0.Length</param>
/// <param name="F">Function to minimize</param>
/// <param name="A">Equality constraint matrix</param>
/// <param name="b">Equality constraint rhs</param>
/// <param name="iters">Number of iterations used to solve the problem</param>
public static float[] Solve(float[] x0, C2Function F, float[,] A, float[] b, out int iters)
{
floatLinalg.floatVector CLx = new floatLinalg.floatVector(x0);
//Creates Hessian and Gradient
floatLinalg.floatSymPosDefMatrix HessF = new floatLinalg.floatSymPosDefMatrix(x0.Length);
floatLinalg.floatVector gradF = new floatLinalg.floatVector(x0);
//Line search variables
floatLinalg.floatVector temp = new floatLinalg.floatVector(x0);
floatLinalg.floatVector deltaX = new floatLinalg.floatVector(x0);
//Equality constraint vars
if (A != null)
{
int c = A.GetLength(0);
int n = x0.Length;
floatLinalg.floatMatrix CLA = new floatLinalg.floatMatrix(A);
floatLinalg.floatVector CLb = new floatLinalg.floatVector(b);
floatLinalg.floatVector CLDeltaNu = new floatLinalg.floatVector(b);
floatLinalg.floatVector rPri = new floatLinalg.floatVector(new float[c]);
floatLinalg.floatVector Atnu = new floatLinalg.floatVector(new float[n]);
floatLinalg.floatVector tempC = new floatLinalg.floatVector(new float[c]);
floatLinalg.floatVector temp2 = new floatLinalg.floatVector(x0);
floatLinalg.floatSymPosDefMatrix AinvHAt = new floatLinalg.floatSymPosDefMatrix(c);
floatLinalg.floatVector AinvHrhs = new floatLinalg.floatVector(new float[c]);
floatLinalg.floatMatrix tempAinvMatrix = new floatLinalg.floatMatrix(new float[n, c]);
float[] fOnes = new float[c];
for (int i = 0; i < fOnes.Length; i++) fOnes[i] = 1;
floatLinalg.floatVector onesC = new floatLinalg.floatVector(fOnes);
return Solve(CLx, F, out iters, HessF, gradF, temp, deltaX, CLA, CLb, AinvHAt, tempAinvMatrix, temp2, AinvHrhs, rPri, tempC, CLDeltaNu, Atnu, onesC);
}
else return Solve(CLx, F, out iters, HessF, gradF, temp, deltaX, null, null, null, null, null, null, null, null, null, null, null);
}
/// <summary>Computes the unconstrained minimum of function F in x0.Length dimensions</summary>
/// <param name="CLx">Solution x and initial guess</param>
/// <param name="F">Function to be minimized</param>
/// <param name="iters">Number of iterations</param>
/// <param name="HessF">Holder of hessian of F</param>
/// <param name="gradF">Holder of gradient of F</param>
/// <param name="temp">Temporary vector of dimension n</param>
/// <param name="deltaX">X search direction</param>
public static float[] Solve(floatLinalg.floatVector CLx, C2Function F, out int iters,
floatLinalg.floatSymPosDefMatrix HessF, floatLinalg.floatVector gradF, floatLinalg.floatVector temp, floatLinalg.floatVector deltaX)
{
return Solve(CLx, F, out iters, HessF, gradF, temp, deltaX, null, null, null, null, null, null, null, null, null, null, null);
}
/// <summary>Computes the unconstrained minimum of function F in x0.Length dimensions</summary>
/// <param name="x0">Start point. Problem dimension is assumed to be x0.Length</param>
/// <param name="F">Function to minimize</param>
/// <param name="iters">Number of iterations used to solve the problem</param>
public static float[] Solve(float[] x0, C2Function F, out int iters)
{
floatLinalg.floatVector CLx = new floatLinalg.floatVector(x0);
//Creates Hessian and Gradient
floatLinalg.floatSymPosDefMatrix HessF = new floatLinalg.floatSymPosDefMatrix(x0.Length);
floatLinalg.floatVector gradF = new floatLinalg.floatVector(x0);
//Line search variables
floatLinalg.floatVector temp = new floatLinalg.floatVector(x0);
floatLinalg.floatVector deltaX = new floatLinalg.floatVector(x0);
return Solve(CLx, F, out iters, HessF, gradF, temp, deltaX);
}
