Merge pull request #156 from borglab/fix/boost-optional

boost::optional<const Ordering &>

gtsam/discrete/DiscreteConditional.cpp

@@ -46,16 +46,20 @@ DiscreteConditional::DiscreteConditional(const size_t nrFrontals,
 
 /* ******************************************************************************** */
 DiscreteConditional::DiscreteConditional(const DecisionTreeFactor& joint,
-    const DecisionTreeFactor& marginal, const boost::optional<Ordering>& orderedKeys) :
+    const DecisionTreeFactor& marginal) :
     BaseFactor(
         ISDEBUG("DiscreteConditional::COUNT") ? joint : joint / marginal), BaseConditional(
             joint.size()-marginal.size()) {
   if (ISDEBUG("DiscreteConditional::DiscreteConditional"))
     cout << (firstFrontalKey()) << endl; //TODO Print all keys
-  if (orderedKeys) {
-    keys_.clear();
-    keys_.insert(keys_.end(), orderedKeys->begin(), orderedKeys->end());
-  }
+}
+
+/* ******************************************************************************** */
+DiscreteConditional::DiscreteConditional(const DecisionTreeFactor& joint,
+    const DecisionTreeFactor& marginal, const Ordering& orderedKeys) :
+    DiscreteConditional(joint, marginal) {
+  keys_.clear();
+  keys_.insert(keys_.end(), orderedKeys.begin(), orderedKeys.end());
 }
 
 /* ******************************************************************************** */

gtsam/discrete/DiscreteConditional.h

@@ -60,7 +60,11 @@ class GTSAM_EXPORT DiscreteConditional: public DecisionTreeFactor,
 
   /** construct P(X|Y)=P(X,Y)/P(Y) from P(X,Y) and P(Y) */
   DiscreteConditional(const DecisionTreeFactor& joint,
-      const DecisionTreeFactor& marginal, const boost::optional<Ordering>& orderedKeys = boost::none);
+      const DecisionTreeFactor& marginal);
+
+  /** construct P(X|Y)=P(X,Y)/P(Y) from P(X,Y) and P(Y) */
+  DiscreteConditional(const DecisionTreeFactor& joint,
+      const DecisionTreeFactor& marginal, const Ordering& orderedKeys);
 
   /**
    * Combine several conditional into a single one.

gtsam/inference/BayesTree-inst.h

@@ -262,7 +262,7 @@ namespace gtsam {
 
     // Now, marginalize out everything that is not variable j
     BayesNetType marginalBN = *cliqueMarginal.marginalMultifrontalBayesNet(
-      Ordering(cref_list_of<1,Key>(j)), boost::none, function);
+      Ordering(cref_list_of<1,Key>(j)), function);
 
     // The Bayes net should contain only one conditional for variable j, so return it
     return marginalBN.front();
@@ -383,7 +383,7 @@ namespace gtsam {
     }
 
     // now, marginalize out everything that is not variable j1 or j2
-    return p_BC1C2.marginalMultifrontalBayesNet(Ordering(cref_list_of<2,Key>(j1)(j2)), boost::none, function);
+    return p_BC1C2.marginalMultifrontalBayesNet(Ordering(cref_list_of<2,Key>(j1)(j2)), function);
   }
 
   /* ************************************************************************* */

gtsam/inference/BayesTreeCliqueBase-inst.h

@@ -171,7 +171,7 @@ namespace gtsam {
 
         // The variables we want to keepSet are exactly the ones in S
         KeyVector indicesS(this->conditional()->beginParents(), this->conditional()->endParents());
-        cachedSeparatorMarginal_ = *p_Cp.marginalMultifrontalBayesNet(Ordering(indicesS), boost::none, function);
+        cachedSeparatorMarginal_ = *p_Cp.marginalMultifrontalBayesNet(Ordering(indicesS), function);
       }
     }
 

gtsam/inference/EliminateableFactorGraph.h

