diff --git a/examples/nist.cc b/examples/nist.cc
index 244a7f8..7c177e9 100644
--- a/examples/nist.cc
+++ b/examples/nist.cc
@@ -124,12 +124,12 @@
 typedef Eigen::Matrix<double, Dynamic, 1> Vector;
 typedef Eigen::Matrix<double, Dynamic, Dynamic, RowMajor> Matrix;
 
-using std::ifstream;
-using std::vector;
-using std::string;
-using std::atoi;
 using std::atof;
+using std::atoi;
 using std::cout;
+using std::ifstream;
+using std::string;
+using std::vector;
 
 void SplitStringUsingChar(const string& full,
                           const char delim,
diff --git a/internal/ceres/coordinate_descent_minimizer.cc b/internal/ceres/coordinate_descent_minimizer.cc
index b949c00..0c58329 100644
--- a/internal/ceres/coordinate_descent_minimizer.cc
+++ b/internal/ceres/coordinate_descent_minimizer.cc
@@ -107,7 +107,8 @@
     const int num_parameter_blocks = residual_block->NumParameterBlocks();
     for (int j = 0; j < num_parameter_blocks; ++j) {
       ParameterBlock* parameter_block = residual_block->parameter_blocks()[j];
-      const map<ParameterBlock*, int>::const_iterator it = parameter_block_index.find(parameter_block);
+      const map<ParameterBlock*, int>::const_iterator it =
+          parameter_block_index.find(parameter_block);
       if (it != parameter_block_index.end()) {
         residual_blocks_[it->second].push_back(residual_block);
       }
diff --git a/internal/ceres/covariance_impl.h b/internal/ceres/covariance_impl.h
index f2defe8..f73025e 100644
--- a/internal/ceres/covariance_impl.h
+++ b/internal/ceres/covariance_impl.h
@@ -41,7 +41,6 @@
 #include "ceres/suitesparse.h"
 
 namespace ceres {
-
 namespace internal {
 
 class CompressedRowSparseMatrix;
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
index bc1de72..7ac0b40 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
@@ -41,8 +41,8 @@
 namespace ceres {
 namespace internal {
 
-using std::vector;
 using std::copy;
+using std::vector;
 
 class DynamicCompressedRowSparseMatrixTest : public ::testing::Test {
  protected:
diff --git a/internal/ceres/gradient_checking_cost_function.cc b/internal/ceres/gradient_checking_cost_function.cc
index 0ac3fe6..e3cd67c 100644
--- a/internal/ceres/gradient_checking_cost_function.cc
+++ b/internal/ceres/gradient_checking_cost_function.cc
@@ -52,6 +52,8 @@
 namespace ceres {
 namespace internal {
 
+using std::abs;
+using std::max;
 using std::string;
 using std::vector;
 
@@ -71,14 +73,14 @@
   if (!relative_error) {
     relative_error = &local_relative_error;
   }
-  *absolute_error = fabs(x - y);
-  *relative_error = *absolute_error / std::max(fabs(x), fabs(y));
+  *absolute_error = abs(x - y);
+  *relative_error = *absolute_error / max(abs(x), abs(y));
   if (x == 0 || y == 0) {
     // If x or y is exactly zero, then relative difference doesn't have any
     // meaning. Take the absolute difference instead.
     *relative_error = *absolute_error;
   }
-  return fabs(*relative_error) < fabs(relative_precision);
+  return abs(*relative_error) < abs(relative_precision);
 }
 
 class GradientCheckingCostFunction : public CostFunction {
@@ -125,8 +127,7 @@
     vector<Matrix> term_jacobians(block_sizes.size());
     vector<Matrix> finite_difference_jacobians(block_sizes.size());
     vector<double*> term_jacobian_pointers(block_sizes.size());
-    vector<double*> finite_difference_jacobian_pointers(
-        block_sizes.size());
+    vector<double*> finite_difference_jacobian_pointers(block_sizes.size());
     for (int i = 0; i < block_sizes.size(); i++) {
       term_jacobians[i].resize(num_residuals, block_sizes[i]);
       term_jacobian_pointers[i] = term_jacobians[i].data();
@@ -186,8 +187,7 @@
                        relative_precision_,
                        &relative_error,
                        &absolute_error);
-          worst_relative_error = std::max(worst_relative_error,
-                                          relative_error);
+          worst_relative_error = max(worst_relative_error, relative_error);
 
           StringAppendF(&m, "%6d %4d %4d %17g %17g %17g %17g %17g %17g",
                         k, i, j,
@@ -264,8 +264,7 @@
 
   // For every ParameterBlock in problem_impl, create a new parameter
   // block with the same local parameterization and constancy.
-  const vector<ParameterBlock*>& parameter_blocks =
-      program->parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
   for (int i = 0; i < parameter_blocks.size(); ++i) {
     ParameterBlock* parameter_block = parameter_blocks[i];
     gradient_checking_problem_impl->AddParameterBlock(
@@ -282,8 +281,7 @@
   // For every ResidualBlock in problem_impl, create a new
   // ResidualBlock by wrapping its CostFunction inside a
   // GradientCheckingCostFunction.
-  const vector<ResidualBlock*>& residual_blocks =
-      program->residual_blocks();
+  const vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
   for (int i = 0; i < residual_blocks.size(); ++i) {
     ResidualBlock* residual_block = residual_blocks[i];
 
diff --git a/internal/ceres/gradient_checking_cost_function_test.cc b/internal/ceres/gradient_checking_cost_function_test.cc
index 7bdc4da..ed72d21 100644
--- a/internal/ceres/gradient_checking_cost_function_test.cc
+++ b/internal/ceres/gradient_checking_cost_function_test.cc
@@ -48,6 +48,9 @@
 #include "gmock/mock-log.h"
 #include "gtest/gtest.h"
 
+namespace ceres {
+namespace internal {
+
 using std::vector;
 using testing::AllOf;
 using testing::AnyNumber;
@@ -55,9 +58,6 @@
 using testing::ScopedMockLog;
 using testing::_;
 
-namespace ceres {
-namespace internal {
-
 // Pick a (non-quadratic) function whose derivative are easy:
 //
 //    f = exp(- a' x).
diff --git a/internal/ceres/parameter_block_ordering_test.cc b/internal/ceres/parameter_block_ordering_test.cc
index dfc7b20..e5d6d31 100644
--- a/internal/ceres/parameter_block_ordering_test.cc
+++ b/internal/ceres/parameter_block_ordering_test.cc
@@ -84,8 +84,7 @@
 
 TEST_F(SchurOrderingTest, NoFixed) {
   const Program& program = problem_.program();
-  const vector<ParameterBlock*>& parameter_blocks =
-      program.parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
   scoped_ptr<HessianGraph> graph(CreateHessianGraph(program));
 
   const VertexSet& vertices = graph->vertices();
@@ -139,8 +138,7 @@
   problem_.SetParameterBlockConstant(x_);
 
   const Program& program = problem_.program();
-  const vector<ParameterBlock*>& parameter_blocks =
-      program.parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
   scoped_ptr<HessianGraph> graph(CreateHessianGraph(program));
 
   const VertexSet& vertices = graph->vertices();
diff --git a/internal/ceres/program.cc b/internal/ceres/program.cc
index 131802f..2d5c4e2 100644
--- a/internal/ceres/program.cc
+++ b/internal/ceres/program.cc
@@ -50,6 +50,7 @@
 namespace ceres {
 namespace internal {
 
+using std::max;
 using std::set;
 using std::string;
 using std::vector;
@@ -284,10 +285,9 @@
   return reduced_program.release();
 }
 
-bool Program::RemoveFixedBlocks(
-    vector<double*>* removed_parameter_blocks,
-    double* fixed_cost,
-    string* error) {
+bool Program::RemoveFixedBlocks(vector<double*>* removed_parameter_blocks,
+                                double* fixed_cost,
+                                string* error) {
   CHECK_NOTNULL(removed_parameter_blocks);
   CHECK_NOTNULL(fixed_cost);
   CHECK_NOTNULL(error);
@@ -373,8 +373,9 @@
   // blocks in the same residual block are part of
   // parameter_block_ptrs as that would violate the assumption that it
   // is an independent set in the Hessian matrix.
-  vector<ResidualBlock*>::const_iterator it = residual_blocks_.begin();
-  for (; it != residual_blocks_.end(); ++it) {
+  for (vector<ResidualBlock*>::const_iterator it = residual_blocks_.begin();
+       it != residual_blocks_.end();
+       ++it) {
     ParameterBlock* const* parameter_blocks = (*it)->parameter_blocks();
     const int num_parameter_blocks = (*it)->NumParameterBlocks();
     int count = 0;
@@ -469,8 +470,8 @@
   int max_scratch_bytes_for_evaluate = 0;
   for (int i = 0; i < residual_blocks_.size(); ++i) {
     max_scratch_bytes_for_evaluate =
-        std::max(max_scratch_bytes_for_evaluate,
-                 residual_blocks_[i]->NumScratchDoublesForEvaluate());
+        max(max_scratch_bytes_for_evaluate,
+            residual_blocks_[i]->NumScratchDoublesForEvaluate());
   }
   return max_scratch_bytes_for_evaluate;
 }
@@ -485,7 +486,7 @@
       derivatives += residual_block->NumResiduals() *
                      residual_block->parameter_blocks()[j]->LocalSize();
     }
-    max_derivatives = std::max(max_derivatives, derivatives);
+    max_derivatives = max(max_derivatives, derivatives);
   }
   return max_derivatives;
 }
@@ -493,8 +494,8 @@
 int Program::MaxParametersPerResidualBlock() const {
   int max_parameters = 0;
   for (int i = 0; i < residual_blocks_.size(); ++i) {
-    max_parameters = std::max(max_parameters,
-                              residual_blocks_[i]->NumParameterBlocks());
+    max_parameters = max(max_parameters,
+                         residual_blocks_[i]->NumParameterBlocks());
   }
   return max_parameters;
 }
@@ -502,8 +503,7 @@
 int Program::MaxResidualsPerResidualBlock() const {
   int max_residuals = 0;
   for (int i = 0; i < residual_blocks_.size(); ++i) {
-    max_residuals = std::max(max_residuals,
-                             residual_blocks_[i]->NumResiduals());
+    max_residuals = max(max_residuals, residual_blocks_[i]->NumResiduals());
   }
   return max_residuals;
 }
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index d1c1df4..c771a22 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -223,14 +223,14 @@
       program->mutable_parameter_blocks();
   parameter_blocks->clear();
 
-  const map<int, set<double*> >& groups =
-      ordering.group_to_elements();
-
-  map<int, set<double*> >::const_iterator group_it = groups.begin();
-  for ( ; group_it != groups.end(); ++group_it) {
+  const map<int, set<double*> >& groups = ordering.group_to_elements();
+  for (map<int, set<double*> >::const_iterator group_it = groups.begin();
+       group_it != groups.end();
+       ++group_it) {
     const set<double*>& group = group_it->second;
-    set<double*>::const_iterator parameter_block_ptr_it = group.begin();
-    for ( ; parameter_block_ptr_it != group.end(); ++parameter_block_ptr_it) {
+    for (set<double*>::const_iterator parameter_block_ptr_it = group.begin();
+         parameter_block_ptr_it != group.end();
+         ++parameter_block_ptr_it) {
       ProblemImpl::ParameterMap::const_iterator parameter_block_it =
           parameter_map.find(*parameter_block_ptr_it);
       if (parameter_block_it == parameter_map.end()) {
@@ -256,10 +256,8 @@
 
   // Create a histogram of the number of residuals for each E block. There is an
   // extra bucket at the end to catch all non-eliminated F blocks.
-  vector<int> residual_blocks_per_e_block(
-      size_of_first_elimination_group + 1);
-  vector<ResidualBlock*>* residual_blocks =
-      program->mutable_residual_blocks();
+  vector<int> residual_blocks_per_e_block(size_of_first_elimination_group + 1);
+  vector<ResidualBlock*>* residual_blocks = program->mutable_residual_blocks();
   vector<int> min_position_per_residual(residual_blocks->size());
   for (int i = 0; i < residual_blocks->size(); ++i) {
     ResidualBlock* residual_block = (*residual_blocks)[i];
@@ -415,8 +413,7 @@
   Eigen::PermutationMatrix<Eigen::Dynamic, Eigen::Dynamic, int> perm;
   amd_ordering(block_schur_complement, perm);
 
-  const vector<ParameterBlock*>& parameter_blocks =
-      program->parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
   vector<ParameterBlock*> ordering(num_cols);
 
   // The ordering of the first size_of_first_elimination_group does
diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index 74b4a1d..77db982 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -160,8 +160,7 @@
                             linear_solver_ordering,
                             program,
                             &message));
-  const vector<ParameterBlock*>& parameter_blocks =
-      program->parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
 
   EXPECT_EQ(parameter_blocks.size(), 3);
   EXPECT_EQ(parameter_blocks[0]->user_state(), &x);
diff --git a/internal/ceres/rotation_test.cc b/internal/ceres/rotation_test.cc
index 1cf0236..d92ec5f 100644
--- a/internal/ceres/rotation_test.cc
+++ b/internal/ceres/rotation_test.cc
@@ -44,6 +44,10 @@
 namespace ceres {
 namespace internal {
 
+using std::min;
+using std::max;
+using std::numeric_limits;
+using std::string;
 using std::swap;
 
 const double kPi = 3.14159265358979323846;
@@ -55,7 +59,7 @@
 }
 
 // A tolerance value for floating-point comparisons.
-static double const kTolerance = std::numeric_limits<double>::epsilon() * 10;
+static double const kTolerance = numeric_limits<double>::epsilon() * 10;
 
 // Looser tolerance used for numerically unstable conversions.
 static double const kLooseTolerance = 1e-9;
@@ -142,12 +146,12 @@
   Eigen::Vector3d e(expected[0], expected[1], expected[2]);
   const double e_norm = e.norm();
 
-  double delta_norm = std::numeric_limits<double>::max();
+  double delta_norm = numeric_limits<double>::max();
   if (e_norm > 0) {
     // Deal with the sign ambiguity near PI. Since the sign can flip,
     // we take the smaller of the two differences.
     if (fabs(e_norm - kPi) < kLooseTolerance) {
-      delta_norm = std::min((a - e).norm(), (a + e).norm()) / e_norm;
+      delta_norm = min((a - e).norm(), (a + e).norm()) / e_norm;
     } else {
       delta_norm = (a - e).norm() / e_norm;
     }
@@ -243,7 +247,7 @@
 // Test that approximate conversion works for very small angles.
 TEST(Rotation, TinyAngleAxisToQuaternion) {
   // Very small value that could potentially cause underflow.
-  double theta = pow(std::numeric_limits<double>::min(), 0.75);
+  double theta = pow(numeric_limits<double>::min(), 0.75);
   double axis_angle[3] = { theta, 0, 0 };
   double quaternion[4];
   double expected[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
@@ -304,7 +308,7 @@
 // Test that approximate conversion works for very small angles.
 TEST(Rotation, TinyQuaternionToAngleAxis) {
   // Very small value that could potentially cause underflow.
-  double theta = pow(std::numeric_limits<double>::min(), 0.75);
+  double theta = pow(numeric_limits<double>::min(), 0.75);
   double quaternion[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
   double axis_angle[3];
   double expected[3] = { theta, 0, 0 };
@@ -503,7 +507,7 @@
   LOG(INFO) << "Rotation:";
   LOG(INFO) << "EXPECTED        |        ACTUAL";
   for (int i = 0; i < 3; ++i) {
-    std::string line;
+    string line;
     for (int j = 0; j < 3; ++j) {
       StringAppendF(&line, "%g ", kMatrix[i][j]);
     }
@@ -598,7 +602,7 @@
 
     for (int i = 0; i < 3; ++i) {
       EXPECT_NEAR(round_trip[i], axis_angle[i],
-                  std::numeric_limits<double>::epsilon());
+                  numeric_limits<double>::epsilon());
     }
   }
 }
@@ -701,7 +705,7 @@
   if (x == 0 || y == 0) {
     return absdiff <= kTolerance;
   }
-  double reldiff = absdiff / std::max(fabs(x), fabs(y));
+  double reldiff = absdiff / max(fabs(x), fabs(y));
   return reldiff <= kTolerance;
 }
 
@@ -737,11 +741,11 @@
 
 // Log-10 of a value well below machine precision.
 static const int kSmallTinyCutoff =
-    static_cast<int>(2 * log(std::numeric_limits<double>::epsilon())/log(10.0));
+    static_cast<int>(2 * log(numeric_limits<double>::epsilon())/log(10.0));
 
 // Log-10 of a value just below values representable by double.
 static const int kTinyZeroLimit   =
-    static_cast<int>(1 + log(std::numeric_limits<double>::min())/log(10.0));
+    static_cast<int>(1 + log(numeric_limits<double>::min())/log(10.0));
 
 // Test that exact conversion works for small angles when jets are used.
 TEST(Rotation, SmallAngleAxisToQuaternionForJets) {
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index c6414b5..b08bbfe 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -154,15 +154,11 @@
       *error = "Can't use DENSE_NORMAL_CHOLESKY with LAPACK because "
           "LAPACK was not enabled when Ceres was built.";
       return false;
-    }
-
-    if (options.linear_solver_type == DENSE_QR) {
+    } else if (options.linear_solver_type == DENSE_QR) {
       *error = "Can't use DENSE_QR with LAPACK because "
           "LAPACK was not enabled when Ceres was built.";
       return false;
-    }
-
-    if (options.linear_solver_type == DENSE_SCHUR) {
+    } else if (options.linear_solver_type == DENSE_SCHUR) {
       *error = "Can't use DENSE_SCHUR with LAPACK because "
           "LAPACK was not enabled when Ceres was built.";
       return false;
@@ -176,21 +172,15 @@
       *error = "Can't use SPARSE_NORMAL_CHOLESKY with SUITESPARSE because "
              "SuiteSparse was not enabled when Ceres was built.";
       return false;
-    }
-
-    if (options.linear_solver_type == SPARSE_SCHUR) {
+    } else if (options.linear_solver_type == SPARSE_SCHUR) {
       *error = "Can't use SPARSE_SCHUR with SUITESPARSE because "
           "SuiteSparse was not enabled when Ceres was built.";
       return false;
-    }
-
-    if (options.preconditioner_type == CLUSTER_JACOBI) {
+    } else if (options.preconditioner_type == CLUSTER_JACOBI) {
       *error =  "CLUSTER_JACOBI preconditioner not supported. "
           "SuiteSparse was not enabled when Ceres was built.";
       return false;
-    }
-
-    if (options.preconditioner_type == CLUSTER_TRIDIAGONAL) {
+    } else if (options.preconditioner_type == CLUSTER_TRIDIAGONAL) {
       *error =  "CLUSTER_TRIDIAGONAL preconditioner not supported. "
           "SuiteSparse was not enabled when Ceres was built.";
     return false;
@@ -204,9 +194,7 @@
       *error = "Can't use SPARSE_NORMAL_CHOLESKY with CX_SPARSE because "
              "CXSparse was not enabled when Ceres was built.";
       return false;
-    }
-
-    if (options.linear_solver_type == SPARSE_SCHUR) {
+    } else if (options.linear_solver_type == SPARSE_SCHUR) {
       *error = "Can't use SPARSE_SCHUR with CX_SPARSE because "
           "CXSparse was not enabled when Ceres was built.";
       return false;
@@ -221,9 +209,7 @@
           "Eigen's sparse linear algebra was not enabled when Ceres was "
           "built.";
       return false;
-    }
-
-    if (options.linear_solver_type == SPARSE_SCHUR) {
+    } else if (options.linear_solver_type == SPARSE_SCHUR) {
       *error = "Can't use SPARSE_SCHUR with EIGEN_SPARSE because "
           "Eigen's sparse linear algebra was not enabled when Ceres was "
           "built.";
@@ -237,9 +223,7 @@
       *error = "Can't use SPARSE_NORMAL_CHOLESKY as "
           "sparse_linear_algebra_library_type is NO_SPARSE.";
       return false;
-    }
-
-    if (options.linear_solver_type == SPARSE_SCHUR) {
+    } else if (options.linear_solver_type == SPARSE_SCHUR) {
       *error = "Can't use SPARSE_SCHUR as "
           "sparse_linear_algebra_library_type is NO_SPARSE.";
       return false;
diff --git a/internal/ceres/visibility_based_preconditioner.h b/internal/ceres/visibility_based_preconditioner.h
index 10959d6..f898c30 100644
--- a/internal/ceres/visibility_based_preconditioner.h
+++ b/internal/ceres/visibility_based_preconditioner.h
@@ -151,7 +151,7 @@
   LinearSolverTerminationType Factorize();
   void ScaleOffDiagonalCells();
 
-  void ClusterCameras(const std::vector< std::set<int> >& visibility);
+  void ClusterCameras(const std::vector<std::set<int> >& visibility);
   void FlattenMembershipMap(const HashMap<int, int>& membership_map,
                             std::vector<int>* membership_vector) const;
   void ComputeClusterVisibility(