///<summary> Minimize the given cost function </summary>
public override DoubleVector Search(DoubleVector x, DoubleVector d, double stp)
{
DoubleVector ret = new DoubleVector(x);
double j = 0;
double delta_d = d.GetDotProduct(d);
double alpha;
do
{
alpha = -GradientEvaluation(ret).GetDotProduct(d) /
d.GetDotProduct(HessianEvaluation(ret) * d);
ret = ret + alpha * d;
j++;
} while ((j < maxIteration) && (alpha * alpha * delta_d > tolerance * tolerance));
return ret;
}
///<summary> Minimize the given cost function </summary>
public override DoubleVector Search(DoubleVector x, DoubleVector d, double step)
{
DoubleVector ret = new DoubleVector(x);
double j=0;
double eta;
double delta_d = d.GetDotProduct(d);
double alpha = -sigma_0;
double eta_prev = d.GetDotProduct(GradientEvaluation(ret+sigma_0*d));
do
{
eta = d.GetDotProduct(GradientEvaluation(ret));
alpha = alpha*(eta/(eta_prev-eta));
ret = ret + alpha*d;
eta_prev = eta;
j++;
} while ((j<maxIteration) && (alpha*alpha*delta_d > tolerance*tolerance));
return ret;
}
///<summary> Initialize the optimization method </summary>
///<remarks> The use of this function is intended for testing/debugging purposes only </remarks>
public override void InitializeMethod(DoubleVector initialvector)
{
g = GradientEvaluation(initialvector);
// Calculate Diagonal preconditioner
DoubleMatrix h = HessianEvaluation(initialvector);
DoubleMatrix m_inv = new DoubleMatrix(initialvector.Length,initialvector.Length);
for (int i=0; i<initialvector.Length; i++)
m_inv[i,i] = 1/h[i,i];
s = m_inv*g;
DoubleVector d = -s;
delta_new = g.GetDotProduct(d);
restartCounter=0;
/* ------------------------------ */
this.iterationVectors_ = new DoubleVector[endCriteria_.maxIteration+1];
this.iterationVectors_[0] = initialvector;
this.iterationValues_ = new double[endCriteria_.maxIteration+1];
this.iterationValues_[0] = FunctionEvaluation(this.iterationVectors_[0]);
this.iterationGradients_ = new DoubleVector[endCriteria_.maxIteration+1];
this.iterationGradients_[0] = new DoubleVector(g);
this.iterationGradientNorms_ = new double[endCriteria_.maxIteration+1];
this.iterationGradientNorms_[0] = g.GetNorm();
this.iterationDirections_ = new DoubleVector[endCriteria_.maxIteration+1];
this.iterationDirections_[0] = d;
this.iterationTrialSteps_ = new double[endCriteria_.maxIteration+1];
this.iterationTrialSteps_[0] = 1/this.iterationGradientNorms_[0];
}
///<summary> Perform a single iteration of the optimization method </summary>
///<remarks> The use of this function is intended for testing/debugging purposes only </remarks>
public override void IterateMethod()
{
DoubleVector d = this.iterationDirections_[endCriteria_.iterationCounter-1];
DoubleVector x = this.iterationVectors_[endCriteria_.iterationCounter-1];
DoubleVector g = this.iterationGradients_[endCriteria_.iterationCounter-1];
double stp = this.iterationTrialSteps_[endCriteria_.iterationCounter-1];
// Shanno-Phua's Formula for Trial Step
if (restartCounter==0 && endCriteria_.iterationCounter>1)
{
double dg = d.GetDotProduct(g);
double dg0 = this.iterationDirections_[endCriteria_.iterationCounter-2].GetDotProduct(
this.iterationGradients_[endCriteria_.iterationCounter-2])/stp;
stp = dg0/dg;
}
delta_mid = g.GetDotProduct(g);
// Conduct line search
x = lineSearchMethod_.Search(x,d,stp);
g = GradientEvaluation(x);
delta_old = delta_new;
delta_mid = g.GetDotProduct(s);
// Calculate Diagonal preconditioner
DoubleMatrix h = HessianEvaluation(x);
DoubleMatrix m_inv = new DoubleMatrix(x.Length,x.Length);
for (int i=0; i<x.Length; i++)
m_inv[i,i] = 1/h[i,i];
s = m_inv*g;
// Calculate Beta
delta_new = g.GetDotProduct(s);
double beta = (delta_new-delta_mid)/delta_old;
// Check for restart conditions
restartCounter++;
if (restartCounter==restartCount || (restartCounter==x.Length && restartCount==0) || beta<=0)
{
restartCount = 0;
beta=0;
}
// Calculate next line search direction
d = -s + beta*d;
this.iterationVectors_[endCriteria_.iterationCounter] = x;
this.iterationValues_[endCriteria_.iterationCounter] = FunctionEvaluation(x);
this.iterationGradients_[endCriteria_.iterationCounter] = g;
this.iterationGradientNorms_[endCriteria_.iterationCounter] = g.GetNorm();
this.iterationDirections_[endCriteria_.iterationCounter] = d;
this.iterationTrialSteps_[endCriteria_.iterationCounter] = stp;
}
public void GetDotProduct()
{
DoubleVector a = new DoubleVector(new double[4]{0,1,2,3});
DoubleVector b = new DoubleVector(new double[4]{4,5,6,7});
Assert.AreEqual(a.GetDotProduct(),14);
Assert.AreEqual(b.GetDotProduct(),126);
Assert.AreEqual(a.GetDotProduct(b),38);
Assert.AreEqual(a.GetDotProduct(b),b.GetDotProduct(a));
}