@@ -88,9 +88,6 @@ namespace gtsam {
     /// The function type that does a single dense elimination step on a subgraph.
     typedef boost::function<EliminationResult(const FactorGraphType&, const Ordering&)> Eliminate;
 
-    /// Typedef for an optional ordering as an argument to elimination functions
-    typedef boost::optional<const Ordering&> OptionalOrdering;
-
     /// Typedef for an optional variable index as an argument to elimination functions
     typedef boost::optional<const VariableIndex&> OptionalVariableIndex;
 
@@ -108,24 +105,38 @@ namespace gtsam {
      *  <b> Example - METIS ordering for elimination
      *  \code
      *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(OrderingType::METIS);
+     *  \endcode
+     *
+     *  <b> Example - Reusing an existing VariableIndex to improve performance, and using COLAMD ordering: </b>
+     *  \code
+     *  VariableIndex varIndex(graph); // Build variable index
+     *  Data data = otherFunctionUsingVariableIndex(graph, varIndex); // Other code that uses variable index
+     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(EliminateQR, varIndex, boost::none);
+     *  \endcode
+     *  */
+    boost::shared_ptr<BayesNetType> eliminateSequential(
+      OptionalOrderingType orderingType = boost::none,
+      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
+      OptionalVariableIndex variableIndex = boost::none) const;
+
+    /** Do sequential elimination of all variables to produce a Bayes net.
      *
      *  <b> Example - Full QR elimination in specified order:
      *  \code
-     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(EliminateQR, myOrdering);
+     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(myOrdering, EliminateQR);
      *  \endcode
      *
-     *  <b> Example - Reusing an existing VariableIndex to improve performance, and using COLAMD ordering: </b>
+     *  <b> Example - Reusing an existing VariableIndex to improve performance: </b>
      *  \code
      *  VariableIndex varIndex(graph); // Build variable index
      *  Data data = otherFunctionUsingVariableIndex(graph, varIndex); // Other code that uses variable index
-     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(EliminateQR, boost::none, varIndex);
+     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(myOrdering, EliminateQR, varIndex, boost::none);
      *  \endcode
      *  */
     boost::shared_ptr<BayesNetType> eliminateSequential(
-      OptionalOrdering ordering = boost::none,
+      const Ordering& ordering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none,
-      OptionalOrderingType orderingType = boost::none) const;
+      OptionalVariableIndex variableIndex = boost::none) const;
 
     /** Do multifrontal elimination of all variables to produce a Bayes tree.  If an ordering is not
      *  provided, the ordering will be computed using either COLAMD or METIS, dependeing on
@@ -136,11 +147,6 @@ namespace gtsam {
      *  boost::shared_ptr<GaussianBayesTree> result = graph.eliminateMultifrontal(EliminateCholesky);
      *  \endcode
      *
-     *  <b> Example - Full QR elimination in specified order:
-     *  \code
-     *  boost::shared_ptr<GaussianBayesTree> result = graph.eliminateMultifrontal(EliminateQR, myOrdering);
-     *  \endcode
-     *
      *  <b> Example - Reusing an existing VariableIndex to improve performance, and using COLAMD ordering: </b>
      *  \code
      *  VariableIndex varIndex(graph); // Build variable index
@@ -149,10 +155,23 @@ namespace gtsam {
      *  \endcode
      *  */
     boost::shared_ptr<BayesTreeType> eliminateMultifrontal(
-      OptionalOrdering ordering = boost::none,
+      OptionalOrderingType orderingType = boost::none,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-      OptionalVariableIndex variableIndex = boost::none,
-      OptionalOrderingType orderingType = boost::none) const;
+      OptionalVariableIndex variableIndex = boost::none) const;
+
+    /** Do multifrontal elimination of all variables to produce a Bayes tree.  If an ordering is not
+     *  provided, the ordering will be computed using either COLAMD or METIS, dependeing on
+     *  the parameter orderingType (Ordering::COLAMD or Ordering::METIS)
+     *
+     *  <b> Example - Full QR elimination in specified order:
+     *  \code
+     *  boost::shared_ptr<GaussianBayesTree> result = graph.eliminateMultifrontal(EliminateQR, myOrdering);
+     *  \endcode
+     *  */
+    boost::shared_ptr<BayesTreeType> eliminateMultifrontal(
+      const Ordering& ordering,
+      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
+      OptionalVariableIndex variableIndex = boost::none) const;
 
     /** Do sequential elimination of some variables, in \c ordering provided, to produce a Bayes net
      *  and a remaining factor graph.  This computes the factorization \f$ p(X) = p(A|B) p(B) \f$,
@@ -194,37 +213,63 @@ namespace gtsam {
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
       OptionalVariableIndex variableIndex = boost::none) const;
 
+    /** Compute the marginal of the requested variables and return the result as a Bayes net.  Uses
+     *  COLAMD marginalization ordering by default
+     *  @param variables Determines the variables whose marginal to compute, if provided as an
+     *         Ordering they will be ordered in the returned BayesNet as specified, and if provided
+     *         as a KeyVector they will be ordered using constrained COLAMD.
+     *  @param function Optional dense elimination function, if not provided the default will be
+     *         used.
+     *  @param variableIndex Optional pre-computed VariableIndex for the factor graph, if not
+     *         provided one will be computed. */
+    boost::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
+      boost::variant<const Ordering&, const KeyVector&> variables,
+      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
+      OptionalVariableIndex variableIndex = boost::none) const;
+
     /** Compute the marginal of the requested variables and return the result as a Bayes net.
      *  @param variables Determines the variables whose marginal to compute, if provided as an
      *         Ordering they will be ordered in the returned BayesNet as specified, and if provided
      *         as a KeyVector they will be ordered using constrained COLAMD.
-     *  @param marginalizedVariableOrdering Optional ordering for the variables being marginalized
-     *         out, i.e. all variables not in \c variables.  If this is boost::none, the ordering
-     *         will be computed with COLAMD.
+     *  @param marginalizedVariableOrdering Ordering for the variables being marginalized out,
+     *         i.e. all variables not in \c variables.
      *  @param function Optional dense elimination function, if not provided the default will be
      *         used.
      *  @param variableIndex Optional pre-computed VariableIndex for the factor graph, if not
      *         provided one will be computed. */
     boost::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
       boost::variant<const Ordering&, const KeyVector&> variables,
