inline void prepare ()
{
if (_options.size() != 1) {
_returnMsg = "configFile::commentedFile test expects 1 option to be set.";
setReturnCode((int) ERROR_DEVELOPMENT);
return ;
}
vector<string>::iterator it = _options.begin();
_configObj = new configIni ((*it));
setReturnCode((int) RETURN_SUCCESS);
}
int OptCG::computeStep(ColumnVector sk)
//----------------------------------------------------------------------------
//
// compute a step along the direction sk using either a backtrack line search
// or a More-Thuente search
//
//----------------------------------------------------------------------------
{
int step_type;
int itnmax = tol.getMaxBacktrackIter();
real stp_length = 1.0;
real stpmax = tol.getMaxStep();
real stpmin = tol.getMinStep(); // 1.e-9;
real ftol = 5.e-1;
real xtol = 2.2e-16;
real gtol = 5.e-1;
step_type = linesearch(nlp, optout, sk, sx, &stp_length, stpmax, stpmin,
itnmax, ftol, xtol, gtol);
if (step_type < 0) {
setMesg("Algorithm terminated - No longer able to compute step with sufficient decrease");
ret_code = -1;
setReturnCode(ret_code);
return(-1);
}
fcn_evals = nlp->getFevals();
grad_evals = nlp->getGevals();
step_length = stp_length;
return(step_type);
}
inline int execute ()
{
// test creation of insertQuery using map<string,string>.
// if this does not work it means the data storage is
// broken.
map<string,string> data;
data.insert (make_pair ("first_name", "Yannick"));
data.insert (make_pair ("last_name", "Yannick"));
data.insert (make_pair ("address", "Rue de l'église 37"));
data.insert (make_pair ("zipcode", "4720"));
data.insert (make_pair ("city", "Kelmis"));
data.insert (make_pair ("country", "Belgium"));
_queryObj->into ("student")
->values (data);
// make sure we inserted everything
if (_queryObj->getValuesDispatched().size() != 6) {
_returnMsg = "code defines 6 field, value pairs but object returned other entries count.";
return setReturnCode((int) ERROR_DEVELOPMENT);
}
// check if all fields can be retrieved
if (! _queryObj->hasValueForField("first_name") ||
! _queryObj->hasValueForField("last_name") ||
! _queryObj->hasValueForField("address") ||
! _queryObj->hasValueForField("zipcode") ||
! _queryObj->hasValueForField("city") ||
! _queryObj->hasValueForField("country")) {
_returnMsg = "code defines first_name,last_name,address,zipcode,city,country but some are missing at call.";
return setReturnCode((int) ERROR_DEVELOPMENT);
}
return _returnCode;
}
inline int execute ()
{
jsonSingleEntry* single1 = new jsonSingleEntry("my_single1", "data");
jsonSingleEntry* single2 = new jsonSingleEntry("my_single2", "dontknow");
jsonSingleEntry* single3 = new jsonSingleEntry("my_single3", "one more..");
jsonArrayEntry* array1 = new jsonArrayEntry ("greg");
jsonArrayEntry* array2 = new jsonArrayEntry ("yan");
vector<string> arrayOneData;
arrayOneData.push_back ("Grégory");
arrayOneData.push_back ("Saive");
arrayOneData.push_back ("1988-08-29");
vector<string> arrayTwoData;
arrayTwoData.push_back ("Yannick");
arrayTwoData.push_back ("Saive");
arrayTwoData.push_back ("1983-12-10");
array1->setData(arrayOneData);
array2->setData(arrayTwoData);
vector<jsonEntry*> entries;
entries.push_back (single1);
entries.push_back (single2);
entries.push_back (array1);
entries.push_back (array2);
entries.push_back (single3);
jsonObjectEntry* object = new jsonObjectEntry;
object->setEntries (entries);
string arrayJson = "\"my_array\":[\"key1\",\"array content\",\"should work\"]";
jsonArrayEntry* staticArray1 = jsonArrayEntry::fromJSON (arrayJson);
assertable<int>::assertEqual(staticArray1->getData().size(), 3);
assertable<int>::assertEqual(object->getEntries().size(), 5);
// void memory
entries.clear ();
delete single1;
delete single2;
delete single3;
delete array1;
delete array2;
delete staticArray1;
return setReturnCode((int) RETURN_SUCCESS);
}
inline int execute ()
{
if (! (bool) _returnCode)
return _returnCode;
_configObj->parse();
assertable<bool>::assertEqual(_configObj->state(), true);
// the configuration file has two sections (workSection & workSection2) and
// one commented section. The first has 3 entries, the second has no.
// check if comments work without messing up the entries attachments.
iniSection sectionOne = _configObj->getSection("workSection");
iniSection sectionTwo = _configObj->getSection("workSection2");
iniSection sectionOut = _configObj->getSection("commentedSection");
assertable<int>::assertEqual(sectionOne.getPairs().size(), 3);
assertable<int>::assertEqual(sectionTwo.getPairs().size(), 0);
assertable<string>::assertEqual(sectionTwo.getLabel(), "workSection2");
return setReturnCode((int) RETURN_SUCCESS);
}
inline int execute ()
{
string jsonObjectGreg = "\"json.user\"={\"first_name\":\"Grégory\",\"last_name\":\"Saive\",\"address\":[\"rue de l'église\",\"37\",\"4720\",\"Kelmis\"]}";
jsonObjectEntry* objectGreg = new jsonObjectEntry ("student.greg");
jsonSingleEntry* firstNameGreg = new jsonSingleEntry ("first_name", "Grégory");
jsonSingleEntry* lastNameGreg = new jsonSingleEntry ("last_name", "Saive");
jsonArrayEntry* addressGreg = new jsonArrayEntry ("address");
vector<string> addrData;
addrData.push_back ("rue de l'église");
addrData.push_back ("37");
addrData.push_back ("4720");
addrData.push_back ("Kelmis");
// set address data
addressGreg->setData (addrData);
vector<jsonEntry*> entriesForObject;
entriesForObject.push_back (firstNameGreg);
entriesForObject.push_back (lastNameGreg);
entriesForObject.push_back (addressGreg);
// set object data
objectGreg->setEntries (entriesForObject);
assertable<int>::assertEqual(objectGreg->getEntries().size(), 3);
// free
delete objectGreg;
delete firstNameGreg;
delete lastNameGreg;
delete addressGreg;
return setReturnCode((int) RETURN_SUCCESS);
}
inline void prepare ()
{
_queryObj = new insertQuery;
setReturnCode((int) RETURN_SUCCESS);
}
inline void prepare ()
{
setReturnCode((int) RETURN_SUCCESS);
}
void OptCG::optimize()
//------------------------------------------------------------------------
// Nonlinear Preconditioned Conjugate Gradient
//
// Given a nonlinear operator objfcn find the minimizer using a
// nonlinear conjugate gradient method
// This version uses the Polak-Ribiere formula.
// and a line search routine due to More and Thuente as implemented
// in the routines mcsrch and mcstep
//
// Notes: The parameters ftol and gtol should be set so that
// 0 < ftol < gtol < 0.5
// Default values: ftol = 1.e-1, gtol = 5.e-1
// This results in a fairly accurate line search
//
// Here is the mathematical description of the algorithm
// (g = grad f).
// -1
// 1. set z = M g, search = -z;
//
// 2. for i=0 until convergence
//
// find alpha that minimizes f(x + alpha*search)
// subject to the strong Wolfe conditions
//
// Test for convergence
//
//
// beta = -( g , (z - z ) ) / ( g , z )
// i+1 i + 1 i i i
//
// search = - z + beta * search
// i+1 i+1 i
//
//----------------------------------------------------------------------------
{
int i, nlcg_iter;
int convgd = 0;
int step_type;
double beta;
double delta, delta_old, delta_mid, delta_new;
double slope, gnorm;
double step;
double zero = 0.;
// Allocate local vectors
int n = dim;
int maxiter;
double fvalue;
ColumnVector search(n), grad(n), z(n), diag(n), xc(n);
// Initialize iteration
maxiter = tol.getMaxIter();
initOpt();
if (ret_code == 0) {
// compute preconditioned gradient
diag = getFcnScale();
grad = nlp->getGrad();
for (i=1; i<=n; i++) z(i) = grad(i)/diag(i);
search = -z;
delta_old = delta_new = Dot(grad,z);
gnorm = sqrt(Dot(grad,grad));
step = 1.0/gnorm;
//---------------------------------------------------------------------------
//
//
//
//
//---------------------------------------------------------------------------
for (nlcg_iter=1; nlcg_iter <= maxiter; nlcg_iter++) {
iter_taken = nlcg_iter;
// compute a step along the direction search
if ((step_type = computeStep(search)) < 0) {
setMesg("Algorithm terminated - No longer able to compute step with sufficient decrease");
ret_code = step_type;
setReturnCode(ret_code);
return;
}
// Accept this step and update the nonlinear model
acceptStep(nlcg_iter, step_type);
updateModel(nlcg_iter, n, xprev);
xc = nlp->getXc();
mem_step = xc - xprev;
step = Norm2(mem_step);
fvalue = nlp->getF();
grad = nlp->getGrad();
gnorm = sqrt(Dot(grad,grad));
slope = Dot(grad,search);
// Test for Convergence
convgd = checkConvg();
if (convgd > 0) {
ret_code = convgd;
setReturnCode(ret_code);
*optout << d(nlcg_iter,5) << " " << e(fvalue,12,4) << " "
<< e(gnorm,12,4) << e(step,12,4) << "\n";
return;
}
//
// compute a new search direction
// 1. compute preconditioned gradient, z = grad;
// 2. beta is computed using Polak-Ribiere Formula constrained
// so that beta > 0
// 3 Update search direction and norms
delta_old = delta_new; delta_mid = Dot(grad,z);
for (i=1; i<=n; i++) z(i) = grad(i)/diag(i);
delta_new = Dot(grad,z);
delta = delta_new - delta_mid;
beta = max(zero,delta/delta_old);
search = -z + search*beta;
xprev = nlp->getXc();
fprev = fvalue;
gprev = grad;
*optout
<< d(nlcg_iter,5) << " " << e(fvalue,12,4) << " " << e(gnorm,12,4)
<< e(step,12,4) << " " << e(beta,12,4) << " " << e(slope,12,4)
<< d(fcn_evals,4) << " " << d(grad_evals,4) << endl;
}
setMesg("Algorithm terminated - Number of iterations exceeds the specified limit");
ret_code = 4;
setReturnCode(ret_code);
}
}