void testSPDMean(void)
{
// choose a random seed
unsigned tt = (unsigned)time(NULL);
tt = 0;
genrandseed(tt);
/*Randomly generate a point on the SPD manifold*/
integer n = 100, num = 4;
SPDVariable SPDX(n);
double *initialX = SPDX.ObtainWriteEntireData();
for (integer i = 0; i < n; i++)
{
for (integer j = 0; j < n; j++)
{
initialX[i + j * n] = 0;
}
initialX[i + i * n] = 1;
}
// Define the manifold
SPDManifold Domain(n);
Domain.SetHasHHR(true); /*set whether the manifold uses the idea in [HGA2015, Section 4.3] or not*/
double *Ls = new double[n * n * num + n * n];
double *tmp = Ls + n * n * num;
integer info;
for (integer i = 0; i < num; i++)
{
for (integer j = 0; j < n * n; j++)
tmp[j] = genrandnormal();
dgemm_(GLOBAL::N, GLOBAL::T, &n, &n, &n, &GLOBAL::DONE, tmp, &n, tmp, &n, &GLOBAL::DZERO, Ls + i * n * n, &n);
dpotrf_(GLOBAL::L, &n, Ls + i * n * n, &n, &info);
if (info != 0)
{
std::cout << "Warning: TestSPDMean Cholesky decomposition fails with info:" << info << "!" << std::endl;
}
for (integer j = 0; j < n; j++)
for (integer k = j + 1; k < n; k++)
Ls[j + k * n + i * n * n] = 0;
}
// Define the problem
SPDMean Prob(Ls, n, num);
/*The domain of the problem is a SPD manifold*/
Prob.SetDomain(&Domain);
//Prob.CheckGradHessian(&SPDX);
/*Output the parameters of the domain manifold*/
Domain.CheckParams();
/*Check the correctness of the manifold operations*/
//Domain.CheckIntrExtr(&SPDX);
//Domain.CheckRetraction(&SPDX);
//Domain.CheckDiffRetraction(&SPDX);
//Domain.CheckLockingCondition(&SPDX);
//Domain.CheckcoTangentVector(&SPDX);
//Domain.CheckIsometryofVectorTransport(&SPDX);
//Domain.CheckIsometryofInvVectorTransport(&SPDX);
//Domain.CheckVecTranComposeInverseVecTran(&SPDX);
//Domain.CheckTranHInvTran(&SPDX);
//Domain.CheckHaddScaledRank1OPE(&SPDX);
// test LRBFGS
std::cout << "********************************Test Geometric mean in LRBFGS*************************************" << std::endl;
LRBFGS *LRBFGSsolver = new LRBFGS(&Prob, &SPDX);
LRBFGSsolver->LineSearch_LS = ARMIJO;
LRBFGSsolver->Debug = ITERRESULT; //ITERRESULT;//
LRBFGSsolver->Max_Iteration = 20;
LRBFGSsolver->Tolerance = 1e-10;
LRBFGSsolver->Accuracy = 1e-4;
LRBFGSsolver->Finalstepsize = 1;
LRBFGSsolver->CheckParams();
LRBFGSsolver->Run();
delete LRBFGSsolver;
delete[] Ls;
};
void testEucQuadratic(double *M, integer dim, double *X, double *Xopt)
{
// choose a random seed
unsigned tt = (unsigned)time(NULL);
std::cout << "tt:" << tt << std::endl;
tt = 0;
init_genrand(tt);
// Obtain an initial iterate
EucVariable EucX(dim, 1);
if (X == nullptr)
{
EucX.RandInManifold();
}
else
{
double *EucXptr = EucX.ObtainWriteEntireData();
for (integer i = 0; i < dim; i++)
EucXptr[i] = X[i];
}
// Define the manifold
Euclidean Domain(dim);
// Define the problem
EucQuadratic Prob(M, dim);
Prob.SetDomain(&Domain);
// test RSD
std::cout << "********************************Check all line search algorithm in RSD*****************************************" << std::endl;
for (integer i = 0; i < LSALGOLENGTH; i++)
{
RSD *RSDsolver = new RSD(&Prob, &EucX);
RSDsolver->LineSearch_LS = static_cast<LSAlgo> (i);
RSDsolver->DEBUG = FINALRESULT;
RSDsolver->CheckParams();
RSDsolver->Run();
delete RSDsolver;
}
// test RNewton
std::cout << "********************************Check all line search algorithm in RNewton*************************************" << std::endl;
for (integer i = 0; i < LSALGOLENGTH; i++)
{
RNewton *RNewtonsolver = new RNewton(&Prob, &EucX);
RNewtonsolver->LineSearch_LS = static_cast<LSAlgo> (i);
RNewtonsolver->DEBUG = FINALRESULT;
RNewtonsolver->CheckParams();
RNewtonsolver->Run();
delete RNewtonsolver;
}
// test RCG
std::cout << "********************************Check all Formulas in RCG*************************************" << std::endl;
for (integer i = 0; i < RCGMETHODSLENGTH; i++)
{
RCG *RCGsolver = new RCG(&Prob, &EucX);
RCGsolver->RCGmethod = static_cast<RCGmethods> (i);
RCGsolver->LineSearch_LS = STRONGWOLFE;
RCGsolver->LS_beta = 0.1;
RCGsolver->DEBUG = FINALRESULT;
RCGsolver->CheckParams();
RCGsolver->Run();
delete RCGsolver;
}
// test RBroydenFamily
std::cout << "********************************Check all line search algorithm in RBroydenFamily*************************************" << std::endl;
for (integer i = 0; i < LSALGOLENGTH; i++)
{
RBroydenFamily *RBroydenFamilysolver = new RBroydenFamily(&Prob, &EucX);
RBroydenFamilysolver->LineSearch_LS = static_cast<LSAlgo> (i);
RBroydenFamilysolver->DEBUG = FINALRESULT;
RBroydenFamilysolver->CheckParams();
RBroydenFamilysolver->Run();
delete RBroydenFamilysolver;
}
// test RWRBFGS
std::cout << "********************************Check all line search algorithm in RWRBFGS*************************************" << std::endl;
for (integer i = 0; i < LSALGOLENGTH; i++)
{
RWRBFGS *RWRBFGSsolver = new RWRBFGS(&Prob, &EucX);
RWRBFGSsolver->LineSearch_LS = static_cast<LSAlgo> (i);
RWRBFGSsolver->DEBUG = FINALRESULT;
RWRBFGSsolver->CheckParams();
RWRBFGSsolver->Run();
delete RWRBFGSsolver;
}
// test RBFGS
std::cout << "********************************Check all line search algorithm in RBFGS*************************************" << std::endl;
for (integer i = 0; i < LSALGOLENGTH; i++)
{
RBFGS *RBFGSsolver = new RBFGS(&Prob, &EucX);
RBFGSsolver->LineSearch_LS = static_cast<LSAlgo> (i);
RBFGSsolver->DEBUG = FINALRESULT;
RBFGSsolver->CheckParams();
RBFGSsolver->Run();
delete RBFGSsolver;
}
// test LRBFGS
std::cout << "********************************Check all line search algorithm in LRBFGS*************************************" << std::endl;
for (integer i = 0; i < LSALGOLENGTH; i++)
{
LRBFGS *LRBFGSsolver = new LRBFGS(&Prob, &EucX);
LRBFGSsolver->LineSearch_LS = static_cast<LSAlgo> (i);
LRBFGSsolver->DEBUG = FINALRESULT;
LRBFGSsolver->CheckParams();
LRBFGSsolver->Run();
delete LRBFGSsolver;
}
std::cout << "********************************Check RTRSD*************************************" << std::endl;
RTRSD RTRSDsolver(&Prob, &EucX);
std::cout << std::endl;
RTRSDsolver.DEBUG = FINALRESULT;
RTRSDsolver.CheckParams();
RTRSDsolver.Run();
std::cout << "********************************Check RTRNewton*************************************" << std::endl;
RTRNewton RTRNewtonsolver(&Prob, &EucX);
std::cout << std::endl;
RTRNewtonsolver.DEBUG = FINALRESULT;
RTRNewtonsolver.CheckParams();
RTRNewtonsolver.Run();
std::cout << "********************************Check RTRSR1*************************************" << std::endl;
RTRSR1 RTRSR1solver(&Prob, &EucX);
std::cout << std::endl;
RTRSR1solver.DEBUG = FINALRESULT;
RTRSR1solver.CheckParams();
RTRSR1solver.Run();
std::cout << "********************************Check LRTRSR1*************************************" << std::endl;
LRTRSR1 LRTRSR1solver(&Prob, &EucX);
std::cout << std::endl;
LRTRSR1solver.DEBUG = FINALRESULT;
LRTRSR1solver.CheckParams();
LRTRSR1solver.Run();
// Check gradient and Hessian
Prob.CheckGradHessian(&EucX);
const Variable *xopt = RTRNewtonsolver.GetXopt();
Prob.CheckGradHessian(xopt);
if (Xopt != nullptr)
{
const double *xoptptr = xopt->ObtainReadData();
for (integer i = 0; i < dim; i++)
Xopt[i] = xoptptr[i];
}
};
