Miscellaneous fixes.

Change-Id: I521e11f2d20bf24960bbc6b5dab4ec8bb1503d23
diff --git a/internal/ceres/cxsparse.cc b/internal/ceres/cxsparse.cc
index f54d24f..ca36ce0 100644
--- a/internal/ceres/cxsparse.cc
+++ b/internal/ceres/cxsparse.cc
@@ -48,7 +48,9 @@
   }
 }
 
-bool CXSparse::SolveCholesky(cs_di* A, cs_dis* factor, double* b) {
+bool CXSparse::SolveCholesky(cs_di* A,
+                             cs_dis* symbolic_factorization,
+                             double* b) {
   // Make sure we have enough scratch space available.
   if (scratch_size_ < A->n) {
     if (scratch_size_ > 0) {
@@ -58,28 +60,29 @@
   }
 
   // Solve using Cholesky factorization
-  csn* N = cs_chol(A, factor);
-  if (N == NULL) {
+  csn* numeric_factorization = cs_chol(A, symbolic_factorization);
+  if (numeric_factorization == NULL) {
     LOG(WARNING) << "Cholesky factorization failed.";
     return false;
   }
 
   // When the Cholesky factorization succeeded, these methods are guaranteed to
-  // succeed as well. In the comments below, "x" refers to the scratch space.
+  // succeeded as well. In the comments below, "x" refers to the scratch space.
+  //
   // Set x = P * b.
-  cs_ipvec(factor->pinv, b, scratch_, A->n);
+  cs_ipvec(symbolic_factorization->pinv, b, scratch_, A->n);
 
   // Set x = L \ x.
-  cs_lsolve(N->L, scratch_);
+  cs_lsolve(numeric_factorization->L, scratch_);
 
   // Set x = L' \ x.
-  cs_ltsolve(N->L, scratch_);
+  cs_ltsolve(numeric_factorization->L, scratch_);
 
   // Set b = P' * x.
-  cs_pvec(factor->pinv, scratch_, b, A->n);
+  cs_pvec(symbolic_factorization->pinv, scratch_, b, A->n);
 
   // Free Cholesky factorization.
-  cs_nfree(N);
+  cs_nfree(numeric_factorization);
   return true;
 }
 
diff --git a/internal/ceres/cxsparse.h b/internal/ceres/cxsparse.h
index a126510..d3b64fc 100644
--- a/internal/ceres/cxsparse.h
+++ b/internal/ceres/cxsparse.h
@@ -51,13 +51,13 @@
   ~CXSparse();
 
   // Solves a symmetric linear system A * x = b using Cholesky factorization.
-  //  A      - The system matrix.
-  //  factor - The symbolic factorization of A. This is obtained from
-  //           AnalyzeCholesky.
-  //  b      - The right hand size of the linear equation. This array will also
-  //           recieve the solution.
+  //  A                      - The system matrix.
+  //  symbolic_factorization - The symbolic factorization of A. This is obtained
+  //                           from AnalyzeCholesky.
+  //  b                      - The right hand size of the linear equation. This
+  //                           array will also recieve the solution.
   // Returns false if Cholesky factorization of A fails.
-  bool SolveCholesky(cs_di* A, cs_dis* factor, double* b);
+  bool SolveCholesky(cs_di* A, cs_dis* symbolic_factorization, double* b);
 
   // Creates a sparse matrix from a compressed-column form. No memory is
   // allocated or copied; the structure A is filled out with info from the