bool TShape3DB2::evaluate_with_hess( const MsqMatrix<3,3>& T,
double& result,
MsqMatrix<3,3>& wrt_T,
MsqMatrix<3,3> second[6],
MsqError& err )
{
double f = sqr_Frobenius(T);
double g = sqr_Frobenius(adj(T));
double d = det(T);
if (invalid_determinant(d)) {
MSQ_SETERR(err)( barrier_violated_msg, MsqError::BARRIER_VIOLATED );
return false;
}
const double den = 1.0/(9*d*d);
result = f*g*den- 1;
MsqMatrix<3,3> dg = 2 * (f * T - T * transpose(T) * T);
MsqMatrix<3,3> df = 2 * T;
MsqMatrix<3,3> dtau = transpose_adj(T);
wrt_T = g*df + f*dg - 2*f*g/d * transpose_adj(T);
wrt_T *= den;
set_scaled_2nd_deriv_norm_sqr_adj( second, den*f, T );
pluseq_scaled_I( second, 2*den*g );
pluseq_scaled_sum_outer_product( second, den, dg, df );
pluseq_scaled_sum_outer_product( second, -2*den*g/d, df, dtau );
pluseq_scaled_sum_outer_product( second, -2*den*f/d, dg, dtau );
pluseq_scaled_outer_product( second, 6*den*f*g/(d*d), dtau );
pluseq_scaled_2nd_deriv_of_det( second, -2*den*f*g/d, T );
return true;
}
bool TShapeOrientB1::evaluate_with_hess( const MsqMatrix<2,2>& T,
double& result,
MsqMatrix<2,2>& deriv_wrt_T,
MsqMatrix<2,2> second_wrt_T[3],
MsqError& err )
{
const double norm = Frobenius(T);
const double invroot = 1.0/MSQ_SQRT_TWO;
const double tau = det(T);
if (TMetric::invalid_determinant(tau)) { // barrier
MSQ_SETERR(err)( barrier_violated_msg, MsqError::BARRIER_VIOLATED );
return false;
}
const double inv_tau = 1.0/tau;
const double invnorm = 1.0/norm;
const double f = norm - invroot * trace(T);
result = 0.5 * inv_tau * f;
const MsqMatrix<2,2> adjt = transpose_adj(T);
deriv_wrt_T = invnorm * T;
pluseq_scaled_I( deriv_wrt_T, -invroot );
deriv_wrt_T *= 0.5;
deriv_wrt_T -= result * adjt;
deriv_wrt_T *= inv_tau;
const double a = 0.5 * inv_tau * invnorm;
set_scaled_outer_product( second_wrt_T, -a*invnorm*invnorm, T );
pluseq_scaled_I( second_wrt_T, a );
pluseq_scaled_outer_product( second_wrt_T, f*inv_tau*inv_tau*inv_tau, adjt );
pluseq_scaled_2nd_deriv_of_det( second_wrt_T, -0.5*f*inv_tau*inv_tau, T );
pluseq_scaled_sum_outer_product( second_wrt_T, -0.5*inv_tau*inv_tau*invnorm, T, adjt );
pluseq_scaled_sum_outer_product_I( second_wrt_T, 0.5*inv_tau*inv_tau*invroot, adjt );
return true;
}
bool TShapeB1::evaluate_with_hess( const MsqMatrix<3,3>& T,
double& result,
MsqMatrix<3,3>& deriv_wrt_T,
MsqMatrix<3,3> second_wrt_T[6],
MsqError& err )
{
double d = det(T);
if (invalid_determinant(d)) {
MSQ_SETERR(err)( barrier_violated_msg, MsqError::BARRIER_VIOLATED );
return false;
}
double id = 1.0/d;
double norm = Frobenius(T);
double den = 1.0/(3 * MSQ_SQRT_THREE * d);
double norm_cube = norm*norm*norm;
result = norm_cube * den - 1.0;
MsqMatrix<3,3> adjt = transpose_adj(T);
deriv_wrt_T = T;
deriv_wrt_T *= 3 * norm * den;
deriv_wrt_T -= norm_cube * den * id * transpose_adj(T);
set_scaled_outer_product( second_wrt_T, 3 * den / norm, T );
pluseq_scaled_I( second_wrt_T, 3 * norm * den );
pluseq_scaled_2nd_deriv_of_det( second_wrt_T, -den * norm_cube * id, T );
pluseq_scaled_outer_product( second_wrt_T, 2 * den * norm_cube * id * id , adjt );
pluseq_scaled_sum_outer_product( second_wrt_T, -3 * norm * den * id, T, adjt );
return true;
}
bool TShapeSizeOrientB1::evaluate_with_hess( const MsqMatrix<2,2>& T,
double& result,
MsqMatrix<2,2>& deriv_wrt_T,
MsqMatrix<2,2> second_wrt_T[3],
MsqError& err )
{
const double d = det(T);
if (TMetric::invalid_determinant(d)) { // barrier
MSQ_SETERR(err)( barrier_violated_msg, MsqError::BARRIER_VIOLATED );
return false;
}
deriv_wrt_T = T;
pluseq_scaled_I( deriv_wrt_T, -1.0 );
double inv_d = 1.0/d;
result = 0.5 * sqr_Frobenius(deriv_wrt_T) * inv_d;
MsqMatrix<2,2> adjt = transpose_adj(T);
set_scaled_outer_product( second_wrt_T, 2*result*inv_d*inv_d, adjt );
pluseq_scaled_sum_outer_product( second_wrt_T, -inv_d*inv_d, deriv_wrt_T, adjt );
pluseq_scaled_2nd_deriv_of_det( second_wrt_T, -result * inv_d, T );
pluseq_scaled_I( second_wrt_T, inv_d );
deriv_wrt_T -= result * adjt;
deriv_wrt_T *= inv_d;
return true;
}
/** \f$ \frac{\partial^2 \mu}{\partial T^2}
= \frac{1}{\tau} I_4
- \frac{1}{\tau^2} \left( T \otimes \frac{\partial \tau}{\partial T}
+ \frac{\partial \tau}{\partial T} \otimes T \right)
+ \frac{|T|^2}{\tau^3} \left( \frac{\partial \tau}{\partial T} \otimes
\frac{\partial \tau}{\partial T} \right)
- \frac{|T|^2}{2 \tau^3} \frac{\partial^2 \tau}{\partial T^2} \f$
*/
bool Target2DShapeBarrier::evaluate_with_hess( const MsqMatrix<2,2>& A,
const MsqMatrix<2,2>& W,
double& result,
MsqMatrix<2,2>& deriv_wrt_A,
MsqMatrix<2,2> second_wrt_A[3],
MsqError& err )
{
const MsqMatrix<2,2> Winv = inverse(W);
const MsqMatrix<2,2> T = A * Winv;
const double d = det(T);
if (invalid_determinant(d)) { // barrier
result = 0.0;
return false;
}
double inv_d = 1.0/d;
double f1 = sqr_Frobenius(T) * inv_d;
result = 0.5 * f1;
const MsqMatrix<2,2> adjt = transpose_adj(T);
deriv_wrt_A = T;
deriv_wrt_A -= result * adjt;
deriv_wrt_A *= inv_d;
deriv_wrt_A = deriv_wrt_A * transpose(Winv);
set_scaled_outer_product( second_wrt_A, f1 * inv_d * inv_d, adjt );
pluseq_scaled_sum_outer_product( second_wrt_A, -inv_d*inv_d, T, adjt );
pluseq_scaled_I( second_wrt_A, inv_d );
pluseq_scaled_2nd_deriv_of_det( second_wrt_A, -result * inv_d );
second_deriv_wrt_product_factor( second_wrt_A, Winv );
result -= 1.0;
return true;
}
bool TShapeSizeB1::evaluate_with_hess( const MsqMatrix<3,3>& T,
double& result,
MsqMatrix<3,3>& deriv_wrt_T,
MsqMatrix<3,3> second_wrt_T[6],
MsqError& err )
{
const double tau = det(T);
if (invalid_determinant(tau)) { // barrier
result = 0.0;
return false;
}
const MsqMatrix<3,3> adjt = transpose_adj(T);
const double nT = sqr_Frobenius(T);
const double nadj = sqr_Frobenius(adjt);
const double f = 1/(tau*tau);
result = nT + f*nadj - 6;
//! \f$ \frac{\partial}{\partial T} |adj T|^2 \f$
const MsqMatrix<3,3> dNadj_dT = 2 * (nT * T - T * transpose(T) * T);
deriv_wrt_T = T;
deriv_wrt_T -= f/tau * nadj * adjt;
deriv_wrt_T *= 2;
deriv_wrt_T += f * dNadj_dT;
// calculate negative of 2nd wrt T of (|adj T|^2 / tau^2) (sec 3.2.2)
set_scaled_2nd_deriv_norm_sqr_adj( second_wrt_T, f, T );
pluseq_scaled_2nd_deriv_of_det( second_wrt_T, -2*f*f*nadj*tau, T );
pluseq_scaled_outer_product( second_wrt_T, 6*f*f*nadj, adjt );
pluseq_scaled_sum_outer_product( second_wrt_T, -2*f*f *tau, adjt, dNadj_dT );
// calculate 2nd wrt T of this metric
pluseq_scaled_I( second_wrt_T, 2.0 );
return true;
}
template <unsigned DIM> static inline
bool hess( const MsqMatrix<DIM,DIM>& T,
double& result,
MsqMatrix<DIM,DIM>& deriv,
MsqMatrix<DIM,DIM>* second )
{
const double norm = Frobenius(T);
const double invroot = 1.0/DimConst<DIM>::sqrt();
const double tau = det(T);
if (TMetric::invalid_determinant(tau)) { // barrier
result = 0.0;
return false;
}
const double inv_tau = 1.0/tau;
const double invnorm = 1.0/norm;
const double f = norm - invroot * trace(T);
result = 0.5 * inv_tau * f;
const MsqMatrix<DIM,DIM> adjt = transpose_adj(T);
deriv = invnorm * T;
pluseq_scaled_I( deriv, -invroot );
deriv *= 0.5;
deriv -= result * adjt;
deriv *= inv_tau;
const double a = 0.5 * inv_tau * invnorm;
set_scaled_outer_product( second, -a*invnorm*invnorm, T );
pluseq_scaled_I( second, a );
pluseq_scaled_outer_product( second, f*inv_tau*inv_tau*inv_tau, adjt );
pluseq_scaled_2nd_deriv_of_det( second, -0.5*f*inv_tau*inv_tau, T );
pluseq_scaled_sum_outer_product( second, -0.5*inv_tau*inv_tau*invnorm, T, adjt );
pluseq_scaled_sum_outer_product_I( second, 0.5*inv_tau*inv_tau*invroot, adjt );
return true;
}
bool Target3DShapeSizeBarrierAlt1::evaluate_with_hess( const MsqMatrix<3,3>& A,
const MsqMatrix<3,3>& W,
double& result,
MsqMatrix<3,3>& wrt_A,
MsqMatrix<3,3> second[6],
MsqError& err )
{
const MsqMatrix<3,3> Winv = inverse(W);
const MsqMatrix<3,3> T = A * Winv;
const double tau = det(T);
if (invalid_determinant(tau)) { // barrier
result = 0.0;
return false;
}
const double f = sqr_Frobenius(T);
const double g = sqr_Frobenius(adj(T));
result = (f + g)/(6 * tau);
MsqMatrix<3,3> dtau = transpose_adj(T);
MsqMatrix<3,3> dg = -transpose(T) * T;
dg(0,0) += f;
dg(1,1) += f;
dg(2,2) += f;
dg = T * dg;
dg *= 2;
wrt_A = T;
wrt_A += 0.5*dg;
wrt_A *= 1.0/3.0;
wrt_A -= result * dtau;
wrt_A *= 1.0/tau;
wrt_A = wrt_A * transpose(Winv);
set_scaled_2nd_deriv_norm_sqr_adj( second, 1.0/6.0, T );
pluseq_scaled_I( second, 1.0/3.0 );
pluseq_scaled_sum_outer_product( second, -1./3./tau, T, dtau );
pluseq_scaled_sum_outer_product( second, -1./6./tau, dg, dtau );
pluseq_scaled_outer_product( second, 2*result/tau, dtau );
pluseq_scaled_2nd_deriv_of_det( second, -result, T );
hess_scale( second, 1.0/tau );
second_deriv_wrt_product_factor( second, Winv );
result -= 1.0;
return true;
}
bool TShapeSize2DB2::evaluate_with_hess( const MsqMatrix<2,2>& T,
double& result,
MsqMatrix<2,2>& deriv_wrt_T,
MsqMatrix<2,2> second[3],
MsqError& err )
{
const double d = det(T);
if (invalid_determinant(d)) { // barrier
MSQ_SETERR(err)( barrier_violated_msg, MsqError::BARRIER_VIOLATED );
return false;
}
const double frob_sqr = sqr_Frobenius(T);
const double psi = sqrt( frob_sqr + 2.0*det(T) );
const double v = frob_sqr - 2.0 * psi + 2.0;
result = v / (2*d);
// deriv of V wrt T
MsqMatrix<2,2> adjt = transpose_adj(T);
MsqMatrix<2,2> v_wrt_T(T);
if (psi > 1e-50)
{
v_wrt_T *= (1.0 - 1.0/psi);
v_wrt_T -= 1.0/psi * adjt;
v_wrt_T *= 2;
}
else
{
std::cout << "Warning: Division by zero avoided in TShapeSize2DB2::evaluate_with_hess()" << std::endl;
}
// deriv of mu wrt T
deriv_wrt_T = v_wrt_T;
deriv_wrt_T *= 0.5/d;
deriv_wrt_T -= v / (2*d*d) * adjt;
// second of V wrt T
const double s = T(0,1) - T(1,0);
const double tr = trace(T);
const double f = -2.0/(psi*psi*psi);
second[0](0,0) = second[1](0,1) = second[2](1,1) = f*s*s;
second[0](0,1) = second[0](1,0) = second[1](1,1) = -f*s*tr;
second[1](0,0) = second[2](0,1) = second[2](1,0) = f*s*tr;
second[0](1,1) = second[2](0,0) = -(second[1](1,0) = -f*tr*tr);
pluseq_scaled_I( second, 2 );
// second of mu wrt T
const double x = 1.0/(2*d);
second[0] *= x;
second[1] *= x;
second[2] *= x;
pluseq_scaled_2nd_deriv_of_det( second, v/(-2*d*d) );
pluseq_scaled_outer_product( second, v/(d*d*d), adjt );
pluseq_scaled_sum_outer_product( second, -1/(2*d*d), v_wrt_T, adjt );
return true;
}
bool TShapeSize3DB2::evaluate_with_hess( const MsqMatrix<3,3>& T,
double& result,
MsqMatrix<3,3>& wrt_T,
MsqMatrix<3,3> second[6],
MsqError& err )
{
const double tau = det(T);
if (invalid_determinant(tau)) { // barrier
result = 0.0;
return false;
}
const double f = sqr_Frobenius(T);
const double g = sqr_Frobenius(adj(T));
result = (f + g)/(6 * tau);
MsqMatrix<3,3> dtau = transpose_adj(T);
MsqMatrix<3,3> dg = -transpose(T) * T;
dg(0,0) += f;
dg(1,1) += f;
dg(2,2) += f;
dg = T * dg;
dg *= 2;
wrt_T = T;
wrt_T += 0.5*dg;
wrt_T *= 1.0/3.0;
wrt_T -= result * dtau;
wrt_T *= 1.0/tau;
set_scaled_2nd_deriv_norm_sqr_adj( second, 1.0/6.0, T );
pluseq_scaled_I( second, 1.0/3.0 );
pluseq_scaled_sum_outer_product( second, -1./3./tau, T, dtau );
pluseq_scaled_sum_outer_product( second, -1./6./tau, dg, dtau );
pluseq_scaled_outer_product( second, 2*result/tau, dtau );
pluseq_scaled_2nd_deriv_of_det( second, -result, T );
hess_scale( second, 1.0/tau );
result -= 1.0;
return true;
}
bool Target2DShapeOrientBarrier::evaluate_with_hess( const MsqMatrix<2,2>& A,
const MsqMatrix<2,2>& W,
double& result,
MsqMatrix<2,2>& deriv,
MsqMatrix<2,2> second[3],
MsqError& err )
{
const MsqMatrix<2,2> Winv = inverse(W);
const MsqMatrix<2,2> T = A * Winv;
const double norm = Frobenius(T);
const double invroot = 1.0/MSQ_SQRT_TWO;
const double tau = det(T);
if (invalid_determinant(tau)) { // barrier
result = 0.0;
return false;
}
const double inv_tau = 1.0/tau;
const double invnorm = 1.0/norm;
const double f = norm - invroot * trace(T);
result = 0.5 * inv_tau * f;
const MsqMatrix<2,2> adjt = transpose_adj(T);
deriv = invnorm * T;
deriv(0,0) -= invroot;
deriv(1,1) -= invroot;
deriv *= 0.5;
deriv -= result * adjt;
deriv *= inv_tau;
deriv = deriv * transpose(Winv);
const double a = 0.5 * inv_tau * invnorm;
set_scaled_outer_product( second, -a*invnorm*invnorm, T );
pluseq_scaled_I( second, a );
pluseq_scaled_outer_product( second, f*inv_tau*inv_tau*inv_tau, adjt );
pluseq_scaled_2nd_deriv_of_det( second, -0.5*f*inv_tau*inv_tau );
pluseq_scaled_sum_outer_product( second, -0.5*inv_tau*inv_tau*invnorm, T, adjt );
pluseq_scaled_sum_outer_product_I( second, 0.5*inv_tau*inv_tau*invroot, adjt );
second_deriv_wrt_product_factor( second, Winv );
return true;
}
bool TShapeSize3DB4::evaluate_with_hess( const MsqMatrix<3,3>& T,
double& result,
MsqMatrix<3,3>& deriv,
MsqMatrix<3,3> second[6],
MsqError& err )
{
const double tau = det(T);
if (invalid_determinant(tau)) { // barrier
MSQ_SETERR(err)( barrier_violated_msg, MsqError::BARRIER_VIOLATED );
return false;
}
const double norm = Frobenius(T);
const double f = norm*norm/3.0;
const double h = 1/(MSQ_SQRT_THREE * tau);
const double g = norm * h;
const double inv_tau = 1.0/tau;
result = f * g - 1 + mGamma * (tau + inv_tau - 2);
const double g1 = mGamma * (1 - inv_tau*inv_tau);
const MsqMatrix<3,3> adjt = transpose_adj(T);
deriv = g*T;
deriv += (g1 - f*g*inv_tau) * adjt;
if (norm > 1e-50)
{
const double inv_norm = 1/norm;
set_scaled_outer_product( second, h*inv_norm, T );
pluseq_scaled_I( second, norm * h );
pluseq_scaled_2nd_deriv_of_det( second, g1 - f*g*inv_tau, T );
pluseq_scaled_outer_product( second, (f*g + mGamma*inv_tau)*2*inv_tau*inv_tau, adjt );
pluseq_scaled_sum_outer_product( second, -g*inv_tau, T, adjt );
}
else
{
std::cout << "Warning: Division by zero avoided in TShapeSize3DB4::evaluate_with_hess()" << std::endl;
}
return true;
}
bool TShapeSize2DNB2::evaluate_with_hess( const MsqMatrix<2,2>& T,
double& result,
MsqMatrix<2,2>& deriv_wrt_T,
MsqMatrix<2,2> second[3],
MsqError& err )
{
double frob_sqr = sqr_Frobenius(T);
double psi = sqrt( frob_sqr + 2.0*det(T) );
double a = 1e-12;
while (!Mesquite::divide(frob_sqr+2,2*psi,result)) {
MsqMatrix<2,2> Tdelta(T);
Tdelta(0,0) += a;
Tdelta(1,1) += a;
a *= 2.0;
frob_sqr = sqr_Frobenius(Tdelta);
psi = sqrt( frob_sqr + 2.0*det(Tdelta) );
if (psi > 1e-50)
result = (frob_sqr+2) / 2*psi;
}
const double inv_psi = 1.0/psi;
MsqMatrix<2,2> d_psi = T + transpose_adj(T);
d_psi *= inv_psi;
deriv_wrt_T = d_psi;
deriv_wrt_T *= -result;
deriv_wrt_T += T;
deriv_wrt_T *= inv_psi;
set_scaled_2nd_deriv_wrt_psi( second, -result*inv_psi, psi, T );
pluseq_scaled_outer_product( second, 2*result*inv_psi*inv_psi, d_psi );
pluseq_scaled_sum_outer_product( second, -inv_psi*inv_psi, d_psi, T );
pluseq_scaled_I( second, inv_psi );
result -= 1.0;
return true;
}
