Merged in fix/tabs-to-spaces (pull request #222)

Tab cleanup

examples/RangeISAMExample_plaza2.cpp

@@ -83,7 +83,7 @@ vector<RangeTriple> readTriples() {
 
   while (is) {
     double t, sender, range;
-	size_t receiver;
+    size_t receiver;
     is >> t >> sender >> receiver >> range;
     triples.push_back(RangeTriple(t, receiver, range));
   }

gtsam/base/Matrix.cpp

@@ -189,7 +189,7 @@ void print(const Matrix& A, const string &s, ostream& stream) {
       0, // flags
       " ", // coeffSeparator
       ";\n", // rowSeparator
-	  " \t",  // rowPrefix
+      " \t",  // rowPrefix
       "", // rowSuffix
       "[\n", // matPrefix
       "\n  ]" // matSuffix

gtsam/inference/EliminateableFactorGraph-inst.h

@@ -28,8 +28,8 @@ namespace gtsam {
   template<class FACTORGRAPH>
   boost::shared_ptr<typename EliminateableFactorGraph<FACTORGRAPH>::BayesNetType>
     EliminateableFactorGraph<FACTORGRAPH>::eliminateSequential(
-	OptionalOrdering ordering, const Eliminate& function,
+    OptionalOrdering ordering, const Eliminate& function,
-	OptionalVariableIndex variableIndex, OptionalOrderingType orderingType) const
+    OptionalVariableIndex variableIndex, OptionalOrderingType orderingType) const
   {
     if(ordering && variableIndex) {
       gttic(eliminateSequential);
@@ -65,8 +65,8 @@ namespace gtsam {
   template<class FACTORGRAPH>
   boost::shared_ptr<typename EliminateableFactorGraph<FACTORGRAPH>::BayesTreeType>
     EliminateableFactorGraph<FACTORGRAPH>::eliminateMultifrontal(
-	  OptionalOrdering ordering, const Eliminate& function,
+    OptionalOrdering ordering, const Eliminate& function,
-	  OptionalVariableIndex variableIndex, OptionalOrderingType orderingType) const
+    OptionalVariableIndex variableIndex, OptionalOrderingType orderingType) const
   {
     if(ordering && variableIndex) {
       gttic(eliminateMultifrontal);
@@ -86,16 +86,16 @@ namespace gtsam {
       // If no VariableIndex provided, compute one and call this function again IMPORTANT: we check
       // for no variable index first so that it's always computed if we need to call COLAMD because
       // no Ordering is provided.
-		  return eliminateMultifrontal(ordering, function, VariableIndex(asDerived()), orderingType);
+      return eliminateMultifrontal(ordering, function, VariableIndex(asDerived()), orderingType);
     }
     else /*if(!ordering)*/ {
       // If no Ordering provided, compute one and call this function again.  We are guaranteed to
       // have a VariableIndex already here because we computed one if needed in the previous 'else'
       // block.
-	    if (orderingType == Ordering::METIS)
+      if (orderingType == Ordering::METIS)
-		    return eliminateMultifrontal(Ordering::Metis(asDerived()), function, variableIndex, orderingType);
+        return eliminateMultifrontal(Ordering::Metis(asDerived()), function, variableIndex, orderingType);
-	    else
+      else
-		    return eliminateMultifrontal(Ordering::Colamd(*variableIndex), function, variableIndex, orderingType);
+        return eliminateMultifrontal(Ordering::Colamd(*variableIndex), function, variableIndex, orderingType);
     }
   }
 

gtsam/inference/EliminateableFactorGraph.h

@@ -94,8 +94,8 @@ namespace gtsam {
     /// Typedef for an optional variable index as an argument to elimination functions
     typedef boost::optional<const VariableIndex&> OptionalVariableIndex;
 
-	  /// Typedef for an optional ordering type
+    /// Typedef for an optional ordering type
-	  typedef boost::optional<Ordering::OrderingType> OptionalOrderingType;
+    typedef boost::optional<Ordering::OrderingType> OptionalOrderingType;
 
     /** Do sequential elimination of all variables to produce a Bayes net.  If an ordering is not
      *  provided, the ordering provided by COLAMD will be used.
@@ -104,10 +104,10 @@ namespace gtsam {
      *  \code
      *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(EliminateCholesky);
      *  \endcode
-	   *
+     *
-	   *  <b> Example - METIS ordering for elimination
+     *  <b> Example - METIS ordering for elimination
-	   *  \code
+     *  \code
-	   *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(OrderingType::METIS);
+     *  boost::shared_ptr<GaussianBayesNet> result = graph.eliminateSequential(OrderingType::METIS);
      *  
      *  <b> Example - Full QR elimination in specified order:
      *  \code
@@ -125,7 +125,7 @@ namespace gtsam {
       OptionalOrdering ordering = boost::none,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
       OptionalVariableIndex variableIndex = boost::none,
-	    OptionalOrderingType orderingType = boost::none) const;
+      OptionalOrderingType orderingType = 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
@@ -151,8 +151,8 @@ namespace gtsam {
     boost::shared_ptr<BayesTreeType> eliminateMultifrontal(
       OptionalOrdering ordering = boost::none,
       const Eliminate& function = EliminationTraitsType::DefaultEliminate,
-	    OptionalVariableIndex variableIndex = boost::none,
+      OptionalVariableIndex variableIndex = boost::none,
-	    OptionalOrderingType orderingType = boost::none) const;
+      OptionalOrderingType orderingType = 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$,

gtsam/linear/JacobianFactor.cpp

@@ -349,11 +349,11 @@ void JacobianFactor::print(const string& s,
     const KeyFormatter& formatter) const {
   static const Eigen::IOFormat matlab(
       Eigen::StreamPrecision, // precision
-	  0, // flags
+      0, // flags
       " ", // coeffSeparator
       ";\n", // rowSeparator
-	  "\t",  // rowPrefix
+      "\t",  // rowPrefix
-	  "", // rowSuffix
+      "", // rowSuffix
       "[\n", // matPrefix
       "\n  ]" // matSuffix
       );

gtsam/nonlinear/NonlinearOptimizer.cpp

@@ -110,8 +110,8 @@ VectorValues NonlinearOptimizer::solve(const GaussianFactorGraph &gfg,
     delta = gfg.optimize(*params.ordering, params.getEliminationFunction());
   } else if (params.isSequential()) {
     // Sequential QR or Cholesky (decided by params.getEliminationFunction())
-    delta = gfg.eliminateSequential(*params.ordering, params.getEliminationFunction(), 
+    delta = gfg.eliminateSequential(*params.ordering,
-								     boost::none, params.orderingType)->optimize();
+            params.getEliminationFunction(), boost::none, params.orderingType)->optimize();
   } else if (params.isIterative()) {
 
     // Conjugate Gradient -> needs params.iterativeParams

gtsam/nonlinear/NonlinearOptimizerParams.cpp

@@ -110,14 +110,14 @@ void NonlinearOptimizerParams::print(const std::string& str) const {
 
   switch (orderingType){
   case Ordering::COLAMD:
-	  std::cout << "                   ordering: COLAMD\n";
+    std::cout << "                   ordering: COLAMD\n";
-	  break;
+    break;
   case Ordering::METIS:
-	  std::cout << "                   ordering: METIS\n";
+    std::cout << "                   ordering: METIS\n";
-	  break;
+    break;
   default:
-	  std::cout << "                   ordering: custom\n";
+    std::cout << "                   ordering: custom\n";
-	  break;
+    break;
   }
 
   std::cout.flush();
@@ -165,29 +165,31 @@ NonlinearOptimizerParams::LinearSolverType NonlinearOptimizerParams::linearSolve
 }
 
 /* ************************************************************************* */
-std::string NonlinearOptimizerParams::orderingTypeTranslator(Ordering::OrderingType type) const{
+std::string NonlinearOptimizerParams::orderingTypeTranslator(
-	switch (type) {
+    Ordering::OrderingType type) const {
-	case Ordering::METIS:
+  switch (type) {
-		return "METIS";
+  case Ordering::METIS:
-	case Ordering::COLAMD:
+    return "METIS";
-		return "COLAMD";
+  case Ordering::COLAMD:
-	default:
+    return "COLAMD";
-		if (ordering)
+  default:
-			return "CUSTOM";
+    if (ordering)
-		else
+      return "CUSTOM";
-			throw std::invalid_argument(
+    else
-			"Invalid ordering type: You must provide an ordering for a custom ordering type. See setOrdering");
+      throw std::invalid_argument(
-	}
+          "Invalid ordering type: You must provide an ordering for a custom ordering type. See setOrdering");
+  }
 }
 
 /* ************************************************************************* */
-Ordering::OrderingType NonlinearOptimizerParams::orderingTypeTranslator(const std::string& type) const{
+Ordering::OrderingType NonlinearOptimizerParams::orderingTypeTranslator(
-	if (type == "METIS")
+    const std::string& type) const {
-		return Ordering::METIS;
+  if (type == "METIS")
-	if (type == "COLAMD")
+    return Ordering::METIS;
-		return Ordering::COLAMD;
+  if (type == "COLAMD")
-	throw std::invalid_argument(
+    return Ordering::COLAMD;
-		"Invalid ordering type: You must provide an ordering for a custom ordering type. See setOrdering");
+  throw std::invalid_argument(
+      "Invalid ordering type: You must provide an ordering for a custom ordering type. See setOrdering");
 }
 
 

gtsam/nonlinear/NonlinearOptimizerParams.h

@@ -154,16 +154,16 @@ public:
 
   void setOrdering(const Ordering& ordering) {
     this->ordering = ordering;
-	  this->orderingType = Ordering::CUSTOM;
+    this->orderingType = Ordering::CUSTOM;
   }
 
   std::string getOrderingType() const {
-	  return orderingTypeTranslator(orderingType);
+    return orderingTypeTranslator(orderingType);
   }
 
   // Note that if you want to use a custom ordering, you must set the ordering directly, this will switch to custom type
   void setOrderingType(const std::string& ordering){
-	  orderingType = orderingTypeTranslator(ordering);
+    orderingType = orderingTypeTranslator(ordering);
   }
 
 private: