void runPolDecompTest(float tol)
{
using scalar_t = float;
using real_t = WideScalar;
using matrix3_t = Eigen::Matrix<real_t, 3, 3>;
using vector3_t = Eigen::Matrix<real_t, 3, 1>;
size_t nr_problems = 128;
Vcl::Core::InterleavedArray<scalar_t, 3, 3, -1> resR(nr_problems);
Vcl::Core::InterleavedArray<scalar_t, 3, 3, -1> resS(nr_problems);
Vcl::Core::InterleavedArray<scalar_t, 3, 3, -1> refR(nr_problems);
Vcl::Core::InterleavedArray<scalar_t, 3, 3, -1> refS(nr_problems);
auto F = createProblems<scalar_t>(nr_problems);
computeReferenceSolution(nr_problems, F, refR, refS);
// Strides
size_t stride = nr_problems;
size_t width = sizeof(real_t) / sizeof(scalar_t);
for (int i = 0; i < static_cast<int>(stride / width); i++)
{
matrix3_t A = F.at<real_t>(i);
matrix3_t R, S;
Vcl::Mathematics::PolarDecomposition(A, R, &S);
resR.at<real_t>(i) = R;
resS.at<real_t>(i) = S;
}
// Check against reference solution
checkSolution(nr_problems, tol, refR, refS, resR, resS);
}
static int IDASensfnorm(IDAMem IDA_mem, realtype *fnorm)
{
int is, retval;
/* Get sensitivity residual */
retval = resS(Ns, t0,
yy0, yp0, delta,
yyS0new, ypS0new, delnewS,
user_dataS, tmpS1, tmpS2, tmpS3);
nrSe++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
for(is=0; is<Ns; is++) N_VScale(ONE, delnewS[is], savresS[is]);
/* Call linear solve function */
for(is=0; is<Ns; is++) {
retval = lsolve(IDA_mem, delnewS[is], ewtS[is], yy0, yp0, delta);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
}
/* Compute the WRMS-norm; rescale if index = 0. */
*fnorm = IDASensWrmsNorm(IDA_mem, delnewS, ewtS, FALSE);
if(sysindex == 0) (*fnorm) *= tscale*SUNRabs(cj);
return(IDA_SUCCESS);
}
static int IDAfnorm(IDAMem IDA_mem, realtype *fnorm)
{
int retval, is;
/* Get residual vector F, return if failed, and save F in savres. */
retval = res(t0, ynew, ypnew, delnew, user_data);
nre++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
N_VScale(ONE, delnew, savres);
/* Call the linear solve function to get J-inverse F; return if failed. */
retval = lsolve(IDA_mem, delnew, ewt, ynew, ypnew, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Compute the WRMS-norm. */
*fnorm = IDAWrmsNorm(IDA_mem, delnew, ewt, FALSE);
/* Are we computing SENSITIVITIES with the IDA_SIMULTANEOUS approach? */
if(sensi && (ism==IDA_SIMULTANEOUS)) {
/* Evaluate the residual for sensitivities. */
retval = resS(Ns, t0,
ynew, ypnew, savres,
yyS0new, ypS0new, delnewS,
user_dataS, tmpS1, tmpS2, tmpS3);
nrSe++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
/* Save delnewS in savresS. */
for(is=0; is<Ns; is++)
N_VScale(ONE, delnewS[is], savresS[is]);
/* Call the linear solve function to get J-inverse deltaS. */
for(is=0; is<Ns; is++) {
retval = lsolve(IDA_mem, delnewS[is], ewtS[is], ynew, ypnew, savres);
if(retval < 0) return(IDA_LSOLVE_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
}
/* Include sensitivities in norm. */
*fnorm = IDASensWrmsNormUpdate(IDA_mem, *fnorm, delnewS, ewtS, FALSE);
}
/* Rescale norm if index = 0. */
if(sysindex == 0) (*fnorm) *= tscale*SUNRabs(cj);
return(IDA_SUCCESS);
}
int
main(int argc, char *argv[])
{
struct rlimit core_limits;
core_limits.rlim_cur = 0;
core_limits.rlim_max = 0;
setrlimit( RLIMIT_CORE, &core_limits );
ECArgs args( argc, argv );
assert(args.nargs() == 3);
ECString conditionedType = args.arg(0);
Feat::Usage = SEL;
percentDesiredFeatures = (float)atoi(args.arg(1).c_str())/100.0;
cerr << "start selFeats: " << conditionedType
<< " " << percentDesiredFeatures << endl;
ECString path( args.arg( 2 ) );
ECString fHp(path);
fHp += conditionedType;
fHp += ".ff";
Feature::init(path, conditionedType);
ifstream fHps(fHp.c_str());
new FeatureTree(fHps);
whichInt = Feature::whichInt;
cerr << "Before doRanking" << endl;
doRanking();
totDesiredFeatures = (int) (percentDesiredFeatures * totStates);
cerr << "Before markFeats" << endl;
markFeats();
ECString resS(path);
resS += conditionedType;
resS += ".f";
ofstream res(resS.c_str());
FeatureTree* root = FeatureTree::roots(whichInt);
FTreeMap::iterator ftmIter = root->subtree.begin();
cerr << "About to print featuretree" << endl;
for( ; ftmIter != root->subtree.end() ; ftmIter++)
{
int asVal = (*ftmIter).first;
FeatureTree* subRoot = root->subtree[asVal];
subRoot->printFTree(asVal, res);
}
res << "\n\nSelected " << totSelectedStates << " of "
<< totStates << endl;
return 0;
}
/*
* -----------------------------------------------------------------
* IDASensNlsIC
* -----------------------------------------------------------------
* IDASensNlsIC solves nonlinear systems forsensitivities consistent
* initial conditions. It mainly relies on IDASensNewtonIC.
*
* The return value is IDA_SUCCESS = 0 if no error occurred.
* The error return values (positive) considered recoverable are:
* IC_FAIL_RECOV if res, lsetup, or lsolve failed recoverably
* IC_CONSTR_FAILED if the constraints could not be met
* IC_LINESRCH_FAILED if the linesearch failed (on steptol test)
* IC_CONV_FAIL if the Newton iterations failed to converge
* IC_SLOW_CONVRG if the iterations are converging slowly
* (failed the convergence test, but showed
* norm reduction or convergence rate < 1)
* The error return values (negative) considered non-recoverable are:
* IDA_RES_FAIL if res had a non-recoverable error
* IDA_FIRST_RES_FAIL if res failed recoverably on the first call
* IDA_LSETUP_FAIL if lsetup had a non-recoverable error
* IDA_LSOLVE_FAIL if lsolve had a non-recoverable error
* -----------------------------------------------------------------
*/
static int IDASensNlsIC(IDAMem IDA_mem)
{
int retval;
int is, nj;
retval = resS(Ns, t0,
yy0, yp0, delta,
yyS0, ypS0, deltaS,
user_dataS, tmpS1, tmpS2, tmpS3);
nrSe++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IDA_FIRST_RES_FAIL);
/* Save deltaS */
for(is=0; is<Ns; is++) N_VScale(ONE, deltaS[is], savresS[is]);
/* Loop over nj = number of linear solve Jacobian setups. */
for(nj = 1; nj <= 2; nj++) {
/* Call the Newton iteration routine */
retval = IDASensNewtonIC(IDA_mem);
if(retval == IDA_SUCCESS) return(IDA_SUCCESS);
/* If converging slowly and lsetup is nontrivial and this is the first pass,
update Jacobian and retry. */
if(retval == IC_SLOW_CONVRG && setupNonNull && nj==1) {
/* Restore deltaS. */
for(is=0; is<Ns; is++) N_VScale(ONE, savresS[is], deltaS[is]);
nsetupsS++;
retval = lsetup(IDA_mem, yy0, yp0, delta, tmpS1, tmpS2, tmpS3);
if(retval < 0) return(IDA_LSETUP_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
continue;
} else {
return(retval);
}
}
return(IDA_SUCCESS);
}
int
main(int argc, char *argv[])
{
struct rlimit core_limits;
core_limits.rlim_cur = 0;
core_limits.rlim_max = 0;
setrlimit( RLIMIT_CORE, &core_limits );
ECArgs args( argc, argv );
assert(args.nargs() == 2);
conditionedType = args.arg(0);
cerr << "start trainRs: " << conditionedType << endl;
ECString path( args.arg( 1 ) );
if(args.isset('L')) Feature::setLM();
Term::init(path);
readHeadInfo(path);
Pst pst(path);
if(Feature::isLM) ClassRule::readCRules(path);
addSubFeatureFns();
Feature::init(path, conditionedType);
whichInt = Feature::whichInt;
int ceFunInt = Feature::conditionedFeatureInt[Feature::whichInt];
Feature::conditionedEvent
= SubFeature::Funs[ceFunInt];
Feat::Usage = PARSE;
ECString ftstr(path);
ftstr += conditionedType;
ftstr += ".g";
ifstream fts(ftstr.c_str());
if(!fts)
{
cerr << "Could not find " << ftstr << endl;
assert(fts);
}
tRoot = new FeatureTree(fts); //puts it in root;
cout.precision(3);
cerr.precision(3);
lamInit();
InputTree* trainingData[1001];
int usedCount = 0;
sentenceCount = 0;
for( ; ; sentenceCount++)
{
if(sentenceCount%10000 == 1)
{
// cerr << conditionedType << ".tr "
//<< sentenceCount << endl;
}
if(usedCount >= 1000) break;
InputTree* correct = new InputTree;
cin >> (*correct);
if(correct->length() == 0) break;
if(!cin) break;
EcSPairs wtList;
correct->make(wtList);
InputTree* par;
par = correct;
trainingData[usedCount++] = par;
}
if(Feature::isLM) pickLogBases(trainingData,sentenceCount);
procGSwitch = true;
for(pass = 0 ; pass < 10 ; pass++)
{
if(pass%2 == 1) cout << "Pass " << pass << endl;
goThroughSents(trainingData, sentenceCount);
updateLambdas();
//printLambdas(cout);
zeroData();
}
ECString resS(path);
resS += conditionedType;
resS += ".lambdas";
ofstream res(resS.c_str());
res.precision(3);
printLambdas(res);
printLambdas(cout);
cout << "Total params = " << FeatureTree::totParams << endl;
cout << "Done: " << (int)sbrk(0) << endl;
}
int
main(int argc, char *argv[])
{
struct rlimit core_limits;
core_limits.rlim_cur = 0;
core_limits.rlim_max = 0;
setrlimit( RLIMIT_CORE, &core_limits );
ECArgs args( argc, argv );
assert(args.nargs() == 2);
if(args.isset('N')) numGram = atoi(args.value('N').c_str());
Feature::setLM();
if(args.isset('L')) Term::Language = args.value('L');
string path( args.arg( 1 ) );
if(Term::Language == "Ch") readHeadInfoCh(path);
else readHeadInfo(path);
string conditionedType( args.arg(0) );
cerr << "start kn3Counts " << conditionedType << endl;
int minCount = 1;
if(args.isset('m')) minCount = atoi(args.value('m').c_str());
Feat::Usage = KNCOUNTS;
FeatureTree::minCount = minCount;
Term::init(path);
readHeadInfo(path);
Pst pst(path);
addSubFeatureFns();
Feature::assignCalc(conditionedType);
FeatureTree::root() = new FeatureTree();
Feature::init(path, conditionedType);
int wI = Feature::whichInt;
int ceFunInt = Feature::conditionedFeatureInt[wI];
Feature::conditionedEvent
= SubFeature::Funs[ceFunInt];
string trainingString( path );
int sentenceCount = 0;
for( ; ; sentenceCount++)
{
if(sentenceCount%10000 == 1)
{
cerr << "rCounts "
<< sentenceCount << endl;
}
InputTree correct;
cin >> correct;
//if(sentenceCount > 1000) break;
if(correct.length() == 0) break;
//cerr <<sentenceCount << correct << endl;
EcSPairs wtList;
correct.make(wtList);
InputTree* par;
int strt = 0;
par = &correct;
makeSent(par);
curS = par;
gatherFfCounts(par, 0);
if(wI == TTCALC || wI == WWCALC)
{
list<InputTree*> dummy2;
InputTree stopInputTree(par->finish(),par->finish(),
wI==TTCALC ? "" : "^^",
"STOP","",
dummy2,NULL,NULL);
stopInputTree.headTree() = &stopInputTree;
TreeHist treeh(&stopInputTree,0);
treeh.hpos = 0;
callProcG(&treeh);
}
}
finalProbComputation();
string resS(path);
resS += conditionedType;
resS += ".g";
ofstream res(resS.c_str());
assert(res);
FTreeMap& fts = FeatureTree::root()->subtree;
FTreeMap::iterator fti = fts.begin();
for( ; fti != fts.end() ; fti++)
{
int asVal = (*fti).first;
(*fti).second->printFTree(asVal, res);
}
res.close();
cout << "Tot words: " << totWords << endl;
cout << "Total params for " << conditionedType << " = "
<< FeatureTree::totParams << endl;
}
static int IDANlsIC(IDAMem IDA_mem)
{
int retval, nj, is;
N_Vector tv1, tv2, tv3;
booleantype sensi_sim;
/* Are we computing sensitivities with the IDA_SIMULTANEOUS approach? */
sensi_sim = (sensi && (ism==IDA_SIMULTANEOUS));
tv1 = ee;
tv2 = tempv2;
tv3 = phi[2];
/* Evaluate RHS. */
retval = res(t0, yy0, yp0, delta, user_data);
nre++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IDA_FIRST_RES_FAIL);
/* Save the residual. */
N_VScale(ONE, delta, savres);
if(sensi_sim) {
/*Evaluate sensitivity RHS and save it in savresS. */
retval = resS(Ns, t0,
yy0, yp0, delta,
yyS0, ypS0, deltaS,
user_dataS, tmpS1, tmpS2, tmpS3);
nrSe++;
if(retval < 0) return(IDA_RES_FAIL);
if(retval > 0) return(IDA_FIRST_RES_FAIL);
for(is=0; is<Ns; is++)
N_VScale(ONE, deltaS[is], savresS[is]);
}
/* Loop over nj = number of linear solve Jacobian setups. */
for(nj = 1; nj <= maxnj; nj++) {
/* If there is a setup routine, call it. */
if(setupNonNull) {
nsetups++;
retval = lsetup(IDA_mem, yy0, yp0, delta, tv1, tv2, tv3);
if(retval < 0) return(IDA_LSETUP_FAIL);
if(retval > 0) return(IC_FAIL_RECOV);
}
/* Call the Newton iteration routine, and return if successful. */
retval = IDANewtonIC(IDA_mem);
if(retval == IDA_SUCCESS) return(IDA_SUCCESS);
/* If converging slowly and lsetup is nontrivial, retry. */
if(retval == IC_SLOW_CONVRG && setupNonNull) {
N_VScale(ONE, savres, delta);
if(sensi_sim)
for(is=0; is<Ns; is++)
N_VScale(ONE, savresS[is], deltaS[is]);
continue;
} else {
return(retval);
}
} /* End of nj loop */
/* No convergence after maxnj tries; return with retval=IC_SLOW_CONVRG */
return(retval);
}
