NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::MultiVecConstraint::computeDP(
const std::vector<int>& paramIDs,
NOX::Abstract::MultiVector::DenseMatrix& dgdp,
bool isValidG)
{
std::string callingFunction =
"LOCA::MultiContinuation::MultiVecConstraint::computeDP()";
NOX::Abstract::Group::ReturnType status;
// Compute constraints if necessary
if (!isValidG && !isValidConstraints)
status = computeConstraints();
if (!isValidG) {
for (int i=0; i<constraints.numRows(); i++)
dgdp(i,0) = constraints(i,0);
}
// Set rest of dgdp to zero
for (unsigned int j=0; j<paramIDs.size(); j++)
for (int i=0; i<constraints.numRows(); i++)
dgdp(i,j+1) = 0.0;
return status;
}
NOX::Abstract::Group::ReturnType
LOCA::TurningPoint::MinimallyAugmented::Constraint::
computeDP(const std::vector<int>& paramIDs,
NOX::Abstract::MultiVector::DenseMatrix& dgdp,
bool isValidG)
{
std::string callingFunction =
"LOCA::TurningPoint::MinimallyAugmented::Constraint::computeDP()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute sigma, w and v if necessary
if (!isValidConstraints) {
status = computeConstraints();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Compute -(w^T*J*v)_p
status = grpPtr->computeDwtJnDp(paramIDs, (*w_vector)[0], (*v_vector)[0],
dgdp, false);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
dgdp.scale(-1.0/sigma_scale);
// Set the first column of dgdp
dgdp(0,0) = constraints(0,0);
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::TurningPoint::MinimallyAugmented::Constraint::
computeDX()
{
if (isValidDX)
return NOX::Abstract::Group::Ok;
std::string callingFunction =
"LOCA::TurningPoint::MinimallyAugmented::Constraint::computeDX()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute sigma, w and v if necessary
if (!isValidConstraints) {
status = computeConstraints();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Compute -(w^T*J*v)_x
status = grpPtr->computeDwtJnDx((*w_vector)[0], (*v_vector)[0],
(*sigma_x)[0]);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
sigma_x->scale(-1.0/sigma_scale);
isValidDX = true;
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::ArcLengthConstraint::computeDX()
{
if (!isValidConstraints)
return computeConstraints();
else
return NOX::Abstract::Group::Ok;
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::ArcLengthConstraint::computeDP(
const vector<int>& paramIDs,
NOX::Abstract::MultiVector::DenseMatrix& dgdp,
bool isValidG)
{
string callingFunction =
"LOCA::MultiContinuation::ArcLengthConstraint::computeDP()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute constraints if necessary
if (!isValidG && !isValidConstraints) {
status = computeConstraints();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
if (!isValidG) {
for (int i=0; i<constraints.numRows(); i++)
dgdp(i,0) = constraints(i,0);
}
// Get tangent vector
const LOCA::MultiContinuation::ExtendedMultiVector& scaledTangent =
arcLengthGroup->getScaledPredictorTangent();
// If a param ID is equal to a constraint param ID, then that column
// of dgdp is given by that column of the scaled predictor, other wise
// that column is zero
vector<int>::const_iterator it;
int idx;
for (unsigned int i=0; i<paramIDs.size(); i++) {
it = find(conParamIDs.begin(), conParamIDs.end(), paramIDs[i]);
if (it == conParamIDs.end())
for (int k=0; k<constraints.numRows(); k++)
dgdp(k,i+1) = 0.0;
else {
idx = it - conParamIDs.begin();
for (int k=0; k<constraints.numRows(); k++)
dgdp(k,i+1) = scaledTangent.getScalar(k,idx);
}
}
return finalStatus;
}
NOX::Abstract::Group::ReturnType
LOCA::Hopf::MinimallyAugmented::Constraint::
computeDOmega(NOX::Abstract::MultiVector::DenseMatrix& domega)
{
string callingFunction =
"LOCA::Hopf::MinimallyAugmented::Constraint::computeDOmega()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute sigma, w and v if necessary
if (!isValidConstraints) {
status = computeConstraints();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Compute mass matrix M
status = grpPtr->computeShiftedMatrix(0.0, 1.0);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// Compute M*v
Teuchos::RCP<NOX::Abstract::MultiVector> tmp_vector =
v_vector->clone(NOX::ShapeCopy);
status = grpPtr->applyShiftedMatrixMultiVector(*v_vector, *tmp_vector);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// Compute u^T*M*v
NOX::Abstract::MultiVector::DenseMatrix tmp_mat(2,2);
tmp_vector->multiply(1.0, *w_vector, tmp_mat);
// Compute domega
domega(0,0) = tmp_mat(0,1) - tmp_mat(1,0);
domega(1,0) = -(tmp_mat(0,0) + tmp_mat(1,1));
domega.scale(1.0/sigma_scale);
return finalStatus;
}
void rdfcn_neConstraints_lr(double *ts, double *sd, double *sa, double *u, double *p_free, double *pr, double *res, long *dpnd, InfoPtr *info){
if (*dpnd) {
*dpnd = RFCN_DPND(0, *sd, 0, *u, *p_free, 0);
return;
}
// Set phases:
double zVecPtr[NZ];
zVecPtr[phaseL] = flight;
zVecPtr[phaseR] = flight;
syst.setContState(sd);
syst.setDiscState(zVecPtr);
double p[NP];
convertParameters(p_free,p);
syst.setSystParam(p);
syst.setExctState(u);
computeConstraints(p_free[const_sel_free], 0, res);
}
NOX::Abstract::Group::ReturnType
LOCA::Hopf::MinimallyAugmented::Constraint::
computeDP(const vector<int>& paramIDs,
NOX::Abstract::MultiVector::DenseMatrix& dgdp,
bool isValidG)
{
string callingFunction =
"LOCA::Hopf::MinimallyAugmented::Constraint::computeDP()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute sigma, w and v if necessary
if (!isValidConstraints) {
status = computeConstraints();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Compute -(w^T*J*v)_p
NOX::Abstract::MultiVector::DenseMatrix dgdp_real(Teuchos::View, dgdp,
1, paramIDs.size()+1,
0, 0);
NOX::Abstract::MultiVector::DenseMatrix dgdp_imag(Teuchos::View, dgdp,
1, paramIDs.size()+1,
1, 0);
status = grpPtr->computeDwtCeDp(paramIDs,
(*w_vector)[0], (*w_vector)[1],
(*v_vector)[0], (*v_vector)[1],
omega,
dgdp_real, dgdp_imag, false);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
dgdp.scale(-1.0/sigma_scale);
// Set the first column of dgdp
dgdp(0,0) = constraints(0,0);
dgdp(1,0) = constraints(1,0);
return finalStatus;
}
void rdfcn_touchdownLEFT_lR(double *ts, double *sd, double *sa, double *u,
double *p_free, double *pr, double *res, long *dpnd, InfoPtr *info) {
if (*dpnd) {
*dpnd = RFCN_DPND(0, *sd, 0, *u, *p_free, 0);
return;
}
// Set phases:
double zVecPtr[NZ];
zVecPtr[phaseL] = flight;
zVecPtr[phaseR] = stance;
// Update States:
syst.setContState(sd);
syst.setDiscState(zVecPtr);
double p[NP];
convertParameters(p_free,p);
syst.setSystParam(p);
syst.setExctState(u);
double eventVal[NEV];
syst.JumpSet(eventVal);
res[0] = eventVal[touchdownL];
computeConstraints(p_free[const_sel_free], 1, res);
}
NOX::Abstract::Group::ReturnType
LOCA::MultiContinuation::NaturalConstraint::computeDP(
const vector<int>& paramIDs,
NOX::Abstract::MultiVector::DenseMatrix& dgdp,
bool isValidG)
{
string callingFunction =
"LOCA::MultiContinuation::NaturalConstraint::computeDP()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute constraints if necessary
if (!isValidG && !isValidConstraints) {
status = computeConstraints();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
if (!isValidG) {
for (int i=0; i<constraints.numRows(); i++)
dgdp(i,0) = constraints(i,0);
}
// If a param ID is equal to a constraint param ID, then that column
// of dgdp is given by that column of the identity matrix, other wise
// that column is zero
vector<int>::const_iterator it;
for (unsigned int i=0; i<paramIDs.size(); i++) {
for (int k=0; k<constraints.numRows(); k++)
dgdp(k,i+1) = 0.0;
it = find(conParamIDs.begin(), conParamIDs.end(), paramIDs[i]);
if (it != conParamIDs.end())
dgdp(it-conParamIDs.begin(),i+1) = 1.0;
}
return finalStatus;
}
void EMOPSO::function(int particleIndex){
computeObjectives(particleIndex);
computeConstraints(particleIndex);
}
Mahalanobis InfTheoMetricLearner::learnMetric() {
computeConstraints();
int dim = getVectorDim();
Mahalanobis metric = getMetric();
metric.setM(M0);
int simConCount = simConstraints.getConstraintCount();
int disSimConCount = disSimConstraints.getConstraintCount();
vec x1;
vec x2;
double slack = 0.0;
double lambda = 0.0;
InfTheoConstraints* currentConstSet = NULL;
int currentIdx = 0;
int currentSimIdx = 0;
int currentDisSimIdx = 0;
double p = 0.0;
double delta = 0.0;
double alpha = 0.0;
double beta = 0.0;
int i = 0;
for(i = 0; !checkConvergence(metric.getM()) && (simConCount || disSimConCount); ++i) {
// choose sim constraint
if(i % 2 && simConCount) {
currentConstSet = &simConstraints;
currentIdx = currentSimIdx = (currentSimIdx + 1) % simConCount;
// line 3.3
delta = 1;
}
// choose dissim constraint
else if(!(i %2) && disSimConCount) {
currentConstSet = &disSimConstraints;
currentIdx = currentDisSimIdx = (currentDisSimIdx + 1) % disSimConCount;
// line 3.3
delta = -1;
}
// pick some constraint (line 3.1)
x1 = currentConstSet->getX1(currentIdx);
x2 = currentConstSet->getX2(currentIdx);
slack = currentConstSet->getSlack(currentIdx);
lambda = currentConstSet->getLambda(currentIdx);
// line 3.2
p = metric.computeSquaredDistance(x1, x2);
// ignore pairs with x1 == x2
if(p > 0) {
// line 3.4
alpha = min(lambda, delta / 2.0 * (1.0 / p - gamma / slack));
// line 3.5
beta = delta * alpha / (1.0 - delta * alpha * p);
/*
// prints debug information
cout << "p: " << p << endl;
cout << "alpha: " << alpha << endl;
cout << "1.0 / p: " << (1.0 / p) << endl;
cout << "gamma / slack: " << (gamma / slack) << endl;
cout << x1.t() << endl << x2.t() << endl;
cout << "delta / 2.0 * (1.0 / p - gamma / slack): " << (delta / 2.0 * (1.0 / p - gamma / slack)) << endl;
cout << "beta: " << beta << endl;
*/
// line 3.6
double nextSlack = gamma * slack / (gamma + delta * alpha * slack);
currentConstSet->setSlack(currentIdx, nextSlack);
// line 3.7
double nextLambda = lambda - alpha;
currentConstSet->setLambda(currentIdx, nextLambda);
// line 3.8
mat currentM = metric.getM();
currentM = currentM + beta * currentM * (x1 - x2) * (x1 - x2).t() * currentM;
metric.setM(currentM);
}
}
cout << "(InfTheoMetricLearner) metric learning converged in " << i << " iterations" << endl;
return metric;
}
