From 78fd7de1b9db549af5838391f47b6bc5c0dc2575 Mon Sep 17 00:00:00 2001
From: dellaert <dellaert@cc.gatech.edu>
Date: Sun, 22 Feb 2015 07:06:41 +0100
Subject: [PATCH] Formatting and comments

---
 gtsam/slam/JacobianSchurFactor.h | 38 ++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/gtsam/slam/JacobianSchurFactor.h b/gtsam/slam/JacobianSchurFactor.h
index d31eea05b..e7f99a736 100644
--- a/gtsam/slam/JacobianSchurFactor.h
+++ b/gtsam/slam/JacobianSchurFactor.h
@@ -23,7 +23,9 @@
 
 namespace gtsam {
 /**
- * JacobianFactor for Schur complement that uses Q noise model
+ * JacobianFactor for Schur complement
+ * Is base class for JacobianQFactor, JacobianFactorQR, and JacobianFactorSVD
+ * Provides raw memory access versions of linear operator.
  */
 template<size_t D, size_t ZDim>
 class JacobianSchurFactor: public JacobianFactor {
@@ -44,10 +46,11 @@ public:
    */
   Vector operator*(const double* x) const {
     Vector Ax = zero(Ab_.rows());
-    if (empty()) return Ax;
+    if (empty())
+      return Ax;
 
     // Just iterate over all A matrices and multiply in correct config part
-    for(size_t pos=0; pos<size(); ++pos)
+    for (size_t pos = 0; pos < size(); ++pos)
       Ax += Ab_(pos) * ConstDMap(x + D * keys_[pos]);
 
     return model_ ? model_->whiten(Ax) : Ax;
@@ -57,17 +60,17 @@ public:
    * @brief double* Transpose Matrix-vector multiply, i.e. x += A'*e
    * RAW memory access! Assumes keys start at 0 and go to M-1, and y is laid out that way
    */
-  void transposeMultiplyAdd(double alpha, const Vector& e, double* x) const
-  {
+  void transposeMultiplyAdd(double alpha, const Vector& e, double* x) const {
     Vector E = alpha * (model_ ? model_->whiten(e) : e);
     // Just iterate over all A matrices and insert Ai^e into y
-    for(size_t pos=0; pos<size(); ++pos)
+    for (size_t pos = 0; pos < size(); ++pos)
       DMap(x + D * keys_[pos]) += Ab_(pos).transpose() * E;
   }
 
   /** y += alpha * A'*A*x */
-  void multiplyHessianAdd(double alpha, const VectorValues& x, VectorValues& y) const {
-    JacobianFactor::multiplyHessianAdd(alpha,x,y);
+  void multiplyHessianAdd(double alpha, const VectorValues& x,
+      VectorValues& y) const {
+    JacobianFactor::multiplyHessianAdd(alpha, x, y);
   }
 
   /**
@@ -75,26 +78,29 @@ public:
    * RAW memory access! Assumes keys start at 0 and go to M-1, and x and and y are laid out that way
    */
   void multiplyHessianAdd(double alpha, const double* x, double* y) const {
-//    Vector Ax = (*this)*x;
-//    this->transposeMultiplyAdd(alpha,Ax,y);
-    if (empty()) return;
+    if (empty())
+      return;
     Vector Ax = zero(Ab_.rows());
 
     // Just iterate over all A matrices and multiply in correct config part
-    for(size_t pos=0; pos<size(); ++pos)
+    for (size_t pos = 0; pos < size(); ++pos)
       Ax += Ab_(pos) * ConstDMap(x + D * keys_[pos]);
 
     // Deal with noise properly, need to Double* whiten as we are dividing by variance
-    if  (model_) { model_->whitenInPlace(Ax); model_->whitenInPlace(Ax); }
+    if (model_) {
+      model_->whitenInPlace(Ax);
+      model_->whitenInPlace(Ax);
+    }
 
     // multiply with alpha
     Ax *= alpha;
 
     // Again iterate over all A matrices and insert Ai^e into y
-    for(size_t pos=0; pos<size(); ++pos)
+    for (size_t pos = 0; pos < size(); ++pos)
       DMap(y + D * keys_[pos]) += Ab_(pos).transpose() * Ax;
   }
 
-}; // class
+};
+// end class JacobianSchurFactor
 
-} // gtsam
+}// end namespace gtsam