Real TaylorApproximation::value(const Variables& vars)
{
short bdo = sharedDataRep->buildDataOrder;
if (bdo == 1)
return approxData.anchor_function();
else { // build up approx value from constant and derivative terms
Real approx_val = (bdo & 1) ? approxData.anchor_function() : 0.;
if (bdo & 6) {
const RealVector& x = vars.continuous_variables();
const RealVector& x0 = approxData.anchor_continuous_variables();
const RealVector& grad = approxData.anchor_gradient();
const RealSymMatrix& hess = approxData.anchor_hessian();
size_t num_v = sharedDataRep->numVars;
for (size_t i=0; i<num_v; i++) {
Real dist_i = x[i] - x0[i];
if (bdo & 2) // include gradient terms
approx_val += grad[i] * dist_i;
if (bdo & 4) // include Hessian terms
for (size_t j=0; j<num_v; j++)
approx_val += dist_i * hess(i,j) * (x[j] - x0[j])/2.;
}
}
return approx_val;
}
}
const RealVector& TaylorApproximation::gradient(const Variables& vars)
{
short bdo = sharedDataRep->buildDataOrder;
if (bdo == 2)
return approxData.anchor_gradient();
else { // build up approxGradient from derivative terms
if (bdo & 2) // include gradient terms
approxGradient = approxData.anchor_gradient();
else { // initialize approxGradient to zero
size_t num_v = sharedDataRep->numVars;
if (approxGradient.length() != num_v)
approxGradient.size(num_v);
else
approxGradient = 0.;
}
if (bdo & 4) { // include Hessian terms
const RealVector& x = vars.continuous_variables();
const RealVector& x0 = approxData.anchor_continuous_variables();
const RealSymMatrix& hess = approxData.anchor_hessian();
size_t num_v = sharedDataRep->numVars;
for (size_t i=0; i<num_v; i++)
for (size_t j=0; j<num_v; j++)
approxGradient[i] += hess(i,j) * (x[j] - x0[j]);
}
return approxGradient;
}
}
template<typename MatrixType> void qr(const MatrixType& m)
{
/* this test covers the following files:
QR.h
*/
int rows = m.rows();
int cols = m.cols();
typedef typename MatrixType::Scalar Scalar;
typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, MatrixType::ColsAtCompileTime> SquareMatrixType;
typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> VectorType;
MatrixType a = MatrixType::Random(rows,cols);
QR<MatrixType> qrOfA(a);
VERIFY_IS_APPROX(a, qrOfA.matrixQ() * qrOfA.matrixR());
VERIFY_IS_NOT_APPROX(a+MatrixType::Identity(rows, cols), qrOfA.matrixQ() * qrOfA.matrixR());
SquareMatrixType b = a.adjoint() * a;
// check tridiagonalization
Tridiagonalization<SquareMatrixType> tridiag(b);
VERIFY_IS_APPROX(b, tridiag.matrixQ() * tridiag.matrixT() * tridiag.matrixQ().adjoint());
// check hessenberg decomposition
HessenbergDecomposition<SquareMatrixType> hess(b);
VERIFY_IS_APPROX(b, hess.matrixQ() * hess.matrixH() * hess.matrixQ().adjoint());
VERIFY_IS_APPROX(tridiag.matrixT(), hess.matrixH());
b = SquareMatrixType::Random(cols,cols);
hess.compute(b);
VERIFY_IS_APPROX(b, hess.matrixQ() * hess.matrixH() * hess.matrixQ().adjoint());
}
gmMatrix3 Algebraic::hess(const gmVector3 & v)
{
double dfdxy = dxdy(v), dfdxz = dxdz(v), dfdyz = dydz(v);
double dfdxx = dx2(v), dfdyy = dy2(v), dfdzz = dz2(v);
gmMatrix3 hess(dfdxx, dfdxy, dfdxz,
dfdxy, dfdyy, dfdyz,
dfdxz, dfdyz, dfdzz);
return hess;
}
vec sem::set_gradient_hessian(vec grad, mat hessian)
{
int i,j,k;
mat cross_terms(gamma_indices_.n_elem, n_);
mat residuals_divided_by_d = residuals_;
residuals_divided_by_d.each_row /= d_;
for(k = 0; < gamma_indices_.n_elem; k++) {
j = (int) gamma_indices(k) / v_;
i = (int) gamma_indices(k) % v_;
cross_terms.row(k) = residuals_.row(i) % residuals_.row(j) / d_;
}
grad.rows(0, v_ - 1) = sum(residuals_divided_by_d, 1);
grad.rows(v_, v_ + gamma_indices_.n_elem) = sum(cross_terms, 1);
hess(0, v_ - 1, 0, v_ - 1) = residuals_divided_by_d * residuals_divided_by_d.t();
hess(0, v_ - 1, v_ , v_ + gamma_indices_.n_elem) = residuals_divided_by_d * cross_terms.t();
hess(v_, v_ + gamma_indices_.n_elem, 0, v - 1) = hess(0, v_ - 1, v_ , v_ + gamma_indices_.n_elem).t();
hess(v_, v_ + gamma_indices_.n_elem, v_, v_ + gamma_indices_.n_elem) = cross_terms * cross_terms.t();
}
bool IMEXIntegrator::setRotations() const {
const real newtonThreshold = 1.0e-5; //should be able to get this almost exact
std::vector<Triplet> triplets;
Eigen::SparseMatrix<real> hess(r.numEdges()-2, r.numEdges()-2);
VecXe rot = r.next().rot;
VecXe grad = VecXe::Zero(r.numEdges()-2); // Assumes edges are clamped
bool newtonConverge = false;
std::vector<Vec3e> curveBinorm;
for (int i=1; i<r.numCPs()-1; i++) {
Vec3e tPrev = r.next().edge(i-1).normalized();
Vec3e tNext = r.next().edge(i).normalized();
real chi = 1.0 + (tPrev.dot(tNext));
curveBinorm.push_back(2.0*tPrev.cross(tNext)/chi);
}
int newtonIterations = 0;
do {
triplets.clear();
calcRotEqs(r, rot, curveBinorm, grad, triplets);
real resid = grad.norm();
if (resid < newtonThreshold || newtonIterations > 4) {
if (resid > 1.0e-5 * r.numEdges()) { return false; }
newtonConverge = true;
break;
}
newtonIterations++;
hess.setFromTriplets(triplets.begin(), triplets.end());
hess += hessBase;
Eigen::SimplicialLDLT<Eigen::SparseMatrix<real>> sLDLT;
sLDLT.compute(hess);
VecXe sol = sLDLT.solve(grad);
assert(sLDLT.info() == Eigen::Success);
rot.block(1, 0, r.numEdges()-2, 1) += sol;
} while (!newtonConverge);
if (newtonConverge) {
r.next().rot = rot;
}
return newtonConverge;
}
arma::mat hCoef(const arma::mat& weights, const arma::mat& X) {
int p = X.n_cols;
arma::mat hess(p * (weights.n_rows - 1), p * (weights.n_rows - 1), arma::fill::zeros);
for (unsigned int i = 0; i < X.n_rows; i++) {
arma::mat XX = X.row(i).t() * X.row(i);
for (unsigned int j = 0; j < (weights.n_rows - 1); j++) {
for (unsigned int k = 0; k < (weights.n_rows - 1); k++) {
if (j != k) {
hess.submat(j * p, k * p, (j + 1) * p - 1, (k + 1) * p - 1) += XX * weights(j + 1, i)
* weights(k + 1, i);
} else {
hess.submat(j * p, j * p, (j + 1) * p - 1, (j + 1) * p - 1) -= XX * weights(j + 1, i)
* (1.0 - weights(j + 1, i));
}
}
}
}
return hess;
}
void function_minimizer::hess_routine_master()
{
int nvar=initial_params::nvarcalc(); // get the number of active parameters
//if (adjm_ptr) set_labels_for_hess(nvar);
independent_variables x(1,nvar);
initial_params::xinit(x); // get the initial values into the x vector
double f;
double delta=1.e-6;
dvector g1(1,nvar);
dvector g2(1,nvar);
dvector gbest(1,nvar);
dvector hess(1,nvar);
dvector hess1(1,nvar);
dvector hess2(1,nvar);
double eps=.1;
gradient_structure::set_YES_DERIVATIVES();
gbest.fill_seqadd(1.e+50,0.);
adstring tmpstring="admodel.hes";
if (ad_comm::wd_flag)
tmpstring = ad_comm::adprogram_name + ".hes";
uostream ofs((char*)tmpstring);
ofs << nvar;
{
pvm_master_function_evaluation(f,x,g1,nvar);
double sdelta1;
double sdelta2;
for (int i=1;i<=nvar;i++)
{
hess_calcreport(i,nvar);
double f=0.0;
double xsave=x(i);
sdelta1=x(i)+delta;
useless(sdelta1);
sdelta1-=x(i);
x(i)=xsave+sdelta1;
pvm_master_function_evaluation(f,x,g1,nvar);
sdelta2=x(i)-delta;
useless(sdelta2);
sdelta2-=x(i);
x(i)=xsave+sdelta2;
pvm_master_function_evaluation(f,x,g2,nvar);
x(i)=xsave;
hess1=(g1-g2)/(sdelta1-sdelta2);
sdelta1=x(i)+eps*delta;
useless(sdelta1);
sdelta1-=x(i);
x(i)=xsave+sdelta1;
pvm_master_function_evaluation(f,x,g1,nvar);
x(i)=xsave-eps*delta;
sdelta2=x(i)-eps*delta;
useless(sdelta2);
sdelta2-=x(i);
x(i)=xsave+sdelta2;
pvm_master_function_evaluation(f,x,g2,nvar);
x(i)=xsave;
dvariable vf=initial_params::reset(dvar_vector(x));
double eps2=eps*eps;
hess2=(g1-g2)/(sdelta1-sdelta2);
hess=(eps2*hess1-hess2) /(eps2-1.);
ofs << hess;
//if (adjm_ptr) ad_update_hess_stats_report(nvar,i);
}
}
gradient_structure::set_NO_DERIVATIVES();
}
void function_minimizer::hess_routine_noparallel(void)
{
int nvar=initial_params::nvarcalc(); // get the number of active parameters
//if (adjm_ptr) set_labels_for_hess(nvar);
independent_variables x(1,nvar);
initial_params::xinit(x); // get the initial values into the x vector
double delta=1.e-5;
dvector g1(1,nvar);
dvector g2(1,nvar);
dvector gbest(1,nvar);
dvector hess(1,nvar);
dvector hess1(1,nvar);
dvector hess2(1,nvar);
double eps=.1;
gradient_structure::set_YES_DERIVATIVES();
gbest.fill_seqadd(1.e+50,0.);
adstring tmpstring="admodel.hes";
if (ad_comm::wd_flag)
tmpstring = ad_comm::adprogram_name + ".hes";
uostream ofs((char*)tmpstring);
ofs << nvar;
{
{
dvariable vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
gradcalc(nvar, g1, vf);
}
double sdelta1;
double sdelta2;
for (int i=1;i<=nvar;i++)
{
hess_calcreport(i,nvar);
double xsave=x(i);
sdelta1=x(i)+delta;
sdelta1-=x(i);
x(i)=xsave+sdelta1;
dvariable vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
gradcalc(nvar, g1, vf);
sdelta2=x(i)-delta;
sdelta2-=x(i);
x(i)=xsave+sdelta2;
vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
gradcalc(nvar, g2, vf);
x(i)=xsave;
hess1=(g1-g2)/(sdelta1-sdelta2);
sdelta1=x(i)+eps*delta;
sdelta1-=x(i);
x(i)=xsave+sdelta1;
vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
gradcalc(nvar, g1, vf);
x(i)=xsave-eps*delta;
sdelta2=x(i)-eps*delta;
sdelta2-=x(i);
x(i)=xsave+sdelta2;
vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
gradcalc(nvar, g2, vf);
x(i)=xsave;
vf=initial_params::reset(dvar_vector(x));
double eps2=eps*eps;
hess2=(g1-g2)/(sdelta1-sdelta2);
hess=(eps2*hess1-hess2) /(eps2-1.);
ofs << hess;
//if (adjm_ptr) ad_update_hess_stats_report(nvar,i);
}
}
ofs << gradient_structure::Hybrid_bounded_flag;
dvector tscale(1,nvar); // need to get scale from somewhere
/*int check=*/initial_params::stddev_scale(tscale,x);
ofs << tscale;
}
/**
Symmetrize and invert the hessian
*/
void function_minimizer::hess_inv(void)
{
initial_params::set_inactive_only_random_effects();
int nvar=initial_params::nvarcalc(); // get the number of active parameters
independent_variables x(1,nvar);
initial_params::xinit(x); // get the initial values into the x vector
//double f;
dmatrix hess(1,nvar,1,nvar);
uistream ifs("admodel.hes");
int file_nvar = 0;
ifs >> file_nvar;
if (nvar != file_nvar)
{
cerr << "Number of active variables in file mod_hess.rpt is wrong"
<< endl;
}
for (int i = 1;i <= nvar; i++)
{
ifs >> hess(i);
if (!ifs)
{
cerr << "Error reading line " << i << " of the hessian"
<< " in routine hess_inv()" << endl;
exit(1);
}
}
int hybflag = 0;
ifs >> hybflag;
dvector sscale(1,nvar);
ifs >> sscale;
if (!ifs)
{
cerr << "Error reading sscale"
<< " in routine hess_inv()" << endl;
}
double maxerr=0.0;
for (int i = 1;i <= nvar; i++)
{
for (int j=1;j<i;j++)
{
double tmp=(hess(i,j)+hess(j,i))/2.;
double tmp1=fabs(hess(i,j)-hess(j,i));
tmp1/=(1.e-4+fabs(hess(i,j))+fabs(hess(j,i)));
if (tmp1>maxerr) maxerr=tmp1;
hess(i,j)=tmp;
hess(j,i)=tmp;
}
}
/*
if (maxerr>1.e-2)
{
cerr << "warning -- hessian aprroximation is poor" << endl;
}
*/
for (int i = 1;i <= nvar; i++)
{
int zero_switch=0;
for (int j=1;j<=nvar;j++)
{
if (hess(i,j)!=0.0)
{
zero_switch=1;
}
}
if (!zero_switch)
{
cerr << " Hessian is 0 in row " << i << endl;
cerr << " This means that the derivative if probably identically 0 "
" for this parameter" << endl;
}
}
int ssggnn;
ln_det(hess,ssggnn);
int on1=0;
{
ofstream ofs3((char*)(ad_comm::adprogram_name + adstring(".eva")));
{
dvector se=eigenvalues(hess);
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< "unsorted:\t" << se << endl;
se=sort(se);
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< "sorted:\t" << se << endl;
if (se(se.indexmin())<=0.0)
{
negative_eigenvalue_flag=1;
cout << "Warning -- Hessian does not appear to be"
" positive definite" << endl;
}
}
ivector negflags(0,hess.indexmax());
int num_negflags=0;
{
int on = option_match(ad_comm::argc,ad_comm::argv,"-eigvec");
on1=option_match(ad_comm::argc,ad_comm::argv,"-spmin");
if (on > -1 || on1 >-1 )
{
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< eigenvalues(hess) << endl;
dmatrix ev=trans(eigenvectors(hess));
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< ev << endl;
for (int i=1;i<=ev.indexmax();i++)
{
double lam=ev(i)*hess*ev(i);
ofs3 << setshowpoint() << setw(14) << setprecision(10)
<< lam << " " << ev(i)*ev(i) << endl;
if (lam<0.0)
{
num_negflags++;
negflags(num_negflags)=i;
}
}
if ( (on1>-1) && (num_negflags>0)) // we will try to get away from
{ // saddle point
negative_eigenvalue_flag=0;
spminflag=1;
if(negdirections)
{
delete negdirections;
}
negdirections = new dmatrix(1,num_negflags);
for (int i=1;i<=num_negflags;i++)
{
(*negdirections)(i)=ev(negflags(i));
}
}
int on2 = option_match(ad_comm::argc,ad_comm::argv,"-cross");
if (on2>-1)
{ // saddle point
dmatrix cross(1,ev.indexmax(),1,ev.indexmax());
for (int i = 1;i <= ev.indexmax(); i++)
{
for (int j=1;j<=ev.indexmax();j++)
{
cross(i,j)=ev(i)*ev(j);
}
}
ofs3 << endl << " e(i)*e(j) ";
ofs3 << endl << cross << endl;
}
}
}
if (spminflag==0)
{
if (num_negflags==0)
{
hess=inv(hess);
int on=0;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-eigvec"))>-1)
{
int i;
ofs3 << "choleski decomp of correlation" << endl;
dmatrix ch=choleski_decomp(hess);
for (i=1;i<=ch.indexmax();i++)
ofs3 << ch(i)/norm(ch(i)) << endl;
ofs3 << "parameterization of choleski decomnp of correlation" << endl;
for (i=1;i<=ch.indexmax();i++)
{
dvector tmp=ch(i)/norm(ch(i));
ofs3 << tmp(1,i)/tmp(i) << endl;
}
}
}
}
}
if (spminflag==0)
{
if (on1<0)
{
for (int i = 1;i <= nvar; i++)
{
if (hess(i,i) <= 0.0)
{
hess_errorreport();
ad_exit(1);
}
}
}
{
adstring tmpstring="admodel.cov";
if (ad_comm::wd_flag)
tmpstring = ad_comm::adprogram_name + ".cov";
uostream ofs((char*)tmpstring);
ofs << nvar << hess;
ofs << gradient_structure::Hybrid_bounded_flag;
ofs << sscale;
}
}
}
void function_minimizer::hess_routine_and_constraint(int iprof,
const dvector& g, dvector& fg)
{
int nvar=initial_params::nvarcalc(); // get the number of active parameters
independent_variables x(1,nvar);
initial_params::xinit(x); // get the initial values into the x vector
double delta=1.e-6;
dvector g1(1,nvar);
dvector g2(1,nvar);
dvector gbest(1,nvar);
dvector hess(1,nvar);
dvector hess1(1,nvar);
dvector hess2(1,nvar);
//double eps=.1;
gradient_structure::set_YES_DERIVATIVES();
gbest.fill_seqadd(1.e+50,0.);
uostream ofs("admodel.hes");
//ofstream ofs5("tmphess");
double lambda=fg*g/norm2(g);
cout << fg-lambda*g << endl;
cout << norm(fg-lambda*g) << " " << fg*g/(norm(g)*norm(fg)) << endl;
ofs << nvar;
{
{
dvariable vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
vf-=lambda*likeprof_params::likeprofptr[iprof]->variable();
gradcalc(nvar, g1, vf);
}
double sdelta1;
double sdelta2;
for (int i=1;i<=nvar;i++)
{
hess_calcreport(i,nvar);
double xsave=x(i);
sdelta1=x(i)+delta;
sdelta1-=x(i);
x(i)=xsave+sdelta1;
dvariable vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
vf-=lambda*likeprof_params::likeprofptr[iprof]->variable();
gradcalc(nvar, g1, vf);
sdelta2=x(i)-delta;
sdelta2-=x(i);
x(i)=xsave+sdelta2;
vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
vf-=lambda*likeprof_params::likeprofptr[iprof]->variable();
gradcalc(nvar, g2, vf);
x(i)=xsave;
hess1=(g1-g2)/(sdelta1-sdelta2);
/*
sdelta1=x(i)+eps*delta;
sdelta1-=x(i);
x(i)=xsave+sdelta1;
vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
vf-=lambda*likeprof_params::likeprofptr[iprof]->variable();
f=value(vf);
gradcalc(nvar,g1);
x(i)=xsave-eps*delta;
sdelta2=x(i)-eps*delta;
sdelta2-=x(i);
x(i)=xsave+sdelta2;
vf=0.0;
vf=0.0;
vf=initial_params::reset(dvar_vector(x));
*objective_function_value::pobjfun=0.0;
pre_userfunction();
vf+=*objective_function_value::pobjfun;
vf-=lambda*likeprof_params::likeprofptr[iprof]->variable();
f=value(vf);
gradcalc(nvar,g2);
x(i)=xsave;
double eps2=eps*eps;
hess2=(g1-g2)/(sdelta1-sdelta2);
hess=(eps2*hess1-hess2) /(eps2-1.);
*/
hess=hess1;
ofs << hess;
}
}
gradient_structure::set_NO_DERIVATIVES();
}