-      OptionalOrdering marginalizedVariableOrdering = boost::none,
+      const Ordering& marginalizedVariableOrdering,
+      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
+      OptionalVariableIndex variableIndex = boost::none) const;
+
+    /** Compute the marginal of the requested variables and return the result as a Bayes tree.  Uses
+     *  COLAMD marginalization order by default
+     *  @param variables Determines the variables whose marginal to compute, if provided as an
+     *         Ordering they will be ordered in the returned BayesNet as specified, and if provided
+     *         as a KeyVector they will be ordered using constrained COLAMD.
+     *  @param function Optional dense elimination function, if not provided the default will be
+     *         used.
+     *  @param variableIndex Optional pre-computed VariableIndex for the factor graph, if not
+     *         provided one will be computed. */
+    boost::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
+      boost::variant<const Ordering&, const KeyVector&> variables,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
       OptionalVariableIndex variableIndex = boost::none) const;
 
     /** Compute the marginal of the requested variables and return the result as a Bayes tree.
      *  @param variables Determines the variables whose marginal to compute, if provided as an
      *         Ordering they will be ordered in the returned BayesNet as specified, and if provided
      *         as a KeyVector they will be ordered using constrained COLAMD.
-     *  @param marginalizedVariableOrdering Optional ordering for the variables being marginalized
-     *         out, i.e. all variables not in \c variables.  If this is boost::none, the ordering
-     *         will be computed with COLAMD.
+     *  @param marginalizedVariableOrdering Ordering for the variables being marginalized out,
+     *         i.e. all variables not in \c variables.
      *  @param function Optional dense elimination function, if not provided the default will be
      *         used.
      *  @param variableIndex Optional pre-computed VariableIndex for the factor graph, if not
      *         provided one will be computed. */
     boost::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
       boost::variant<const Ordering&, const KeyVector&> variables,
-      OptionalOrdering marginalizedVariableOrdering = boost::none,
+      const Ordering& marginalizedVariableOrdering,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
       OptionalVariableIndex variableIndex = boost::none) const;
 
@@ -241,6 +286,59 @@ namespace gtsam {
 
     // Access the derived factor graph class
     FactorGraphType& asDerived() { return static_cast<FactorGraphType&>(*this); }
+
+  public:
+    /** \deprecated ordering and orderingType shouldn't both be specified */
+    boost::shared_ptr<BayesNetType> eliminateSequential(
+      const Ordering& ordering,
+      const Eliminate& function,
+      OptionalVariableIndex variableIndex,
+      OptionalOrderingType orderingType) const {
+        return eliminateSequential(ordering, function, variableIndex);
+      }
+
+    /** \deprecated orderingType specified first for consistency */
+    boost::shared_ptr<BayesNetType> eliminateSequential(
+      const Eliminate& function,
+      OptionalVariableIndex variableIndex = boost::none,
+      OptionalOrderingType orderingType = boost::none) const {
+        return eliminateSequential(orderingType, function, variableIndex);
+      }
+
+    /** \deprecated ordering and orderingType shouldn't both be specified */
+    boost::shared_ptr<BayesTreeType> eliminateMultifrontal(
+      const Ordering& ordering,
+      const Eliminate& function,
+      OptionalVariableIndex variableIndex,
+      OptionalOrderingType orderingType) const {
+        return eliminateMultifrontal(ordering, function, variableIndex);
+      }
+
+    /** \deprecated orderingType specified first for consistency */
+    boost::shared_ptr<BayesTreeType> eliminateMultifrontal(
+      const Eliminate& function,
+      OptionalVariableIndex variableIndex = boost::none,
+      OptionalOrderingType orderingType = boost::none) const {
+        return eliminateMultifrontal(orderingType, function, variableIndex);
+      }
+
+    /** \deprecated */
+    boost::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
+      boost::variant<const Ordering&, const KeyVector&> variables,
+      boost::none_t,
+      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
+      OptionalVariableIndex variableIndex = boost::none) const {
+          return marginalMultifrontalBayesNet(variables, function, variableIndex);
+      }
+
+    /** \deprecated */
+    boost::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
+      boost::variant<const Ordering&, const KeyVector&> variables,
+      boost::none_t,
+      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
+      OptionalVariableIndex variableIndex = boost::none) const {
+          return marginalMultifrontalBayesTree(variables, function, variableIndex);
+      }
   };
 
 }

gtsam/linear/GaussianBayesNet.cpp

@@ -156,16 +156,17 @@ namespace gtsam {
   }
 
   /* ************************************************************************* */
-  pair<Matrix, Vector> GaussianBayesNet::matrix(boost::optional<const Ordering&> ordering) const {
-    if (ordering) {
-      // Convert to a GaussianFactorGraph and use its machinery
-      GaussianFactorGraph factorGraph(*this);
-      return factorGraph.jacobian(ordering);
-    } else {
-      // recursively call with default ordering
-      const auto defaultOrdering = this->ordering();
-      return matrix(defaultOrdering);
-    }
+  pair<Matrix, Vector> GaussianBayesNet::matrix(const Ordering& ordering) const {
+    // Convert to a GaussianFactorGraph and use its machinery
+    GaussianFactorGraph factorGraph(*this);
+    return factorGraph.jacobian(ordering);
+  }
+
+  /* ************************************************************************* */
+  pair<Matrix, Vector> GaussianBayesNet::matrix() const {
+    // recursively call with default ordering
+    const auto defaultOrdering = this->ordering();
+    return matrix(defaultOrdering);
   }
 
   ///* ************************************************************************* */

gtsam/linear/GaussianBayesNet.h

@@ -92,7 +92,14 @@ namespace gtsam {
      * Will return upper-triangular matrix only when using 'ordering' above.
      * In case Bayes net is incomplete zero columns are added to the end.
      */
-    std::pair<Matrix, Vector> matrix(boost::optional<const Ordering&> ordering = boost::none) const;
+    std::pair<Matrix, Vector> matrix(const Ordering& ordering) const;
+
+    /**
+     * Return (dense) upper-triangular matrix representation
+     * Will return upper-triangular matrix only when using 'ordering' above.
+     * In case Bayes net is incomplete zero columns are added to the end.
+     */
+    std::pair<Matrix, Vector> matrix() const;
 
     /**
      * Optimize along the gradient direction, with a closed-form computation to perform the line