void UnconstrainedTestProblem::generateDisplacement(float_t stdDev) {
// generate displacement until a feasible one is found
do {
for (size_t t = 0; t < d; t++) {
// every component is normally distributed
displacement[t] = RandomNumberGenerator::getInstance().getGaussianRN(stdDev);
}
} while (!isDisplacementFeasible());
// set the displacement also in the objective function
getObjectiveFunction().setDisplacement(displacement);
}
void UnconstrainedTestProblem::setDisplacement(const base::DataVector& displacement) {
this->displacement = displacement;
// set the displacement also in the objective function
getObjectiveFunction().setDisplacement(displacement);
}
void CyclicCoordinateDescent::findMode(
int maxIterations,
int convergenceType,
double epsilon
) {
if (convergenceType < GRADIENT || convergenceType > ZHANG_OLES) {
std::ostringstream stream;
stream << "Unknown convergence criterion: " << convergenceType;
error->throwError(stream);
}
if (!validWeights || hXI.getTouchedY() // || hXI.getTouchedX()
) {
computeNEvents();
computeFixedTermsInLogLikelihood();
computeFixedTermsInGradientAndHessian();
validWeights = true;
hXI.clean();
}
if (!xBetaKnown) {
computeXBeta();
xBetaKnown = true;
sufficientStatisticsKnown = false;
}
if (!sufficientStatisticsKnown) {
computeRemainingStatistics(true, 0); // TODO Check index?
sufficientStatisticsKnown = true;
}
resetBounds();
bool done = false;
int iteration = 0;
double lastObjFunc = 0.0;
if (convergenceType < ZHANG_OLES) {
lastObjFunc = getObjectiveFunction(convergenceType);
} else { // ZHANG_OLES
saveXBeta();
}
while (!done) {
// Do a complete cycle
for(int index = 0; index < J; index++) {
if (!fixBeta[index]) {
double delta = ccdUpdateBeta(index);
delta = applyBounds(delta, index);
if (delta != 0.0) {
sufficientStatisticsKnown = false;
updateSufficientStatistics(delta, index);
}
}
if ( (noiseLevel > QUIET) && ((index+1) % 100 == 0)) {
std::ostringstream stream;
stream << "Finished variable " << (index+1);
logger->writeLine(stream);
}
}
iteration++;
// bool checkConvergence = (iteration % J == 0 || iteration == maxIterations);
bool checkConvergence = true; // Check after each complete cycle
if (checkConvergence) {
double conv;
bool illconditioned = false;
if (convergenceType < ZHANG_OLES) {
double thisObjFunc = getObjectiveFunction(convergenceType);
if (thisObjFunc != thisObjFunc) {
std::ostringstream stream;
stream << "\nWarning: problem is ill-conditioned for this choice of\n"
<< "\t prior (" << jointPrior->getDescription() << ") or\n"
<< "\t initial bounding box (" << initialBound << ")\n"
<< "Enforcing convergence!";
logger->writeLine(stream);
conv = 0.0;
illconditioned = true;
} else {
conv = computeConvergenceCriterion(thisObjFunc, lastObjFunc);
}
lastObjFunc = thisObjFunc;
} else { // ZHANG_OLES
conv = computeZhangOlesConvergenceCriterion();
saveXBeta();
} // Necessary to call getObjFxn or computeZO before getLogLikelihood,
// since these copy over XBeta
double thisLogLikelihood = getLogLikelihood();
double thisLogPrior = getLogPrior();
double thisLogPost = thisLogLikelihood + thisLogPrior;
std::ostringstream stream;
if (noiseLevel > QUIET) {
stream << "\n";
printVector(&hBeta[0], J, stream);
stream << "\n";
stream << "log post: " << thisLogPost
<< " (" << thisLogLikelihood << " + " << thisLogPrior
<< ") (iter:" << iteration << ") ";
}
if (epsilon > 0 && conv < epsilon) {
if (illconditioned) {
lastReturnFlag = ILLCONDITIONED;
} else {
if (noiseLevel > SILENT) {
stream << "Reached convergence criterion";
}
lastReturnFlag = SUCCESS;
}
done = true;
} else if (iteration == maxIterations) {
if (noiseLevel > SILENT) {
stream << "Reached maximum iterations";
}
done = true;
lastReturnFlag = MAX_ITERATIONS;
}
if (noiseLevel > QUIET) {
logger->writeLine(stream);
}
logger->yield();
}
}
lastIterationCount = iteration;
updateCount += 1;
modelSpecifics.printTiming();
fisherInformationKnown = false;
varianceKnown = false;
}
