[COMMENTS] Added Some Missing Comments
Ivan Jimenez
parent
1720adbbd7
commit
d4b4b2b31d
|
|
@ -100,7 +100,17 @@ public:
|
|||
return worstFactorIx;
|
||||
}
|
||||
|
||||
/// TODO: comment
|
||||
/* This function will create a dual graph that solves for the
|
||||
* lagrange multipliers for the current working set.
|
||||
* You can use lagrange multipliers as a necessary condition for optimality.
|
||||
* The factor graph that is being solved is f' = -lambda * g'
|
||||
* where f is the optimized function and g is the function resulting from
|
||||
* aggregating the working set.
|
||||
* The lambdas give you information about the feasibility of a constraint.
|
||||
* if lambda < 0 the constraint is Ok
|
||||
* if lambda = 0 you are on the constraint
|
||||
* if lambda > 0 you are violating the constraint.
|
||||
*/
|
||||
GaussianFactorGraph::shared_ptr buildDualGraph(
|
||||
const InequalityFactorGraph& workingSet,
|
||||
const VectorValues& delta) const {
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ private:
|
|||
}
|
||||
|
||||
|
||||
/// Collect all terms of a factor into a container. TODO: avoid memcpy?
|
||||
/// Collect all terms of a factor into a container.
|
||||
std::vector<std::pair<Key, Matrix> > collectTerms(const LinearInequality& factor) const {
|
||||
std::vector<std::pair<Key, Matrix> > terms;
|
||||
for (Factor::const_iterator it = factor.begin(); it != factor.end(); it++) {
|
||||
|
|
|
|||
|
|
@ -35,7 +35,10 @@ public:
|
|||
return keysDim_;
|
||||
}
|
||||
|
||||
/// TODO(comment)
|
||||
/*
|
||||
* Iterates through every factor in a linear graph and generates a
|
||||
* mapping between every factor key and it's corresponding dimensionality.
|
||||
*/
|
||||
template<class LinearGraph>
|
||||
KeyDimMap collectKeysDim(const LinearGraph& linearGraph) const {
|
||||
KeyDimMap keysDim;
|
||||
|
|
@ -51,7 +54,12 @@ public:
|
|||
GaussianFactorGraph::shared_ptr createZeroPriors(const KeyVector& costKeys,
|
||||
const KeyDimMap& keysDim) const;
|
||||
|
||||
/// TODO(comment)
|
||||
/*
|
||||
* This function performs an iteration of the Active Set Method for solving
|
||||
* LP problems. At the end of this iteration the problem should either be found
|
||||
* to be unfeasible, solved or the current state changed to reflect a new
|
||||
* working set.
|
||||
*/
|
||||
LPState iterate(const LPState& state) const;
|
||||
|
||||
/**
|
||||
|
|
@ -73,7 +81,12 @@ public:
|
|||
VectorValues solveWithCurrentWorkingSet(const VectorValues& xk,
|
||||
const InequalityFactorGraph& workingSet) const;
|
||||
|
||||
/// TODO(comment)
|
||||
/*
|
||||
* A dual factor takes the objective function and a set of constraints.
|
||||
* It then creates a least-square approximation of the lagrangian multipliers
|
||||
* for the following problem: f' = - lambda * g' where f is the objection
|
||||
* function g are dual factors and lambda is the lagrangian multiplier.
|
||||
*/
|
||||
JacobianFactor::shared_ptr createDualFactor(Key key,
|
||||
const InequalityFactorGraph& workingSet, const VectorValues& delta) const;
|
||||
|
||||
|
|
@ -82,7 +95,11 @@ public:
|
|||
const InequalityFactorGraph& workingSet, const VectorValues& xk,
|
||||
const VectorValues& p) const;
|
||||
|
||||
/// TODO(comment)
|
||||
/*
|
||||
* Given an initial value this function determine which constraints are active
|
||||
* which can be used to initialize the working set.
|
||||
* A constraint Ax <= b is active if we have an x' s.t. Ax' = b
|
||||
*/
|
||||
InequalityFactorGraph identifyActiveConstraints(
|
||||
const InequalityFactorGraph& inequalities,
|
||||
const VectorValues& initialValues, const VectorValues& duals) const;
|
||||
|
|
|
|||
|
|
@ -10,13 +10,21 @@
|
|||
|
||||
namespace gtsam {
|
||||
|
||||
// TODO: comment
|
||||
/*
|
||||
* This struct contains the state information for a single iteration of an
|
||||
* active set method iteration.
|
||||
*/
|
||||
struct LPState {
|
||||
// TODO: comment member variables
|
||||
// A itermediate value for the value of the final solution.
|
||||
VectorValues values;
|
||||
// Constains the set of duals computed during the iteration that retuned this
|
||||
// state.
|
||||
VectorValues duals;
|
||||
// An inequality Factor Graph that contains only the active constriants.
|
||||
InequalityFactorGraph workingSet;
|
||||
// True if the algorithm has converged to a solution
|
||||
bool converged;
|
||||
// counter for the number of iteration. Incremented at the end of each iter.
|
||||
size_t iterations;
|
||||
|
||||
/// default constructor
|
||||
|
|
|
|||
|
|
@ -79,21 +79,6 @@ JacobianFactor::shared_ptr QPSolver::createDualFactor(
|
|||
}
|
||||
|
||||
//******************************************************************************
|
||||
/* We have to make sure the new solution with alpha satisfies all INACTIVE inequality constraints
|
||||
* If some inactive inequality constraints complain about the full step (alpha = 1),
|
||||
* we have to adjust alpha to stay within the inequality constraints' feasible regions.
|
||||
*
|
||||
* For each inactive inequality j:
|
||||
* - We already have: aj'*xk - bj <= 0, since xk satisfies all inequality constraints
|
||||
* - We want: aj'*(xk + alpha*p) - bj <= 0
|
||||
* - If aj'*p <= 0, we have: aj'*(xk + alpha*p) <= aj'*xk <= bj, for all alpha>0
|
||||
* it's good!
|
||||
* - We only care when aj'*p > 0. In this case, we need to choose alpha so that
|
||||
* aj'*xk + alpha*aj'*p - bj <= 0 --> alpha <= (bj - aj'*xk) / (aj'*p)
|
||||
* We want to step as far as possible, so we should choose alpha = (bj - aj'*xk) / (aj'*p)
|
||||
*
|
||||
* We want the minimum of all those alphas among all inactive inequality.
|
||||
*/
|
||||
boost::tuple<double, int> QPSolver::computeStepSize(
|
||||
const InequalityFactorGraph& workingSet, const VectorValues& xk,
|
||||
const VectorValues& p) const {
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ namespace gtsam {
|
|||
* defined in the QP struct.
|
||||
* Note: This version of QPSolver only works with a feasible initial value.
|
||||
*/
|
||||
//TODO: Remove Vector Values
|
||||
//TODO: Remove Vector Values
|
||||
class QPSolver: public ActiveSetSolver {
|
||||
|
||||
const QP& qp_; //!< factor graphs of the QP problem, can't be modified!
|
||||
|
|
@ -51,7 +51,21 @@ public:
|
|||
JacobianFactor::shared_ptr createDualFactor(Key key,
|
||||
const InequalityFactorGraph& workingSet, const VectorValues& delta) const;
|
||||
|
||||
/// TODO(comment)
|
||||
/* We have to make sure the new solution with alpha satisfies all INACTIVE inequality constraints
|
||||
* If some inactive inequality constraints complain about the full step (alpha = 1),
|
||||
* we have to adjust alpha to stay within the inequality constraints' feasible regions.
|
||||
*
|
||||
* For each inactive inequality j:
|
||||
* - We already have: aj'*xk - bj <= 0, since xk satisfies all inequality constraints
|
||||
* - We want: aj'*(xk + alpha*p) - bj <= 0
|
||||
* - If aj'*p <= 0, we have: aj'*(xk + alpha*p) <= aj'*xk <= bj, for all alpha>0
|
||||
* it's good!
|
||||
* - We only care when aj'*p > 0. In this case, we need to choose alpha so that
|
||||
* aj'*xk + alpha*aj'*p - bj <= 0 --> alpha <= (bj - aj'*xk) / (aj'*p)
|
||||
* We want to step as far as possible, so we should choose alpha = (bj - aj'*xk) / (aj'*p)
|
||||
*
|
||||
* We want the minimum of all those alphas among all inactive inequality.
|
||||
*/
|
||||
boost::tuple<double, int> computeStepSize(
|
||||
const InequalityFactorGraph& workingSet, const VectorValues& xk,
|
||||
const VectorValues& p) const;
|
||||
|
|
|
|||
Loading…
Reference in New Issue