diff --git a/internal/ceres/accelerate_sparse.cc b/internal/ceres/accelerate_sparse.cc
index eb04e71..d2b642b 100644
--- a/internal/ceres/accelerate_sparse.cc
+++ b/internal/ceres/accelerate_sparse.cc
@@ -33,18 +33,19 @@
 
 #ifndef CERES_NO_ACCELERATE_SPARSE
 
-#include "ceres/accelerate_sparse.h"
-
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include "ceres/accelerate_sparse.h"
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "glog/logging.h"
 
-#define CASESTR(x) case x: return #x
+#define CASESTR(x) \
+  case x:          \
+    return #x
 
 namespace ceres {
 namespace internal {
@@ -68,7 +69,7 @@
 // aligned to kAccelerateRequiredAlignment and returns a pointer to the
 // aligned start.
 void* ResizeForAccelerateAlignment(const size_t required_size,
-                                   std::vector<uint8_t> *workspace) {
+                                   std::vector<uint8_t>* workspace) {
   // As per the Accelerate documentation, all workspace memory passed to the
   // sparse solver functions must be 16-byte aligned.
   constexpr int kAccelerateRequiredAlignment = 16;
@@ -80,29 +81,28 @@
   size_t size_from_aligned_start = workspace->size();
   void* aligned_solve_workspace_start =
       reinterpret_cast<void*>(workspace->data());
-  aligned_solve_workspace_start =
-      std::align(kAccelerateRequiredAlignment,
-                 required_size,
-                 aligned_solve_workspace_start,
-                 size_from_aligned_start);
+  aligned_solve_workspace_start = std::align(kAccelerateRequiredAlignment,
+                                             required_size,
+                                             aligned_solve_workspace_start,
+                                             size_from_aligned_start);
   CHECK(aligned_solve_workspace_start != nullptr)
       << "required_size: " << required_size
       << ", workspace size: " << workspace->size();
   return aligned_solve_workspace_start;
 }
 
-template<typename Scalar>
+template <typename Scalar>
 void AccelerateSparse<Scalar>::Solve(NumericFactorization* numeric_factor,
                                      DenseVector* rhs_and_solution) {
   // From SparseSolve() documentation in Solve.h
-  const int required_size =
-      numeric_factor->solveWorkspaceRequiredStatic +
-      numeric_factor->solveWorkspaceRequiredPerRHS;
-  SparseSolve(*numeric_factor, *rhs_and_solution,
+  const int required_size = numeric_factor->solveWorkspaceRequiredStatic +
+                            numeric_factor->solveWorkspaceRequiredPerRHS;
+  SparseSolve(*numeric_factor,
+              *rhs_and_solution,
               ResizeForAccelerateAlignment(required_size, &solve_workspace_));
 }
 
-template<typename Scalar>
+template <typename Scalar>
 typename AccelerateSparse<Scalar>::ASSparseMatrix
 AccelerateSparse<Scalar>::CreateSparseMatrixTransposeView(
     CompressedRowSparseMatrix* A) {
@@ -112,7 +112,7 @@
   //
   // Accelerate's columnStarts is a long*, not an int*.  These types might be
   // different (e.g. ARM on iOS) so always make a copy.
-  column_starts_.resize(A->num_rows() +1); // +1 for final column length.
+  column_starts_.resize(A->num_rows() + 1);  // +1 for final column length.
   std::copy_n(A->rows(), column_starts_.size(), &column_starts_[0]);
 
   ASSparseMatrix At;
@@ -136,29 +136,31 @@
   return At;
 }
 
-template<typename Scalar>
+template <typename Scalar>
 typename AccelerateSparse<Scalar>::SymbolicFactorization
 AccelerateSparse<Scalar>::AnalyzeCholesky(ASSparseMatrix* A) {
   return SparseFactor(SparseFactorizationCholesky, A->structure);
 }
 
-template<typename Scalar>
+template <typename Scalar>
 typename AccelerateSparse<Scalar>::NumericFactorization
 AccelerateSparse<Scalar>::Cholesky(ASSparseMatrix* A,
                                    SymbolicFactorization* symbolic_factor) {
   return SparseFactor(*symbolic_factor, *A);
 }
 
-template<typename Scalar>
+template <typename Scalar>
 void AccelerateSparse<Scalar>::Cholesky(ASSparseMatrix* A,
                                         NumericFactorization* numeric_factor) {
   // From SparseRefactor() documentation in Solve.h
-  const int required_size = std::is_same<Scalar, double>::value
-      ? numeric_factor->symbolicFactorization.workspaceSize_Double
-      : numeric_factor->symbolicFactorization.workspaceSize_Float;
-  return SparseRefactor(*A, numeric_factor,
-                        ResizeForAccelerateAlignment(required_size,
-                                                     &factorization_workspace_));
+  const int required_size =
+      std::is_same<Scalar, double>::value
+          ? numeric_factor->symbolicFactorization.workspaceSize_Double
+          : numeric_factor->symbolicFactorization.workspaceSize_Float;
+  return SparseRefactor(
+      *A,
+      numeric_factor,
+      ResizeForAccelerateAlignment(required_size, &factorization_workspace_));
 }
 
 // Instantiate only for the specific template types required/supported s/t the
@@ -166,34 +168,33 @@
 template class AccelerateSparse<double>;
 template class AccelerateSparse<float>;
 
-template<typename Scalar>
-std::unique_ptr<SparseCholesky>
-AppleAccelerateCholesky<Scalar>::Create(OrderingType ordering_type) {
+template <typename Scalar>
+std::unique_ptr<SparseCholesky> AppleAccelerateCholesky<Scalar>::Create(
+    OrderingType ordering_type) {
   return std::unique_ptr<SparseCholesky>(
       new AppleAccelerateCholesky<Scalar>(ordering_type));
 }
 
-template<typename Scalar>
+template <typename Scalar>
 AppleAccelerateCholesky<Scalar>::AppleAccelerateCholesky(
     const OrderingType ordering_type)
     : ordering_type_(ordering_type) {}
 
-template<typename Scalar>
+template <typename Scalar>
 AppleAccelerateCholesky<Scalar>::~AppleAccelerateCholesky() {
   FreeSymbolicFactorization();
   FreeNumericFactorization();
 }
 
-template<typename Scalar>
+template <typename Scalar>
 CompressedRowSparseMatrix::StorageType
 AppleAccelerateCholesky<Scalar>::StorageType() const {
   return CompressedRowSparseMatrix::LOWER_TRIANGULAR;
 }
 
-template<typename Scalar>
-LinearSolverTerminationType
-AppleAccelerateCholesky<Scalar>::Factorize(CompressedRowSparseMatrix* lhs,
-                                           std::string* message) {
+template <typename Scalar>
+LinearSolverTerminationType AppleAccelerateCholesky<Scalar>::Factorize(
+    CompressedRowSparseMatrix* lhs, std::string* message) {
   CHECK_EQ(lhs->storage_type(), StorageType());
   if (lhs == NULL) {
     *message = "Failure: Input lhs is NULL.";
@@ -234,11 +235,9 @@
   return LINEAR_SOLVER_SUCCESS;
 }
 
-template<typename Scalar>
-LinearSolverTerminationType
-AppleAccelerateCholesky<Scalar>::Solve(const double* rhs,
-                                       double* solution,
-                                       std::string* message) {
+template <typename Scalar>
+LinearSolverTerminationType AppleAccelerateCholesky<Scalar>::Solve(
+    const double* rhs, double* solution, std::string* message) {
   CHECK_EQ(numeric_factor_->status, SparseStatusOK)
       << "Solve called without a call to Factorize first ("
       << SparseStatusToString(numeric_factor_->status) << ").";
@@ -262,7 +261,7 @@
   return LINEAR_SOLVER_SUCCESS;
 }
 
-template<typename Scalar>
+template <typename Scalar>
 void AppleAccelerateCholesky<Scalar>::FreeSymbolicFactorization() {
   if (symbolic_factor_) {
     SparseCleanup(*symbolic_factor_);
@@ -270,7 +269,7 @@
   }
 }
 
-template<typename Scalar>
+template <typename Scalar>
 void AppleAccelerateCholesky<Scalar>::FreeNumericFactorization() {
   if (numeric_factor_) {
     SparseCleanup(*numeric_factor_);
@@ -283,7 +282,7 @@
 template class AppleAccelerateCholesky<double>;
 template class AppleAccelerateCholesky<float>;
 
-}
-}
+}  // namespace internal
+}  // namespace ceres
 
 #endif  // CERES_NO_ACCELERATE_SPARSE
diff --git a/internal/ceres/accelerate_sparse.h b/internal/ceres/accelerate_sparse.h
index 43b4ea5..e53758d 100644
--- a/internal/ceres/accelerate_sparse.h
+++ b/internal/ceres/accelerate_sparse.h
@@ -40,9 +40,9 @@
 #include <string>
 #include <vector>
 
+#include "Accelerate.h"
 #include "ceres/linear_solver.h"
 #include "ceres/sparse_cholesky.h"
-#include "Accelerate.h"
 
 namespace ceres {
 namespace internal {
@@ -50,11 +50,10 @@
 class CompressedRowSparseMatrix;
 class TripletSparseMatrix;
 
-template<typename Scalar>
-struct SparseTypesTrait {
-};
+template <typename Scalar>
+struct SparseTypesTrait {};
 
-template<>
+template <>
 struct SparseTypesTrait<double> {
   typedef DenseVector_Double DenseVector;
   typedef SparseMatrix_Double SparseMatrix;
@@ -62,7 +61,7 @@
   typedef SparseOpaqueFactorization_Double NumericFactorization;
 };
 
-template<>
+template <>
 struct SparseTypesTrait<float> {
   typedef DenseVector_Float DenseVector;
   typedef SparseMatrix_Float SparseMatrix;
@@ -70,14 +69,16 @@
   typedef SparseOpaqueFactorization_Float NumericFactorization;
 };
 
-template<typename Scalar>
+template <typename Scalar>
 class AccelerateSparse {
  public:
   using DenseVector = typename SparseTypesTrait<Scalar>::DenseVector;
   // Use ASSparseMatrix to avoid collision with ceres::internal::SparseMatrix.
   using ASSparseMatrix = typename SparseTypesTrait<Scalar>::SparseMatrix;
-  using SymbolicFactorization = typename SparseTypesTrait<Scalar>::SymbolicFactorization;
-  using NumericFactorization = typename SparseTypesTrait<Scalar>::NumericFactorization;
+  using SymbolicFactorization =
+      typename SparseTypesTrait<Scalar>::SymbolicFactorization;
+  using NumericFactorization =
+      typename SparseTypesTrait<Scalar>::NumericFactorization;
 
   // Solves a linear system given its symbolic (reference counted within
   // NumericFactorization) and numeric factorization.
@@ -109,7 +110,7 @@
 
 // An implementation of SparseCholesky interface using Apple's Accelerate
 // framework.
-template<typename Scalar>
+template <typename Scalar>
 class AppleAccelerateCholesky : public SparseCholesky {
  public:
   // Factory
@@ -122,7 +123,7 @@
                                         std::string* message) final;
   LinearSolverTerminationType Solve(const double* rhs,
                                     double* solution,
-                                    std::string* message) final ;
+                                    std::string* message) final;
 
  private:
   AppleAccelerateCholesky(const OrderingType ordering_type);
@@ -132,15 +133,15 @@
   const OrderingType ordering_type_;
   AccelerateSparse<Scalar> as_;
   std::unique_ptr<typename AccelerateSparse<Scalar>::SymbolicFactorization>
-  symbolic_factor_;
+      symbolic_factor_;
   std::unique_ptr<typename AccelerateSparse<Scalar>::NumericFactorization>
-  numeric_factor_;
+      numeric_factor_;
   // Copy of rhs/solution if Scalar != double (necessitating a copy).
   Eigen::Matrix<Scalar, Eigen::Dynamic, 1> scalar_rhs_and_solution_;
 };
 
-}
-}
+}  // namespace internal
+}  // namespace ceres
 
 #endif  // CERES_NO_ACCELERATE_SPARSE
 
diff --git a/internal/ceres/array_utils.cc b/internal/ceres/array_utils.cc
index 32459e6..6bffd84 100644
--- a/internal/ceres/array_utils.cc
+++ b/internal/ceres/array_utils.cc
@@ -35,6 +35,7 @@
 #include <cstddef>
 #include <string>
 #include <vector>
+
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
 namespace ceres {
@@ -45,7 +46,7 @@
 bool IsArrayValid(const int size, const double* x) {
   if (x != NULL) {
     for (int i = 0; i < size; ++i) {
-      if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue))  {
+      if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue)) {
         return false;
       }
     }
@@ -59,7 +60,7 @@
   }
 
   for (int i = 0; i < size; ++i) {
-    if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue))  {
+    if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue)) {
       return i;
     }
   }
@@ -92,14 +93,13 @@
 void MapValuesToContiguousRange(const int size, int* array) {
   std::vector<int> unique_values(array, array + size);
   std::sort(unique_values.begin(), unique_values.end());
-  unique_values.erase(std::unique(unique_values.begin(),
-                                  unique_values.end()),
+  unique_values.erase(std::unique(unique_values.begin(), unique_values.end()),
                       unique_values.end());
 
   for (int i = 0; i < size; ++i) {
-    array[i] = std::lower_bound(unique_values.begin(),
-                                unique_values.end(),
-                                array[i]) - unique_values.begin();
+    array[i] =
+        std::lower_bound(unique_values.begin(), unique_values.end(), array[i]) -
+        unique_values.begin();
   }
 }
 
diff --git a/internal/ceres/array_utils.h b/internal/ceres/array_utils.h
index 1d55733..b068721 100644
--- a/internal/ceres/array_utils.h
+++ b/internal/ceres/array_utils.h
@@ -44,6 +44,7 @@
 #define CERES_INTERNAL_ARRAY_UTILS_H_
 
 #include <string>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
diff --git a/internal/ceres/array_utils_test.cc b/internal/ceres/array_utils_test.cc
index 77379d9..6c0ea84 100644
--- a/internal/ceres/array_utils_test.cc
+++ b/internal/ceres/array_utils_test.cc
@@ -30,9 +30,10 @@
 
 #include "ceres/array_utils.h"
 
-#include <limits>
 #include <cmath>
+#include <limits>
 #include <vector>
+
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc b/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc
index 2533ba6..87e0067 100644
--- a/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc
+++ b/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc
@@ -55,13 +55,14 @@
 
   template <typename T>
   bool operator()(const T* const* parameters, T* residuals) const {
-    return Apply(parameters, residuals,
-                 std::make_index_sequence<kNumParameterBlocks>());
+    return Apply(
+        parameters, residuals, std::make_index_sequence<kNumParameterBlocks>());
   }
 
  private:
   template <typename T, size_t... Indices>
-  bool Apply(const T* const* parameters, T* residuals,
+  bool Apply(const T* const* parameters,
+             T* residuals,
              std::index_sequence<Indices...>) const {
     return cost_function_(parameters[Indices]..., residuals);
   }
@@ -109,7 +110,9 @@
 
 template <>
 struct CostFunctionFactory<kNotDynamic> {
-  template <typename CostFunctor, int kNumResiduals, int... Ns,
+  template <typename CostFunctor,
+            int kNumResiduals,
+            int... Ns,
             typename... Args>
   static std::unique_ptr<ceres::CostFunction> Create(Args&&... args) {
     return std::make_unique<
@@ -120,7 +123,9 @@
 
 template <>
 struct CostFunctionFactory<kDynamic> {
-  template <typename CostFunctor, int kNumResiduals, int... Ns,
+  template <typename CostFunctor,
+            int kNumResiduals,
+            int... Ns,
             typename... Args>
   static std::unique_ptr<ceres::CostFunction> Create(Args&&... args) {
     constexpr const int kNumParameterBlocks = sizeof...(Ns);
@@ -147,8 +152,8 @@
   double* jacobians[] = {jacobian_values.data()};
 
   std::unique_ptr<ceres::CostFunction> cost_function =
-      CostFunctionFactory<kIsDynamic>::template Create<
-          ConstantCostFunction<kParameterBlockSize>, 1, 1>();
+      CostFunctionFactory<kIsDynamic>::
+          template Create<ConstantCostFunction<kParameterBlockSize>, 1, 1>();
 
   for (auto _ : state) {
     cost_function->Evaluate(parameters, residuals.data(), jacobians);
@@ -186,13 +191,12 @@
   double residuals[1];
   double* jacobians[] = {jacobian1};
 
-  std::unique_ptr<ceres::CostFunction> cost_function =
-      CostFunctionFactory<kIsDynamic>::template Create<Linear1CostFunction, 1,
-                                                       1>();
+  std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+      kIsDynamic>::template Create<Linear1CostFunction, 1, 1>();
 
   for (auto _ : state) {
-    cost_function->Evaluate(parameters, residuals,
-                            state.range(0) ? jacobians : nullptr);
+    cost_function->Evaluate(
+        parameters, residuals, state.range(0) ? jacobians : nullptr);
   }
 }
 BENCHMARK_TEMPLATE(BM_Linear1AutoDiff, kNotDynamic)->Arg(0)->Arg(1);
@@ -207,13 +211,12 @@
   double residuals[10];
   double* jacobians[] = {jacobian1};
 
-  std::unique_ptr<ceres::CostFunction> cost_function =
-      CostFunctionFactory<kIsDynamic>::template Create<Linear10CostFunction, 10,
-                                                       10>();
+  std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+      kIsDynamic>::template Create<Linear10CostFunction, 10, 10>();
 
   for (auto _ : state) {
-    cost_function->Evaluate(parameters, residuals,
-                            state.range(0) ? jacobians : nullptr);
+    cost_function->Evaluate(
+        parameters, residuals, state.range(0) ? jacobians : nullptr);
   }
 }
 BENCHMARK_TEMPLATE(BM_Linear10AutoDiff, kNotDynamic)->Arg(0)->Arg(1);
@@ -255,8 +258,8 @@
           x, y);
 
   for (auto _ : state) {
-    cost_function->Evaluate(parameters, &residuals,
-                            state.range(0) ? jacobians : nullptr);
+    cost_function->Evaluate(
+        parameters, &residuals, state.range(0) ? jacobians : nullptr);
   }
 }
 BENCHMARK_TEMPLATE(BM_Rat43AutoDiff, kNotDynamic)->Arg(0)->Arg(1);
@@ -275,13 +278,12 @@
 
   const double x = 0.2;
   const double y = 0.3;
-  std::unique_ptr<ceres::CostFunction> cost_function =
-      CostFunctionFactory<kIsDynamic>::template Create<SnavelyReprojectionError,
-                                                       2, 9, 3>(x, y);
+  std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+      kIsDynamic>::template Create<SnavelyReprojectionError, 2, 9, 3>(x, y);
 
   for (auto _ : state) {
-    cost_function->Evaluate(parameters, residuals,
-                            state.range(0) ? jacobians : nullptr);
+    cost_function->Evaluate(
+        parameters, residuals, state.range(0) ? jacobians : nullptr);
   }
 }
 
@@ -338,14 +340,16 @@
   intrinsics << 128, 128, 1, -1, 0.5, 0.5;
 
   std::unique_ptr<ceres::CostFunction> cost_function =
-      CostFunctionFactory<kIsDynamic>::template Create<
-          FunctorType, FunctorType::PATCH_SIZE, FunctorType::POSE_SIZE,
-          FunctorType::POSE_SIZE, FunctorType::POINT_SIZE>(
+      CostFunctionFactory<kIsDynamic>::template Create<FunctorType,
+                                                       FunctorType::PATCH_SIZE,
+                                                       FunctorType::POSE_SIZE,
+                                                       FunctorType::POSE_SIZE,
+                                                       FunctorType::POINT_SIZE>(
           intensities_host, bearings_host, image_target, intrinsics);
 
   for (auto _ : state) {
-    cost_function->Evaluate(parameters, residuals,
-                            state.range(0) ? jacobians : nullptr);
+    cost_function->Evaluate(
+        parameters, residuals, state.range(0) ? jacobians : nullptr);
   }
 }
 
@@ -376,8 +380,8 @@
           q_i_j, t_i_j);
 
   for (auto _ : state) {
-    cost_function->Evaluate(parameters, residuals,
-                            state.range(0) ? jacobians : nullptr);
+    cost_function->Evaluate(
+        parameters, residuals, state.range(0) ? jacobians : nullptr);
   }
 }
 
@@ -396,24 +400,25 @@
   auto x = Eigen::Vector3d(0.5, 0.7, -0.1).normalized();
   auto y = Eigen::Vector3d(0.2, -0.2, -0.2).normalized();
 
-  double* parameters[7] = {material, c.data(), n.data(), v.data(),
-                           l.data(), x.data(), y.data()};
+  double* parameters[7] = {
+      material, c.data(), n.data(), v.data(), l.data(), x.data(), y.data()};
 
   double jacobian[(10 + 6 * 3) * 3];
   double residuals[3];
+  // clang-format off
   double* jacobians[7] = {
       jacobian + 0,      jacobian + 10 * 3, jacobian + 13 * 3,
       jacobian + 16 * 3, jacobian + 19 * 3, jacobian + 22 * 3,
       jacobian + 25 * 3,
   };
+  // clang-format on
 
-  std::unique_ptr<ceres::CostFunction> cost_function =
-      CostFunctionFactory<kIsDynamic>::template Create<FunctorType, 3, 10, 3, 3,
-                                                       3, 3, 3, 3>();
+  std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+      kIsDynamic>::template Create<FunctorType, 3, 10, 3, 3, 3, 3, 3, 3>();
 
   for (auto _ : state) {
-    cost_function->Evaluate(parameters, residuals,
-                            state.range(0) ? jacobians : nullptr);
+    cost_function->Evaluate(
+        parameters, residuals, state.range(0) ? jacobians : nullptr);
   }
 }
 
diff --git a/internal/ceres/autodiff_benchmarks/brdf_cost_function.h b/internal/ceres/autodiff_benchmarks/brdf_cost_function.h
index eba0932..9d7c0cc 100644
--- a/internal/ceres/autodiff_benchmarks/brdf_cost_function.h
+++ b/internal/ceres/autodiff_benchmarks/brdf_cost_function.h
@@ -190,10 +190,10 @@
 
   template <typename T>
   inline T GTR2Aniso(const T& n_dot_h,
-              const T& h_dot_x,
-              const T& h_dot_y,
-              const T& ax,
-              const T& ay) const {
+                     const T& h_dot_x,
+                     const T& h_dot_y,
+                     const T& ax,
+                     const T& ay) const {
     return T(1) / (T(M_PI) * ax * ay *
                    Square(Square(h_dot_x / ax) + Square(h_dot_y / ay) +
                           n_dot_h * n_dot_h));
@@ -205,10 +205,10 @@
   }
 
   template <typename Derived1, typename Derived2>
-  inline typename Derived1::PlainObject
-  Lerp(const Eigen::MatrixBase<Derived1>& a,
-       const Eigen::MatrixBase<Derived2>& b,
-       typename Derived1::Scalar alpha) const {
+  inline typename Derived1::PlainObject Lerp(
+      const Eigen::MatrixBase<Derived1>& a,
+      const Eigen::MatrixBase<Derived2>& b,
+      typename Derived1::Scalar alpha) const {
     return (typename Derived1::Scalar(1) - alpha) * a + alpha * b;
   }
 
diff --git a/internal/ceres/autodiff_cost_function_test.cc b/internal/ceres/autodiff_cost_function_test.cc
index 53461cb..cc340f6 100644
--- a/internal/ceres/autodiff_cost_function_test.cc
+++ b/internal/ceres/autodiff_cost_function_test.cc
@@ -32,30 +32,30 @@
 
 #include <memory>
 
-#include "gtest/gtest.h"
-#include "ceres/cost_function.h"
 #include "ceres/array_utils.h"
+#include "ceres/cost_function.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
 
 class BinaryScalarCost {
  public:
-  explicit BinaryScalarCost(double a): a_(a) {}
+  explicit BinaryScalarCost(double a) : a_(a) {}
   template <typename T>
-  bool operator()(const T* const x, const T* const y,
-                  T* cost) const {
-    cost[0] = x[0] * y[0] + x[1] * y[1]  - T(a_);
+  bool operator()(const T* const x, const T* const y, T* cost) const {
+    cost[0] = x[0] * y[0] + x[1] * y[1] - T(a_);
     return true;
   }
+
  private:
   double a_;
 };
 
 TEST(AutodiffCostFunction, BilinearDifferentiationTest) {
-  CostFunction* cost_function  =
-    new AutoDiffCostFunction<BinaryScalarCost, 1, 2, 2>(
-        new BinaryScalarCost(1.0));
+  CostFunction* cost_function =
+      new AutoDiffCostFunction<BinaryScalarCost, 1, 2, 2>(
+          new BinaryScalarCost(1.0));
 
   double** parameters = new double*[2];
   parameters[0] = new double[2];
@@ -112,10 +112,19 @@
 };
 
 TEST(AutodiffCostFunction, ManyParameterAutodiffInstantiates) {
-  CostFunction* cost_function  =
-      new AutoDiffCostFunction<
-          TenParameterCost, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1>(
-              new TenParameterCost);
+  CostFunction* cost_function =
+      new AutoDiffCostFunction<TenParameterCost,
+                               1,
+                               1,
+                               1,
+                               1,
+                               1,
+                               1,
+                               1,
+                               1,
+                               1,
+                               1,
+                               1>(new TenParameterCost);
 
   double** parameters = new double*[10];
   double** jacobians = new double*[10];
diff --git a/internal/ceres/autodiff_local_parameterization_test.cc b/internal/ceres/autodiff_local_parameterization_test.cc
index df7723d..36fd3c9 100644
--- a/internal/ceres/autodiff_local_parameterization_test.cc
+++ b/internal/ceres/autodiff_local_parameterization_test.cc
@@ -28,8 +28,10 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-#include <cmath>
 #include "ceres/autodiff_local_parameterization.h"
+
+#include <cmath>
+
 #include "ceres/local_parameterization.h"
 #include "ceres/rotation.h"
 #include "gtest/gtest.h"
@@ -48,8 +50,7 @@
 };
 
 TEST(AutoDiffLocalParameterizationTest, IdentityParameterization) {
-  AutoDiffLocalParameterization<IdentityPlus, 3, 3>
-      parameterization;
+  AutoDiffLocalParameterization<IdentityPlus, 3, 3> parameterization;
 
   double x[3] = {1.0, 2.0, 3.0};
   double delta[3] = {0.0, 1.0, 2.0};
@@ -71,9 +72,8 @@
 }
 
 struct ScaledPlus {
-  explicit ScaledPlus(const double &scale_factor)
-     : scale_factor_(scale_factor)
-  {}
+  explicit ScaledPlus(const double& scale_factor)
+      : scale_factor_(scale_factor) {}
 
   template <typename T>
   bool operator()(const T* x, const T* delta, T* x_plus_delta) const {
@@ -89,8 +89,8 @@
 TEST(AutoDiffLocalParameterizationTest, ScaledParameterization) {
   const double kTolerance = 1e-14;
 
-  AutoDiffLocalParameterization<ScaledPlus, 3, 3>
-      parameterization(new ScaledPlus(1.2345));
+  AutoDiffLocalParameterization<ScaledPlus, 3, 3> parameterization(
+      new ScaledPlus(1.2345));
 
   double x[3] = {1.0, 2.0, 3.0};
   double delta[3] = {0.0, 1.0, 2.0};
@@ -112,7 +112,7 @@
 }
 
 struct QuaternionPlus {
-  template<typename T>
+  template <typename T>
   bool operator()(const T* x, const T* delta, T* x_plus_delta) const {
     const T squared_norm_delta =
         delta[0] * delta[0] + delta[1] * delta[1] + delta[2] * delta[2];
@@ -147,7 +147,6 @@
   double x_plus_delta_ref[4] = {0.0, 0.0, 0.0, 0.0};
   double jacobian_ref[12];
 
-
   QuaternionParameterization ref_parameterization;
   ref_parameterization.Plus(x, delta, x_plus_delta_ref);
   ref_parameterization.ComputeJacobian(x, jacobian_ref);
@@ -162,20 +161,22 @@
     EXPECT_NEAR(x_plus_delta[i], x_plus_delta_ref[i], kTolerance);
   }
 
+  // clang-format off
   const double x_plus_delta_norm =
       sqrt(x_plus_delta[0] * x_plus_delta[0] +
            x_plus_delta[1] * x_plus_delta[1] +
            x_plus_delta[2] * x_plus_delta[2] +
            x_plus_delta[3] * x_plus_delta[3]);
+  // clang-format on
 
   EXPECT_NEAR(x_plus_delta_norm, 1.0, kTolerance);
 
   for (int i = 0; i < 12; ++i) {
     EXPECT_TRUE(std::isfinite(jacobian[i]));
     EXPECT_NEAR(jacobian[i], jacobian_ref[i], kTolerance)
-        << "Jacobian mismatch: i = " << i
-        << "\n Expected \n" << ConstMatrixRef(jacobian_ref, 4, 3)
-        << "\n Actual \n" << ConstMatrixRef(jacobian, 4, 3);
+        << "Jacobian mismatch: i = " << i << "\n Expected \n"
+        << ConstMatrixRef(jacobian_ref, 4, 3) << "\n Actual \n"
+        << ConstMatrixRef(jacobian, 4, 3);
   }
 }
 
@@ -185,13 +186,14 @@
   QuaternionParameterizationTestHelper(x, delta);
 }
 
-
 TEST(AutoDiffLocalParameterization, QuaternionParameterizationNearZeroTest) {
   double x[4] = {0.52, 0.25, 0.15, 0.45};
+  // clang-format off
   double norm_x = sqrt(x[0] * x[0] +
                        x[1] * x[1] +
                        x[2] * x[2] +
                        x[3] * x[3]);
+  // clang-format on
   for (int i = 0; i < 4; ++i) {
     x[i] = x[i] / norm_x;
   }
@@ -206,10 +208,12 @@
 
 TEST(AutoDiffLocalParameterization, QuaternionParameterizationNonZeroTest) {
   double x[4] = {0.52, 0.25, 0.15, 0.45};
+  // clang-format off
   double norm_x = sqrt(x[0] * x[0] +
                        x[1] * x[1] +
                        x[2] * x[2] +
                        x[3] * x[3]);
+  // clang-format on
 
   for (int i = 0; i < 4; ++i) {
     x[i] = x[i] / norm_x;
diff --git a/internal/ceres/blas.cc b/internal/ceres/blas.cc
index 3ba63bb..f8d006e 100644
--- a/internal/ceres/blas.cc
+++ b/internal/ceres/blas.cc
@@ -29,6 +29,7 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/blas.h"
+
 #include "ceres/internal/port.h"
 #include "glog/logging.h"
 
diff --git a/internal/ceres/block_evaluate_preparer.cc b/internal/ceres/block_evaluate_preparer.cc
index 59c0d3e..7db96d9 100644
--- a/internal/ceres/block_evaluate_preparer.cc
+++ b/internal/ceres/block_evaluate_preparer.cc
@@ -31,6 +31,7 @@
 #include "ceres/block_evaluate_preparer.h"
 
 #include <vector>
+
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/casts.h"
 #include "ceres/parameter_block.h"
@@ -53,10 +54,8 @@
                                     double** jacobians) {
   // If the overall jacobian is not available, use the scratch space.
   if (jacobian == NULL) {
-    scratch_evaluate_preparer_.Prepare(residual_block,
-                                       residual_block_index,
-                                       jacobian,
-                                       jacobians);
+    scratch_evaluate_preparer_.Prepare(
+        residual_block, residual_block_index, jacobian, jacobians);
     return;
   }
 
diff --git a/internal/ceres/block_jacobi_preconditioner.cc b/internal/ceres/block_jacobi_preconditioner.cc
index 772c7af..6f37aca 100644
--- a/internal/ceres/block_jacobi_preconditioner.cc
+++ b/internal/ceres/block_jacobi_preconditioner.cc
@@ -30,9 +30,9 @@
 
 #include "ceres/block_jacobi_preconditioner.h"
 
+#include "ceres/block_random_access_diagonal_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
-#include "ceres/block_random_access_diagonal_matrix.h"
 #include "ceres/casts.h"
 #include "ceres/internal/eigen.h"
 
@@ -65,13 +65,11 @@
       const int col_block_size = bs->cols[block_id].size;
 
       int r, c, row_stride, col_stride;
-      CellInfo* cell_info = m_->GetCell(block_id, block_id,
-                                        &r, &c,
-                                        &row_stride, &col_stride);
+      CellInfo* cell_info =
+          m_->GetCell(block_id, block_id, &r, &c, &row_stride, &col_stride);
       MatrixRef m(cell_info->values, row_stride, col_stride);
-      ConstMatrixRef b(values + cells[j].position,
-                       row_block_size,
-                       col_block_size);
+      ConstMatrixRef b(
+          values + cells[j].position, row_block_size, col_block_size);
       m.block(r, c, col_block_size, col_block_size) += b.transpose() * b;
     }
   }
@@ -82,9 +80,7 @@
     for (int i = 0; i < bs->cols.size(); ++i) {
       const int block_size = bs->cols[i].size;
       int r, c, row_stride, col_stride;
-      CellInfo* cell_info = m_->GetCell(i, i,
-                                        &r, &c,
-                                        &row_stride, &col_stride);
+      CellInfo* cell_info = m_->GetCell(i, i, &r, &c, &row_stride, &col_stride);
       MatrixRef m(cell_info->values, row_stride, col_stride);
       m.block(r, c, block_size, block_size).diagonal() +=
           ConstVectorRef(D + position, block_size).array().square().matrix();
diff --git a/internal/ceres/block_jacobi_preconditioner.h b/internal/ceres/block_jacobi_preconditioner.h
index 856b506..4ede9b9 100644
--- a/internal/ceres/block_jacobi_preconditioner.h
+++ b/internal/ceres/block_jacobi_preconditioner.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_BLOCK_JACOBI_PRECONDITIONER_H_
 
 #include <memory>
+
 #include "ceres/block_random_access_diagonal_matrix.h"
 #include "ceres/preconditioner.h"
 
diff --git a/internal/ceres/block_jacobi_preconditioner_test.cc b/internal/ceres/block_jacobi_preconditioner_test.cc
index 4a9a871..cc582c6 100644
--- a/internal/ceres/block_jacobi_preconditioner_test.cc
+++ b/internal/ceres/block_jacobi_preconditioner_test.cc
@@ -32,16 +32,16 @@
 
 #include <memory>
 #include <vector>
-#include "ceres/block_random_access_diagonal_matrix.h"
-#include "ceres/linear_least_squares_problems.h"
-#include "ceres/block_sparse_matrix.h"
-#include "gtest/gtest.h"
+
 #include "Eigen/Dense"
+#include "ceres/block_random_access_diagonal_matrix.h"
+#include "ceres/block_sparse_matrix.h"
+#include "ceres/linear_least_squares_problems.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
 
-
 class BlockJacobiPreconditionerTest : public ::testing::Test {
  protected:
   void SetUpFromProblemId(int problem_id) {
@@ -56,7 +56,10 @@
     A->ToDenseMatrix(&dense_a);
     dense_ata = dense_a.transpose() * dense_a;
     dense_ata += VectorRef(D.get(), A->num_cols())
-        .array().square().matrix().asDiagonal();
+                     .array()
+                     .square()
+                     .matrix()
+                     .asDiagonal();
   }
 
   void VerifyDiagonalBlocks(const int problem_id) {
@@ -73,17 +76,14 @@
     for (int i = 0; i < bs->cols.size(); ++i) {
       const int block_size = bs->cols[i].size;
       int r, c, row_stride, col_stride;
-      CellInfo* cell_info = m->GetCell(i, i,
-                                       &r, &c,
-                                       &row_stride, &col_stride);
+      CellInfo* cell_info = m->GetCell(i, i, &r, &c, &row_stride, &col_stride);
       MatrixRef m(cell_info->values, row_stride, col_stride);
       Matrix actual_block_inverse = m.block(r, c, block_size, block_size);
-      Matrix expected_block = dense_ata.block(bs->cols[i].position,
-                                              bs->cols[i].position,
-                                              block_size,
-                                              block_size);
+      Matrix expected_block = dense_ata.block(
+          bs->cols[i].position, bs->cols[i].position, block_size, block_size);
       const double residual = (actual_block_inverse * expected_block -
-                               Matrix::Identity(block_size, block_size)).norm();
+                               Matrix::Identity(block_size, block_size))
+                                  .norm();
       EXPECT_NEAR(residual, 0.0, 1e-12) << "Block: " << i;
     }
   }
@@ -93,13 +93,9 @@
   Matrix dense_ata;
 };
 
-TEST_F(BlockJacobiPreconditionerTest, SmallProblem) {
-  VerifyDiagonalBlocks(2);
-}
+TEST_F(BlockJacobiPreconditionerTest, SmallProblem) { VerifyDiagonalBlocks(2); }
 
-TEST_F(BlockJacobiPreconditionerTest, LargeProblem) {
-  VerifyDiagonalBlocks(3);
-}
+TEST_F(BlockJacobiPreconditionerTest, LargeProblem) { VerifyDiagonalBlocks(3); }
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/block_jacobian_writer.cc b/internal/ceres/block_jacobian_writer.cc
index 6998bd6..17c157b 100644
--- a/internal/ceres/block_jacobian_writer.cc
+++ b/internal/ceres/block_jacobian_writer.cc
@@ -32,11 +32,11 @@
 
 #include "ceres/block_evaluate_preparer.h"
 #include "ceres/block_sparse_matrix.h"
+#include "ceres/internal/eigen.h"
+#include "ceres/internal/port.h"
 #include "ceres/parameter_block.h"
 #include "ceres/program.h"
 #include "ceres/residual_block.h"
-#include "ceres/internal/eigen.h"
-#include "ceres/internal/port.h"
 
 namespace ceres {
 namespace internal {
diff --git a/internal/ceres/block_jacobian_writer.h b/internal/ceres/block_jacobian_writer.h
index c94a0d3..8054d7b 100644
--- a/internal/ceres/block_jacobian_writer.h
+++ b/internal/ceres/block_jacobian_writer.h
@@ -39,6 +39,7 @@
 #define CERES_INTERNAL_BLOCK_JACOBIAN_WRITER_H_
 
 #include <vector>
+
 #include "ceres/evaluator.h"
 #include "ceres/internal/port.h"
 
@@ -52,8 +53,7 @@
 // TODO(sameeragarwal): This class needs documemtation.
 class BlockJacobianWriter {
  public:
-  BlockJacobianWriter(const Evaluator::Options& options,
-                      Program* program);
+  BlockJacobianWriter(const Evaluator::Options& options, Program* program);
 
   // JacobianWriter interface.
 
diff --git a/internal/ceres/block_random_access_dense_matrix.cc b/internal/ceres/block_random_access_dense_matrix.cc
index f567aa5..386f81e 100644
--- a/internal/ceres/block_random_access_dense_matrix.cc
+++ b/internal/ceres/block_random_access_dense_matrix.cc
@@ -31,6 +31,7 @@
 #include "ceres/block_random_access_dense_matrix.h"
 
 #include <vector>
+
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 
@@ -59,8 +60,7 @@
 
 // Assume that the user does not hold any locks on any cell blocks
 // when they are calling SetZero.
-BlockRandomAccessDenseMatrix::~BlockRandomAccessDenseMatrix() {
-}
+BlockRandomAccessDenseMatrix::~BlockRandomAccessDenseMatrix() {}
 
 CellInfo* BlockRandomAccessDenseMatrix::GetCell(const int row_block_id,
                                                 const int col_block_id,
diff --git a/internal/ceres/block_random_access_dense_matrix.h b/internal/ceres/block_random_access_dense_matrix.h
index 8c5e252..be67f34 100644
--- a/internal/ceres/block_random_access_dense_matrix.h
+++ b/internal/ceres/block_random_access_dense_matrix.h
@@ -31,11 +31,10 @@
 #ifndef CERES_INTERNAL_BLOCK_RANDOM_ACCESS_DENSE_MATRIX_H_
 #define CERES_INTERNAL_BLOCK_RANDOM_ACCESS_DENSE_MATRIX_H_
 
-#include "ceres/block_random_access_matrix.h"
-
 #include <memory>
 #include <vector>
 
+#include "ceres/block_random_access_matrix.h"
 #include "ceres/internal/port.h"
 
 namespace ceres {
diff --git a/internal/ceres/block_random_access_dense_matrix_test.cc b/internal/ceres/block_random_access_dense_matrix_test.cc
index 8a5ba59..0736d56 100644
--- a/internal/ceres/block_random_access_dense_matrix_test.cc
+++ b/internal/ceres/block_random_access_dense_matrix_test.cc
@@ -28,10 +28,12 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-#include <vector>
-#include "gtest/gtest.h"
 #include "ceres/block_random_access_dense_matrix.h"
+
+#include <vector>
+
 #include "ceres/internal/eigen.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -54,8 +56,7 @@
       int col;
       int row_stride;
       int col_stride;
-      CellInfo* cell =
-          m.GetCell(i, j, &row, &col, &row_stride, &col_stride);
+      CellInfo* cell = m.GetCell(i, j, &row, &col, &row_stride, &col_stride);
 
       EXPECT_TRUE(cell != NULL);
       EXPECT_EQ(row, row_idx);
@@ -84,11 +85,10 @@
       int col;
       int row_stride;
       int col_stride;
-      CellInfo* cell = m.GetCell(
-          i, j, &row, &col, &row_stride, &col_stride);
-      MatrixRef(cell->values, row_stride, col_stride).block(
-          row, col, blocks[i], blocks[j]) =
-          (i+1) * (j+1) * Matrix::Ones(blocks[i], blocks[j]);
+      CellInfo* cell = m.GetCell(i, j, &row, &col, &row_stride, &col_stride);
+      MatrixRef(cell->values, row_stride, col_stride)
+          .block(row, col, blocks[i], blocks[j]) =
+          (i + 1) * (j + 1) * Matrix::Ones(blocks[i], blocks[j]);
     }
   }
 
diff --git a/internal/ceres/block_random_access_diagonal_matrix.cc b/internal/ceres/block_random_access_diagonal_matrix.cc
index 526d173..08f6d7f 100644
--- a/internal/ceres/block_random_access_diagonal_matrix.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix.cc
@@ -63,9 +63,8 @@
     num_nonzeros += blocks_[i] * blocks_[i];
   }
 
-  VLOG(1) << "Matrix Size [" << num_cols
-          << "," << num_cols
-          << "] " << num_nonzeros;
+  VLOG(1) << "Matrix Size [" << num_cols << "," << num_cols << "] "
+          << num_nonzeros;
 
   tsm_.reset(new TripletSparseMatrix(num_cols, num_cols, num_nonzeros));
   tsm_->set_num_nonzeros(num_nonzeros);
@@ -116,8 +115,7 @@
 // when they are calling SetZero.
 void BlockRandomAccessDiagonalMatrix::SetZero() {
   if (tsm_->num_nonzeros()) {
-    VectorRef(tsm_->mutable_values(),
-              tsm_->num_nonzeros()).setZero();
+    VectorRef(tsm_->mutable_values(), tsm_->num_nonzeros()).setZero();
   }
 }
 
@@ -126,11 +124,8 @@
   for (int i = 0; i < blocks_.size(); ++i) {
     const int block_size = blocks_[i];
     MatrixRef block(values, block_size, block_size);
-    block =
-        block
-        .selfadjointView<Eigen::Upper>()
-        .llt()
-        .solve(Matrix::Identity(block_size, block_size));
+    block = block.selfadjointView<Eigen::Upper>().llt().solve(
+        Matrix::Identity(block_size, block_size));
     values += block_size * block_size;
   }
 }
diff --git a/internal/ceres/block_random_access_diagonal_matrix.h b/internal/ceres/block_random_access_diagonal_matrix.h
index 3bda7d1..4d3e1cc 100644
--- a/internal/ceres/block_random_access_diagonal_matrix.h
+++ b/internal/ceres/block_random_access_diagonal_matrix.h
@@ -50,7 +50,8 @@
  public:
   // blocks is an array of block sizes.
   explicit BlockRandomAccessDiagonalMatrix(const std::vector<int>& blocks);
-  BlockRandomAccessDiagonalMatrix(const BlockRandomAccessDiagonalMatrix&) = delete;
+  BlockRandomAccessDiagonalMatrix(const BlockRandomAccessDiagonalMatrix&) =
+      delete;
   void operator=(const BlockRandomAccessDiagonalMatrix&) = delete;
 
   // The destructor is not thread safe. It assumes that no one is
diff --git a/internal/ceres/block_random_access_diagonal_matrix_test.cc b/internal/ceres/block_random_access_diagonal_matrix_test.cc
index a54595c..e384dac 100644
--- a/internal/ceres/block_random_access_diagonal_matrix_test.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix_test.cc
@@ -28,15 +28,16 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/block_random_access_diagonal_matrix.h"
+
 #include <limits>
 #include <memory>
 #include <vector>
 
-#include "ceres/block_random_access_diagonal_matrix.h"
+#include "Eigen/Cholesky"
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
-#include "Eigen/Cholesky"
 
 namespace ceres {
 namespace internal {
@@ -49,7 +50,7 @@
     blocks.push_back(4);
     blocks.push_back(5);
     const int num_rows = 3 + 4 + 5;
-    num_nonzeros_ =  3 * 3 + 4 * 4 + 5 * 5;
+    num_nonzeros_ = 3 * 3 + 4 * 4 + 5 * 5;
 
     m_.reset(new BlockRandomAccessDiagonalMatrix(blocks));
 
@@ -66,9 +67,8 @@
 
       for (int j = 0; j < blocks.size(); ++j) {
         col_block_id = j;
-        CellInfo* cell =  m_->GetCell(row_block_id, col_block_id,
-                                    &row, &col,
-                                    &row_stride, &col_stride);
+        CellInfo* cell = m_->GetCell(
+            row_block_id, col_block_id, &row, &col, &row_stride, &col_stride);
         // Off diagonal entries are not present.
         if (i != j) {
           EXPECT_TRUE(cell == NULL);
@@ -82,11 +82,11 @@
         EXPECT_EQ(col_stride, blocks[col_block_id]);
 
         // Write into the block
-        MatrixRef(cell->values, row_stride, col_stride).block(
-            row, col, blocks[row_block_id], blocks[col_block_id]) =
-            (row_block_id + 1) * (col_block_id +1) *
-            Matrix::Ones(blocks[row_block_id], blocks[col_block_id])
-            + Matrix::Identity(blocks[row_block_id], blocks[row_block_id]);
+        MatrixRef(cell->values, row_stride, col_stride)
+            .block(row, col, blocks[row_block_id], blocks[col_block_id]) =
+            (row_block_id + 1) * (col_block_id + 1) *
+                Matrix::Ones(blocks[row_block_id], blocks[col_block_id]) +
+            Matrix::Identity(blocks[row_block_id], blocks[row_block_id]);
       }
     }
   }
@@ -107,28 +107,31 @@
   double kTolerance = 1e-14;
 
   // (0,0)
-  EXPECT_NEAR((dense.block(0, 0, 3, 3) -
-               (Matrix::Ones(3, 3) + Matrix::Identity(3, 3))).norm(),
-              0.0,
-              kTolerance);
+  EXPECT_NEAR(
+      (dense.block(0, 0, 3, 3) - (Matrix::Ones(3, 3) + Matrix::Identity(3, 3)))
+          .norm(),
+      0.0,
+      kTolerance);
 
   // (1,1)
   EXPECT_NEAR((dense.block(3, 3, 4, 4) -
-               (2 * 2 * Matrix::Ones(4, 4) + Matrix::Identity(4, 4))).norm(),
+               (2 * 2 * Matrix::Ones(4, 4) + Matrix::Identity(4, 4)))
+                  .norm(),
               0.0,
               kTolerance);
 
   // (1,1)
   EXPECT_NEAR((dense.block(7, 7, 5, 5) -
-               (3 * 3 * Matrix::Ones(5, 5) + Matrix::Identity(5, 5))).norm(),
+               (3 * 3 * Matrix::Ones(5, 5) + Matrix::Identity(5, 5)))
+                  .norm(),
               0.0,
               kTolerance);
 
   // There is nothing else in the matrix besides these four blocks.
-  EXPECT_NEAR(dense.norm(),
-              sqrt(6 * 1.0 + 3 * 4.0 +
-                   12 * 16.0 + 4 * 25.0 +
-                   20 * 81.0 + 5 * 100.0), kTolerance);
+  EXPECT_NEAR(
+      dense.norm(),
+      sqrt(6 * 1.0 + 3 * 4.0 + 12 * 16.0 + 4 * 25.0 + 20 * 81.0 + 5 * 100.0),
+      kTolerance);
 }
 
 TEST_F(BlockRandomAccessDiagonalMatrixTest, RightMultiply) {
@@ -139,7 +142,7 @@
   Vector x = Vector::Random(dense.rows());
   Vector expected_y = dense * x;
   Vector actual_y = Vector::Zero(dense.rows());
-  m_->RightMultiply(x.data(),  actual_y.data());
+  m_->RightMultiply(x.data(), actual_y.data());
   EXPECT_NEAR((expected_y - actual_y).norm(), 0, kTolerance);
 }
 
diff --git a/internal/ceres/block_random_access_matrix.cc b/internal/ceres/block_random_access_matrix.cc
index 347d765..ea88855 100644
--- a/internal/ceres/block_random_access_matrix.cc
+++ b/internal/ceres/block_random_access_matrix.cc
@@ -33,8 +33,7 @@
 namespace ceres {
 namespace internal {
 
-BlockRandomAccessMatrix::~BlockRandomAccessMatrix() {
-}
+BlockRandomAccessMatrix::~BlockRandomAccessMatrix() {}
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/block_random_access_sparse_matrix.cc b/internal/ceres/block_random_access_sparse_matrix.cc
index 9c16454..c28b7ce 100644
--- a/internal/ceres/block_random_access_sparse_matrix.cc
+++ b/internal/ceres/block_random_access_sparse_matrix.cc
@@ -50,10 +50,8 @@
 using std::vector;
 
 BlockRandomAccessSparseMatrix::BlockRandomAccessSparseMatrix(
-    const vector<int>& blocks,
-    const set<pair<int, int>>& block_pairs)
-    : kMaxRowBlocks(10 * 1000 * 1000),
-      blocks_(blocks) {
+    const vector<int>& blocks, const set<pair<int, int>>& block_pairs)
+    : kMaxRowBlocks(10 * 1000 * 1000), blocks_(blocks) {
   CHECK_LT(blocks.size(), kMaxRowBlocks);
 
   // Build the row/column layout vector and count the number of scalar
@@ -75,9 +73,8 @@
     num_nonzeros += row_block_size * col_block_size;
   }
 
-  VLOG(1) << "Matrix Size [" << num_cols
-          << "," << num_cols
-          << "] " << num_nonzeros;
+  VLOG(1) << "Matrix Size [" << num_cols << "," << num_cols << "] "
+          << num_nonzeros;
 
   tsm_.reset(new TripletSparseMatrix(num_cols, num_cols, num_nonzeros));
   tsm_->set_num_nonzeros(num_nonzeros);
@@ -105,11 +102,11 @@
         layout_[IntPairToLong(row_block_id, col_block_id)]->values - values;
     for (int r = 0; r < row_block_size; ++r) {
       for (int c = 0; c < col_block_size; ++c, ++pos) {
-          rows[pos] = block_positions_[row_block_id] + r;
-          cols[pos] = block_positions_[col_block_id] + c;
-          values[pos] = 1.0;
-          DCHECK_LT(rows[pos], tsm_->num_rows());
-          DCHECK_LT(cols[pos], tsm_->num_rows());
+        rows[pos] = block_positions_[row_block_id] + r;
+        cols[pos] = block_positions_[col_block_id] + c;
+        values[pos] = 1.0;
+        DCHECK_LT(rows[pos], tsm_->num_rows());
+        DCHECK_LT(cols[pos], tsm_->num_rows());
       }
     }
   }
@@ -129,7 +126,7 @@
                                                  int* col,
                                                  int* row_stride,
                                                  int* col_stride) {
-  const LayoutType::iterator it  =
+  const LayoutType::iterator it =
       layout_.find(IntPairToLong(row_block_id, col_block_id));
   if (it == layout_.end()) {
     return NULL;
@@ -147,8 +144,7 @@
 // when they are calling SetZero.
 void BlockRandomAccessSparseMatrix::SetZero() {
   if (tsm_->num_nonzeros()) {
-    VectorRef(tsm_->mutable_values(),
-              tsm_->num_nonzeros()).setZero();
+    VectorRef(tsm_->mutable_values(), tsm_->num_nonzeros()).setZero();
   }
 }
 
@@ -164,7 +160,9 @@
     const int col_block_pos = block_positions_[col];
 
     MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
-        cell_position_and_data.second, row_block_size, col_block_size,
+        cell_position_and_data.second,
+        row_block_size,
+        col_block_size,
         x + col_block_pos,
         y + row_block_pos);
 
@@ -174,7 +172,9 @@
     // triangular multiply also.
     if (row != col) {
       MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
-          cell_position_and_data.second, row_block_size, col_block_size,
+          cell_position_and_data.second,
+          row_block_size,
+          col_block_size,
           x + row_block_pos,
           y + col_block_pos);
     }
diff --git a/internal/ceres/block_random_access_sparse_matrix.h b/internal/ceres/block_random_access_sparse_matrix.h
index d542a3d..ca04163 100644
--- a/internal/ceres/block_random_access_sparse_matrix.h
+++ b/internal/ceres/block_random_access_sparse_matrix.h
@@ -39,10 +39,10 @@
 #include <vector>
 
 #include "ceres/block_random_access_matrix.h"
-#include "ceres/triplet_sparse_matrix.h"
 #include "ceres/internal/port.h"
-#include "ceres/types.h"
 #include "ceres/small_blas.h"
+#include "ceres/triplet_sparse_matrix.h"
+#include "ceres/types.h"
 
 namespace ceres {
 namespace internal {
@@ -110,7 +110,7 @@
 
   // A mapping from <row_block_id, col_block_id> to the position in
   // the values array of tsm_ where the block is stored.
-  typedef std::unordered_map<long int, CellInfo* > LayoutType;
+  typedef std::unordered_map<long int, CellInfo*> LayoutType;
   LayoutType layout_;
 
   // In order traversal of contents of the matrix. This allows us to
diff --git a/internal/ceres/block_random_access_sparse_matrix_test.cc b/internal/ceres/block_random_access_sparse_matrix_test.cc
index fa0698f..557b678 100644
--- a/internal/ceres/block_random_access_sparse_matrix_test.cc
+++ b/internal/ceres/block_random_access_sparse_matrix_test.cc
@@ -28,11 +28,12 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/block_random_access_sparse_matrix.h"
+
 #include <limits>
 #include <memory>
 #include <vector>
 
-#include "ceres/block_random_access_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
@@ -77,9 +78,8 @@
     int col;
     int row_stride;
     int col_stride;
-    CellInfo* cell =  m.GetCell(row_block_id, col_block_id,
-                                &row, &col,
-                                &row_stride, &col_stride);
+    CellInfo* cell = m.GetCell(
+        row_block_id, col_block_id, &row, &col, &row_stride, &col_stride);
     EXPECT_TRUE(cell != NULL);
     EXPECT_EQ(row, 0);
     EXPECT_EQ(col, 0);
@@ -87,9 +87,9 @@
     EXPECT_EQ(col_stride, blocks[col_block_id]);
 
     // Write into the block
-    MatrixRef(cell->values, row_stride, col_stride).block(
-        row, col, blocks[row_block_id], blocks[col_block_id]) =
-        (row_block_id + 1) * (col_block_id +1) *
+    MatrixRef(cell->values, row_stride, col_stride)
+        .block(row, col, blocks[row_block_id], blocks[col_block_id]) =
+        (row_block_id + 1) * (col_block_id + 1) *
         Matrix::Ones(blocks[row_block_id], blocks[col_block_id]);
   }
 
@@ -103,9 +103,8 @@
   double kTolerance = 1e-14;
 
   // (0, 0)
-  EXPECT_NEAR((dense.block(0, 0, 3, 3) - Matrix::Ones(3, 3)).norm(),
-              0.0,
-              kTolerance);
+  EXPECT_NEAR(
+      (dense.block(0, 0, 3, 3) - Matrix::Ones(3, 3)).norm(), 0.0, kTolerance);
   // (1, 1)
   EXPECT_NEAR((dense.block(3, 3, 4, 4) - 2 * 2 * Matrix::Ones(4, 4)).norm(),
               0.0,
@@ -120,8 +119,8 @@
               kTolerance);
 
   // There is nothing else in the matrix besides these four blocks.
-  EXPECT_NEAR(dense.norm(), sqrt(9. + 16. * 16. + 36. * 20. + 9. * 15.),
-              kTolerance);
+  EXPECT_NEAR(
+      dense.norm(), sqrt(9. + 16. * 16. + 36. * 20. + 9. * 15.), kTolerance);
 
   Vector x = Vector::Ones(dense.rows());
   Vector actual_y = Vector::Zero(dense.rows());
@@ -131,8 +130,7 @@
   m.SymmetricRightMultiply(x.data(), actual_y.data());
   EXPECT_NEAR((expected_y - actual_y).norm(), 0.0, kTolerance)
       << "actual: " << actual_y.transpose() << "\n"
-      << "expected: " << expected_y.transpose()
-      << "matrix: \n " << dense;
+      << "expected: " << expected_y.transpose() << "matrix: \n " << dense;
 }
 
 // IntPairToLong is private, thus this fixture is needed to access and
@@ -155,14 +153,13 @@
   }
 
   void CheckLongToIntPair() {
-    uint64_t max_rows =  m_->kMaxRowBlocks;
+    uint64_t max_rows = m_->kMaxRowBlocks;
     for (int row = max_rows - 10; row < max_rows; ++row) {
       for (int col = 0; col < 10; ++col) {
         int row_computed;
         int col_computed;
-        m_->LongToIntPair(m_->IntPairToLong(row, col),
-                          &row_computed,
-                          &col_computed);
+        m_->LongToIntPair(
+            m_->IntPairToLong(row, col), &row_computed, &col_computed);
         EXPECT_EQ(row, row_computed);
         EXPECT_EQ(col, col_computed);
       }
diff --git a/internal/ceres/block_sparse_matrix.cc b/internal/ceres/block_sparse_matrix.cc
index 8f50f35..5efd2e1 100644
--- a/internal/ceres/block_sparse_matrix.cc
+++ b/internal/ceres/block_sparse_matrix.cc
@@ -30,9 +30,10 @@
 
 #include "ceres/block_sparse_matrix.h"
 
-#include <cstddef>
 #include <algorithm>
+#include <cstddef>
 #include <vector>
+
 #include "ceres/block_structure.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/random.h"
@@ -77,8 +78,8 @@
   CHECK_GE(num_rows_, 0);
   CHECK_GE(num_cols_, 0);
   CHECK_GE(num_nonzeros_, 0);
-  VLOG(2) << "Allocating values array with "
-          << num_nonzeros_ * sizeof(double) << " bytes.";  // NOLINT
+  VLOG(2) << "Allocating values array with " << num_nonzeros_ * sizeof(double)
+          << " bytes.";  // NOLINT
   values_.reset(new double[num_nonzeros_]);
   max_num_nonzeros_ = num_nonzeros_;
   CHECK(values_ != nullptr);
@@ -88,7 +89,7 @@
   std::fill(values_.get(), values_.get() + num_nonzeros_, 0.0);
 }
 
-void BlockSparseMatrix::RightMultiply(const double* x,  double* y) const {
+void BlockSparseMatrix::RightMultiply(const double* x, double* y) const {
   CHECK(x != nullptr);
   CHECK(y != nullptr);
 
@@ -101,7 +102,9 @@
       int col_block_size = block_structure_->cols[col_block_id].size;
       int col_block_pos = block_structure_->cols[col_block_id].position;
       MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
-          values_.get() + cells[j].position, row_block_size, col_block_size,
+          values_.get() + cells[j].position,
+          row_block_size,
+          col_block_size,
           x + col_block_pos,
           y + row_block_pos);
     }
@@ -121,7 +124,9 @@
       int col_block_size = block_structure_->cols[col_block_id].size;
       int col_block_pos = block_structure_->cols[col_block_id].position;
       MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
-          values_.get() + cells[j].position, row_block_size, col_block_size,
+          values_.get() + cells[j].position,
+          row_block_size,
+          col_block_size,
           x + row_block_pos,
           y + col_block_pos);
     }
@@ -138,8 +143,8 @@
       int col_block_id = cells[j].block_id;
       int col_block_size = block_structure_->cols[col_block_id].size;
       int col_block_pos = block_structure_->cols[col_block_id].position;
-      const MatrixRef m(values_.get() + cells[j].position,
-                        row_block_size, col_block_size);
+      const MatrixRef m(
+          values_.get() + cells[j].position, row_block_size, col_block_size);
       VectorRef(x + col_block_pos, col_block_size) += m.colwise().squaredNorm();
     }
   }
@@ -155,8 +160,8 @@
       int col_block_id = cells[j].block_id;
       int col_block_size = block_structure_->cols[col_block_id].size;
       int col_block_pos = block_structure_->cols[col_block_id].position;
-      MatrixRef m(values_.get() + cells[j].position,
-                        row_block_size, col_block_size);
+      MatrixRef m(
+          values_.get() + cells[j].position, row_block_size, col_block_size);
       m *= ConstVectorRef(scale + col_block_pos, col_block_size).asDiagonal();
     }
   }
@@ -178,8 +183,8 @@
       int col_block_size = block_structure_->cols[col_block_id].size;
       int col_block_pos = block_structure_->cols[col_block_id].position;
       int jac_pos = cells[j].position;
-      m.block(row_block_pos, col_block_pos, row_block_size, col_block_size)
-          += MatrixRef(values_.get() + jac_pos, row_block_size, col_block_size);
+      m.block(row_block_pos, col_block_pos, row_block_size, col_block_size) +=
+          MatrixRef(values_.get() + jac_pos, row_block_size, col_block_size);
     }
   }
 }
@@ -201,7 +206,7 @@
       int col_block_size = block_structure_->cols[col_block_id].size;
       int col_block_pos = block_structure_->cols[col_block_id].position;
       int jac_pos = cells[j].position;
-       for (int r = 0; r < row_block_size; ++r) {
+      for (int r = 0; r < row_block_size; ++r) {
         for (int c = 0; c < col_block_size; ++c, ++jac_pos) {
           matrix->mutable_rows()[jac_pos] = row_block_pos + r;
           matrix->mutable_cols()[jac_pos] = col_block_pos + c;
@@ -215,8 +220,7 @@
 
 // Return a pointer to the block structure. We continue to hold
 // ownership of the object though.
-const CompressedRowBlockStructure* BlockSparseMatrix::block_structure()
-    const {
+const CompressedRowBlockStructure* BlockSparseMatrix::block_structure() const {
   return block_structure_.get();
 }
 
@@ -233,7 +237,8 @@
       int jac_pos = cells[j].position;
       for (int r = 0; r < row_block_size; ++r) {
         for (int c = 0; c < col_block_size; ++c) {
-          fprintf(file, "% 10d % 10d %17f\n",
+          fprintf(file,
+                  "% 10d % 10d %17f\n",
                   row_block_pos + r,
                   col_block_pos + c,
                   values_[jac_pos++]);
@@ -369,7 +374,6 @@
     int row_block_position = 0;
     int value_position = 0;
     for (int r = 0; r < options.num_row_blocks; ++r) {
-
       const int delta_block_size =
           Uniform(options.max_row_block_size - options.min_row_block_size);
       const int row_block_size = options.min_row_block_size + delta_block_size;
diff --git a/internal/ceres/block_sparse_matrix.h b/internal/ceres/block_sparse_matrix.h
index d0c255d..fa9e4ed 100644
--- a/internal/ceres/block_sparse_matrix.h
+++ b/internal/ceres/block_sparse_matrix.h
@@ -35,9 +35,10 @@
 #define CERES_INTERNAL_BLOCK_SPARSE_MATRIX_H_
 
 #include <memory>
+
 #include "ceres/block_structure.h"
-#include "ceres/sparse_matrix.h"
 #include "ceres/internal/eigen.h"
+#include "ceres/sparse_matrix.h"
 
 namespace ceres {
 namespace internal {
@@ -77,11 +78,13 @@
   void ToDenseMatrix(Matrix* dense_matrix) const final;
   void ToTextFile(FILE* file) const final;
 
+  // clang-format off
   int num_rows()         const final { return num_rows_;     }
   int num_cols()         const final { return num_cols_;     }
   int num_nonzeros()     const final { return num_nonzeros_; }
   const double* values() const final { return values_.get(); }
   double* mutable_values()     final { return values_.get(); }
+  // clang-format on
 
   void ToTripletSparseMatrix(TripletSparseMatrix* matrix) const;
   const CompressedRowBlockStructure* block_structure() const;
@@ -94,8 +97,7 @@
   void DeleteRowBlocks(int delta_row_blocks);
 
   static BlockSparseMatrix* CreateDiagonalMatrix(
-      const double* diagonal,
-      const std::vector<Block>& column_blocks);
+      const double* diagonal, const std::vector<Block>& column_blocks);
 
   struct RandomMatrixOptions {
     int num_row_blocks = 0;
diff --git a/internal/ceres/block_sparse_matrix_test.cc b/internal/ceres/block_sparse_matrix_test.cc
index 0c88bd9..02d3fb1 100644
--- a/internal/ceres/block_sparse_matrix_test.cc
+++ b/internal/ceres/block_sparse_matrix_test.cc
@@ -32,6 +32,7 @@
 
 #include <memory>
 #include <string>
+
 #include "ceres/casts.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
@@ -43,7 +44,7 @@
 namespace internal {
 
 class BlockSparseMatrixTest : public ::testing::Test {
- protected :
+ protected:
   void SetUp() final {
     std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(2));
@@ -159,13 +160,13 @@
 
     A_->RightMultiply(x.data(), y_a.data());
     B_->RightMultiply(x.data(), y_b.data());
-    EXPECT_LT((y_a.head(B_->num_rows()) - y_b.head(B_->num_rows())).norm(), 1e-12);
+    EXPECT_LT((y_a.head(B_->num_rows()) - y_b.head(B_->num_rows())).norm(),
+              1e-12);
     Vector expected_tail = Vector::Zero(A_->num_cols());
     expected_tail(i) = diagonal(i);
     EXPECT_LT((y_a.tail(A_->num_cols()) - expected_tail).norm(), 1e-12);
   }
 
-
   A_->DeleteRowBlocks(column_blocks.size());
   EXPECT_EQ(A_->num_rows(), B_->num_rows());
   EXPECT_EQ(A_->num_cols(), B_->num_cols());
@@ -213,6 +214,5 @@
   }
 }
 
-
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/block_structure.cc b/internal/ceres/block_structure.cc
index 6479b60..39ba082 100644
--- a/internal/ceres/block_structure.cc
+++ b/internal/ceres/block_structure.cc
@@ -35,7 +35,7 @@
 
 bool CellLessThan(const Cell& lhs, const Cell& rhs) {
   if (lhs.block_id == rhs.block_id) {
-    return (lhs.position  < rhs.position);
+    return (lhs.position < rhs.position);
   }
   return (lhs.block_id < rhs.block_id);
 }
diff --git a/internal/ceres/block_structure.h b/internal/ceres/block_structure.h
index b5218c0..d49d7d3 100644
--- a/internal/ceres/block_structure.h
+++ b/internal/ceres/block_structure.h
@@ -40,6 +40,7 @@
 
 #include <cstdint>
 #include <vector>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
diff --git a/internal/ceres/bundle_adjustment_test_util.h b/internal/ceres/bundle_adjustment_test_util.h
index 7e076eb..074931f 100644
--- a/internal/ceres/bundle_adjustment_test_util.h
+++ b/internal/ceres/bundle_adjustment_test_util.h
@@ -37,9 +37,8 @@
 #include <cstdlib>
 #include <string>
 
-#include "ceres/internal/port.h"
-
 #include "ceres/autodiff_cost_function.h"
+#include "ceres/internal/port.h"
 #include "ceres/ordered_groups.h"
 #include "ceres/problem.h"
 #include "ceres/rotation.h"
@@ -73,29 +72,31 @@
   }
 
   ~BundleAdjustmentProblem() {
-    delete []point_index_;
-    delete []camera_index_;
-    delete []observations_;
-    delete []parameters_;
+    delete[] point_index_;
+    delete[] camera_index_;
+    delete[] observations_;
+    delete[] parameters_;
   }
 
   Problem* mutable_problem() { return &problem_; }
   Solver::Options* mutable_solver_options() { return &options_; }
 
-  int num_cameras()            const { return num_cameras_;        }
-  int num_points()             const { return num_points_;         }
-  int num_observations()       const { return num_observations_;   }
-  const int* point_index()     const { return point_index_;  }
+  // clang-format off
+  int num_cameras()            const { return num_cameras_; }
+  int num_points()             const { return num_points_; }
+  int num_observations()       const { return num_observations_; }
+  const int* point_index()     const { return point_index_; }
   const int* camera_index()    const { return camera_index_; }
   const double* observations() const { return observations_; }
-  double* mutable_cameras() { return parameters_; }
-  double* mutable_points() { return parameters_  + 9 * num_cameras_; }
+  double* mutable_cameras()          { return parameters_; }
+  double* mutable_points()           { return parameters_ + 9 * num_cameras_; }
+  // clang-format on
 
   static double kResidualTolerance;
 
  private:
   void ReadData(const string& filename) {
-    FILE * fptr = fopen(filename.c_str(), "r");
+    FILE* fptr = fopen(filename.c_str(), "r");
 
     if (!fptr) {
       LOG(FATAL) << "File Error: unable to open file " << filename;
@@ -106,9 +107,8 @@
     FscanfOrDie(fptr, "%d", &num_points_);
     FscanfOrDie(fptr, "%d", &num_observations_);
 
-    VLOG(1) << "Header: " << num_cameras_
-            << " " << num_points_
-            << " " << num_observations_;
+    VLOG(1) << "Header: " << num_cameras_ << " " << num_points_ << " "
+            << num_observations_;
 
     point_index_ = new int[num_observations_];
     camera_index_ = new int[num_observations_];
@@ -121,7 +121,7 @@
       FscanfOrDie(fptr, "%d", camera_index_ + i);
       FscanfOrDie(fptr, "%d", point_index_ + i);
       for (int j = 0; j < 2; ++j) {
-        FscanfOrDie(fptr, "%lf", observations_ + 2*i + j);
+        FscanfOrDie(fptr, "%lf", observations_ + 2 * i + j);
       }
     }
 
@@ -141,8 +141,8 @@
       // outputs a 2 dimensional residual.
       CostFunction* cost_function =
           new AutoDiffCostFunction<BundlerResidual, 2, 9, 3>(
-              new BundlerResidual(observations_[2*i + 0],
-                                  observations_[2*i + 1]));
+              new BundlerResidual(observations_[2 * i + 0],
+                                  observations_[2 * i + 1]));
 
       // Each observation corresponds to a pair of a camera and a point
       // which are identified by camera_index()[i] and
@@ -170,8 +170,8 @@
     options_.parameter_tolerance = 1e-10;
   }
 
-  template<typename T>
-  void FscanfOrDie(FILE *fptr, const char *format, T *value) {
+  template <typename T>
+  void FscanfOrDie(FILE* fptr, const char* format, T* value) {
     int num_scanned = fscanf(fptr, format, value);
     if (num_scanned != 1) {
       LOG(FATAL) << "Invalid UW data file.";
@@ -186,7 +186,7 @@
   struct BundlerResidual {
     // (u, v): the position of the observation with respect to the image
     // center point.
-    BundlerResidual(double u, double v): u(u), v(v) {}
+    BundlerResidual(double u, double v) : u(u), v(v) {}
 
     template <typename T>
     bool operator()(const T* const camera,
@@ -207,12 +207,12 @@
       // Compute the center of distortion.  The sign change comes from
       // the camera model that Noah Snavely's Bundler assumes, whereby
       // the camera coordinate system has a negative z axis.
-      T xp = - focal * p[0] / p[2];
-      T yp = - focal * p[1] / p[2];
+      T xp = -focal * p[0] / p[2];
+      T yp = -focal * p[1] / p[2];
 
       // Apply second and fourth order radial distortion.
-      T r2 = xp*xp + yp*yp;
-      T distortion = T(1.0) + r2  * (l1 + l2  * r2);
+      T r2 = xp * xp + yp * yp;
+      T distortion = T(1.0) + r2 * (l1 + l2 * r2);
 
       residuals[0] = distortion * xp - u;
       residuals[1] = distortion * yp - v;
diff --git a/internal/ceres/c_api.cc b/internal/ceres/c_api.cc
index 2244909..251cde4 100644
--- a/internal/ceres/c_api.cc
+++ b/internal/ceres/c_api.cc
@@ -34,9 +34,10 @@
 
 #include "ceres/c_api.h"
 
-#include <vector>
 #include <iostream>
 #include <string>
+#include <vector>
+
 #include "ceres/cost_function.h"
 #include "ceres/loss_function.h"
 #include "ceres/problem.h"
@@ -70,8 +71,7 @@
                        int num_residuals,
                        int num_parameter_blocks,
                        int* parameter_block_sizes)
-      : cost_function_(cost_function),
-        user_data_(user_data) {
+      : cost_function_(cost_function), user_data_(user_data) {
     set_num_residuals(num_residuals);
     for (int i = 0; i < num_parameter_blocks; ++i) {
       mutable_parameter_block_sizes()->push_back(parameter_block_sizes[i]);
@@ -81,12 +81,10 @@
   virtual ~CallbackCostFunction() {}
 
   bool Evaluate(double const* const* parameters,
-                        double* residuals,
-                        double** jacobians) const final {
-    return (*cost_function_)(user_data_,
-                             const_cast<double**>(parameters),
-                             residuals,
-                             jacobians);
+                double* residuals,
+                double** jacobians) const final {
+    return (*cost_function_)(
+        user_data_, const_cast<double**>(parameters), residuals, jacobians);
   }
 
  private:
@@ -100,7 +98,7 @@
  public:
   explicit CallbackLossFunction(ceres_loss_function_t loss_function,
                                 void* user_data)
-    : loss_function_(loss_function), user_data_(user_data) {}
+      : loss_function_(loss_function), user_data_(user_data) {}
   void Evaluate(double sq_norm, double* rho) const final {
     (*loss_function_)(user_data_, sq_norm, rho);
   }
@@ -134,8 +132,8 @@
 void ceres_stock_loss_function(void* user_data,
                                double squared_norm,
                                double out[3]) {
-  reinterpret_cast<ceres::LossFunction*>(user_data)
-      ->Evaluate(squared_norm, out);
+  reinterpret_cast<ceres::LossFunction*>(user_data)->Evaluate(squared_norm,
+                                                              out);
 }
 
 ceres_residual_block_id_t* ceres_problem_add_residual_block(
@@ -159,16 +157,15 @@
 
   ceres::LossFunction* callback_loss_function = NULL;
   if (loss_function != NULL) {
-    callback_loss_function = new CallbackLossFunction(loss_function,
-                                                      loss_function_data);
+    callback_loss_function =
+        new CallbackLossFunction(loss_function, loss_function_data);
   }
 
   std::vector<double*> parameter_blocks(parameters,
                                         parameters + num_parameter_blocks);
   return reinterpret_cast<ceres_residual_block_id_t*>(
-      ceres_problem->AddResidualBlock(callback_cost_function,
-                                      callback_loss_function,
-                                      parameter_blocks));
+      ceres_problem->AddResidualBlock(
+          callback_cost_function, callback_loss_function, parameter_blocks));
 }
 
 void ceres_solve(ceres_problem_t* c_problem) {
diff --git a/internal/ceres/c_api_test.cc b/internal/ceres/c_api_test.cc
index fa11249..043f6ab 100644
--- a/internal/ceres/c_api_test.cc
+++ b/internal/ceres/c_api_test.cc
@@ -37,6 +37,7 @@
 
 // Duplicated from curve_fitting.cc.
 int num_observations = 67;
+// clang-format off
 double data[] = {
   0.000000e+00, 1.133898e+00,
   7.500000e-02, 1.334902e+00,
@@ -106,13 +107,14 @@
   4.875000e+00, 4.727863e+00,
   4.950000e+00, 4.669206e+00,
 };
+// clang-format on
 
 // A test cost function, similar to the one in curve_fitting.c.
 static int exponential_residual(void* user_data,
                                 double** parameters,
                                 double* residuals,
                                 double** jacobians) {
-  double* measurement = (double*) user_data;
+  double* measurement = (double*)user_data;
   double x = measurement[0];
   double y = measurement[1];
   double m = parameters[0][0];
@@ -123,10 +125,10 @@
     return 1;
   }
   if (jacobians[0] != NULL) {
-    jacobians[0][0] = - x * exp(m * x + c);  // dr/dm
+    jacobians[0][0] = -x * exp(m * x + c);  // dr/dm
   }
   if (jacobians[1] != NULL) {
-    jacobians[1][0] =     - exp(m * x + c);  // dr/dc
+    jacobians[1][0] = -exp(m * x + c);  // dr/dc
   }
   return 1;
 }
@@ -137,8 +139,8 @@
 TEST(C_API, SimpleEndToEndTest) {
   double m = 0.0;
   double c = 0.0;
-  double *parameter_pointers[] = { &m, &c };
-  int parameter_sizes[] = { 1, 1 };
+  double* parameter_pointers[] = {&m, &c};
+  int parameter_sizes[] = {1, 1};
 
   ceres_problem_t* problem = ceres_create_problem();
   for (int i = 0; i < num_observations; ++i) {
@@ -162,16 +164,14 @@
   ceres_free_problem(problem);
 }
 
-template<typename T>
+template <typename T>
 class ScopedSetValue {
  public:
   ScopedSetValue(T* variable, T new_value)
       : variable_(variable), old_value_(*variable) {
     *variable = new_value;
   }
-  ~ScopedSetValue() {
-    *variable_ = old_value_;
-  }
+  ~ScopedSetValue() { *variable_ = old_value_; }
 
  private:
   T* variable_;
@@ -181,8 +181,8 @@
 TEST(C_API, LossFunctions) {
   double m = 0.2;
   double c = 0.03;
-  double *parameter_pointers[] = { &m, &c };
-  int parameter_sizes[] = { 1, 1 };
+  double* parameter_pointers[] = {&m, &c};
+  int parameter_sizes[] = {1, 1};
 
   // Create two outliers, but be careful to leave the data intact.
   ScopedSetValue<double> outlier1x(&data[12], 2.5);
@@ -191,19 +191,18 @@
   ScopedSetValue<double> outlier2y(&data[15], 30e3);
 
   // Create a cauchy cost function, and reuse it many times.
-  void* cauchy_loss_data =
-      ceres_create_cauchy_loss_function_data(5.0);
+  void* cauchy_loss_data = ceres_create_cauchy_loss_function_data(5.0);
 
   ceres_problem_t* problem = ceres_create_problem();
   for (int i = 0; i < num_observations; ++i) {
     ceres_problem_add_residual_block(
         problem,
-        exponential_residual,  // Cost function
-        &data[2 * i],          // Points to the (x,y) measurement
-        ceres_stock_loss_function,
-        cauchy_loss_data,      // Loss function user data
-        1,                     // Number of residuals
-        2,                     // Number of parameter blocks
+        exponential_residual,       // Cost function
+        &data[2 * i],               // Points to the (x,y) measurement
+        ceres_stock_loss_function,  //
+        cauchy_loss_data,           // Loss function user data
+        1,                          // Number of residuals
+        2,                          // Number of parameter blocks
         parameter_sizes,
         parameter_pointers);
   }
diff --git a/internal/ceres/callbacks.cc b/internal/ceres/callbacks.cc
index 84576e4..0e0df9d 100644
--- a/internal/ceres/callbacks.cc
+++ b/internal/ceres/callbacks.cc
@@ -28,8 +28,10 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-#include <iostream>  // NO LINT
 #include "ceres/callbacks.h"
+
+#include <iostream>  // NO LINT
+
 #include "ceres/program.h"
 #include "ceres/stringprintf.h"
 #include "glog/logging.h"
@@ -76,8 +78,7 @@
 
 LoggingCallback::LoggingCallback(const MinimizerType minimizer_type,
                                  const bool log_to_stdout)
-    : minimizer_type(minimizer_type),
-      log_to_stdout_(log_to_stdout) {}
+    : minimizer_type(minimizer_type), log_to_stdout_(log_to_stdout) {}
 
 LoggingCallback::~LoggingCallback() {}
 
@@ -99,11 +100,13 @@
                           summary.iteration_time_in_seconds,
                           summary.cumulative_time_in_seconds);
   } else if (minimizer_type == TRUST_REGION) {
+    // clang-format off
     if (summary.iteration == 0) {
       output = "iter      cost      cost_change  |gradient|   |step|    tr_ratio  tr_radius  ls_iter  iter_time  total_time\n";  // NOLINT
     }
     const char* kReportRowFormat =
         "% 4d % 8e   % 3.2e   % 3.2e  % 3.2e  % 3.2e % 3.2e     % 4d   % 3.2e   % 3.2e";  // NOLINT
+    // clang-format on
     output += StringPrintf(kReportRowFormat,
                            summary.iteration,
                            summary.cost,
diff --git a/internal/ceres/callbacks.h b/internal/ceres/callbacks.h
index d68bf7f..47112b8 100644
--- a/internal/ceres/callbacks.h
+++ b/internal/ceres/callbacks.h
@@ -32,8 +32,9 @@
 #define CERES_INTERNAL_CALLBACKS_H_
 
 #include <string>
-#include "ceres/iteration_callback.h"
+
 #include "ceres/internal/port.h"
+#include "ceres/iteration_callback.h"
 
 namespace ceres {
 namespace internal {
@@ -47,6 +48,7 @@
   StateUpdatingCallback(Program* program, double* parameters);
   virtual ~StateUpdatingCallback();
   CallbackReturnType operator()(const IterationSummary& summary) final;
+
  private:
   Program* program_;
   double* parameters_;
@@ -61,6 +63,7 @@
                                              double* user_parameters);
   virtual ~GradientProblemSolverStateUpdatingCallback();
   CallbackReturnType operator()(const IterationSummary& summary) final;
+
  private:
   int num_parameters_;
   const double* internal_parameters_;
diff --git a/internal/ceres/canonical_views_clustering.cc b/internal/ceres/canonical_views_clustering.cc
index e927e1f..c193735 100644
--- a/internal/ceres/canonical_views_clustering.cc
+++ b/internal/ceres/canonical_views_clustering.cc
@@ -31,8 +31,8 @@
 
 #include "ceres/canonical_views_clustering.h"
 
-#include <unordered_set>
 #include <unordered_map>
+#include <unordered_set>
 
 #include "ceres/graph.h"
 #include "ceres/map_util.h"
@@ -126,8 +126,7 @@
 
     // Add canonical view if quality improves, or if minimum is not
     // yet met, otherwise break.
-    if ((best_difference <= 0) &&
-        (centers->size() >= options_.min_views)) {
+    if ((best_difference <= 0) && (centers->size() >= options_.min_views)) {
       break;
     }
 
@@ -141,8 +140,7 @@
 
 // Return the set of vertices of the graph which have valid vertex
 // weights.
-void CanonicalViewsClustering::FindValidViews(
-    IntSet* valid_views) const {
+void CanonicalViewsClustering::FindValidViews(IntSet* valid_views) const {
   const IntSet& views = graph_->vertices();
   for (const auto& view : views) {
     if (graph_->VertexWeight(view) != WeightedGraph<int>::InvalidWeight()) {
@@ -154,8 +152,7 @@
 // Computes the difference in the quality score if 'candidate' were
 // added to the set of canonical views.
 double CanonicalViewsClustering::ComputeClusteringQualityDifference(
-    const int candidate,
-    const vector<int>& centers) const {
+    const int candidate, const vector<int>& centers) const {
   // View score.
   double difference =
       options_.view_score_weight * graph_->VertexWeight(candidate);
@@ -179,7 +176,7 @@
   // Orthogonality.
   for (int i = 0; i < centers.size(); ++i) {
     difference -= options_.similarity_penalty_weight *
-        graph_->EdgeWeight(centers[i], candidate);
+                  graph_->EdgeWeight(centers[i], candidate);
   }
 
   return difference;
@@ -192,8 +189,7 @@
   for (const auto& neighbor : neighbors) {
     const double old_similarity =
         FindWithDefault(view_to_canonical_view_similarity_, neighbor, 0.0);
-    const double new_similarity =
-        graph_->EdgeWeight(neighbor, canonical_view);
+    const double new_similarity = graph_->EdgeWeight(neighbor, canonical_view);
     if (new_similarity > old_similarity) {
       view_to_canonical_view_[neighbor] = canonical_view;
       view_to_canonical_view_similarity_[neighbor] = new_similarity;
@@ -203,8 +199,7 @@
 
 // Assign a cluster id to each view.
 void CanonicalViewsClustering::ComputeClusterMembership(
-    const vector<int>& centers,
-    IntMap* membership) const {
+    const vector<int>& centers, IntMap* membership) const {
   CHECK(membership != nullptr);
   membership->clear();
 
diff --git a/internal/ceres/canonical_views_clustering_test.cc b/internal/ceres/canonical_views_clustering_test.cc
index 42e05bc..0593d65 100644
--- a/internal/ceres/canonical_views_clustering_test.cc
+++ b/internal/ceres/canonical_views_clustering_test.cc
@@ -32,6 +32,7 @@
 #include "ceres/canonical_views_clustering.h"
 
 #include <unordered_map>
+
 #include "ceres/graph.h"
 #include "gtest/gtest.h"
 
@@ -110,7 +111,6 @@
   EXPECT_EQ(centers_[0], kVertexIds[1]);
 }
 
-
 // Increases view score weight so vertex 2 will be chosen.
 TEST_F(CanonicalViewsTest, ViewScoreTest) {
   options_.min_views = 0;
diff --git a/internal/ceres/casts.h b/internal/ceres/casts.h
index f18fdea..d137071 100644
--- a/internal/ceres/casts.h
+++ b/internal/ceres/casts.h
@@ -56,15 +56,15 @@
 //
 // base::identity_ is used to make a non-deduced context, which
 // forces all callers to explicitly specify the template argument.
-template<typename To>
+template <typename To>
 inline To implicit_cast(typename identity_<To>::type to) {
   return to;
 }
 
 // This version of implicit_cast is used when two template arguments
 // are specified. It's obsolete and should not be used.
-template<typename To, typename From>
-inline To implicit_cast(typename identity_<From>::type const &f) {
+template <typename To, typename From>
+inline To implicit_cast(typename identity_<From>::type const& f) {
   return f;
 }
 
@@ -86,8 +86,8 @@
 //    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
 // You should design the code some other way not to need this.
 
-template<typename To, typename From>     // use like this: down_cast<T*>(foo);
-inline To down_cast(From* f) {                   // so we only accept pointers
+template <typename To, typename From>  // use like this: down_cast<T*>(foo);
+inline To down_cast(From* f) {         // so we only accept pointers
   // Ensures that To is a sub-type of From *.  This test is here only
   // for compile-time type checking, and has no overhead in an
   // optimized build at run-time, as it will be optimized away
diff --git a/internal/ceres/cgnr_linear_operator.h b/internal/ceres/cgnr_linear_operator.h
index 8e8febc..beb8bbc 100644
--- a/internal/ceres/cgnr_linear_operator.h
+++ b/internal/ceres/cgnr_linear_operator.h
@@ -33,8 +33,9 @@
 
 #include <algorithm>
 #include <memory>
-#include "ceres/linear_operator.h"
+
 #include "ceres/internal/eigen.h"
+#include "ceres/linear_operator.h"
 
 namespace ceres {
 namespace internal {
@@ -79,9 +80,8 @@
 // Note: This class is not thread safe, since it uses some temporary storage.
 class CgnrLinearOperator : public LinearOperator {
  public:
-  CgnrLinearOperator(const LinearOperator& A, const double *D)
-      : A_(A), D_(D), z_(new double[A.num_rows()]) {
-  }
+  CgnrLinearOperator(const LinearOperator& A, const double* D)
+      : A_(A), D_(D), z_(new double[A.num_rows()]) {}
   virtual ~CgnrLinearOperator() {}
 
   void RightMultiply(const double* x, double* y) const final {
@@ -96,8 +96,8 @@
     // y = y + DtDx
     if (D_ != NULL) {
       int n = A_.num_cols();
-      VectorRef(y, n).array() += ConstVectorRef(D_, n).array().square() *
-                                 ConstVectorRef(x, n).array();
+      VectorRef(y, n).array() +=
+          ConstVectorRef(D_, n).array().square() * ConstVectorRef(x, n).array();
     }
   }
 
diff --git a/internal/ceres/cgnr_solver.h b/internal/ceres/cgnr_solver.h
index 5292733..bc701c0 100644
--- a/internal/ceres/cgnr_solver.h
+++ b/internal/ceres/cgnr_solver.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_CGNR_SOLVER_H_
 
 #include <memory>
+
 #include "ceres/linear_solver.h"
 
 namespace ceres {
@@ -55,11 +56,10 @@
   void operator=(const CgnrSolver&) = delete;
   virtual ~CgnrSolver();
 
-  Summary SolveImpl(
-      BlockSparseMatrix* A,
-      const double* b,
-      const LinearSolver::PerSolveOptions& per_solve_options,
-      double* x) final;
+  Summary SolveImpl(BlockSparseMatrix* A,
+                    const double* b,
+                    const LinearSolver::PerSolveOptions& per_solve_options,
+                    double* x) final;
 
  private:
   const LinearSolver::Options options_;
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils.cc b/internal/ceres/compressed_col_sparse_matrix_utils.cc
index 3f6672f..e1f6bb8 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils.cc
@@ -30,8 +30,9 @@
 
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 
-#include <vector>
 #include <algorithm>
+#include <vector>
+
 #include "ceres/internal/port.h"
 #include "glog/logging.h"
 
@@ -40,13 +41,12 @@
 
 using std::vector;
 
-void CompressedColumnScalarMatrixToBlockMatrix(
-    const int* scalar_rows,
-    const int* scalar_cols,
-    const vector<int>& row_blocks,
-    const vector<int>& col_blocks,
-    vector<int>* block_rows,
-    vector<int>* block_cols) {
+void CompressedColumnScalarMatrixToBlockMatrix(const int* scalar_rows,
+                                               const int* scalar_cols,
+                                               const vector<int>& row_blocks,
+                                               const vector<int>& col_blocks,
+                                               vector<int>* block_rows,
+                                               vector<int>* block_cols) {
   CHECK(block_rows != nullptr);
   CHECK(block_cols != nullptr);
   block_rows->clear();
@@ -71,10 +71,8 @@
   for (int col_block = 0; col_block < num_col_blocks; ++col_block) {
     int column_size = 0;
     for (int idx = scalar_cols[c]; idx < scalar_cols[c + 1]; ++idx) {
-      vector<int>::const_iterator it =
-          std::lower_bound(row_block_starts.begin(),
-                           row_block_starts.end(),
-                           scalar_rows[idx]);
+      vector<int>::const_iterator it = std::lower_bound(
+          row_block_starts.begin(), row_block_starts.end(), scalar_rows[idx]);
       // Since we are using lower_bound, it will return the row id
       // where the row block starts. For everything but the first row
       // of the block, where these values will be the same, we can
@@ -104,7 +102,7 @@
 
   // block_starts = [0, block1, block1 + block2 ..]
   vector<int> block_starts(num_blocks);
-  for (int i = 0, cursor = 0; i < num_blocks ; ++i) {
+  for (int i = 0, cursor = 0; i < num_blocks; ++i) {
     block_starts[i] = cursor;
     cursor += blocks[i];
   }
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils.h b/internal/ceres/compressed_col_sparse_matrix_utils.h
index da2109f..8e56519 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils.h
+++ b/internal/ceres/compressed_col_sparse_matrix_utils.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_COMPRESSED_COL_SPARSE_MATRIX_UTILS_H_
 
 #include <vector>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
@@ -58,10 +59,9 @@
 // Given a set of blocks and a permutation of these blocks, compute
 // the corresponding "scalar" ordering, where the scalar ordering of
 // size sum(blocks).
-void BlockOrderingToScalarOrdering(
-    const std::vector<int>& blocks,
-    const std::vector<int>& block_ordering,
-    std::vector<int>* scalar_ordering);
+void BlockOrderingToScalarOrdering(const std::vector<int>& blocks,
+                                   const std::vector<int>& block_ordering,
+                                   std::vector<int>* scalar_ordering);
 
 // Solve the linear system
 //
@@ -101,7 +101,7 @@
       const double v = values[idx];
       rhs_and_solution[c] -= v * rhs_and_solution[r];
     }
-    rhs_and_solution[c] =  rhs_and_solution[c] / values[cols[c + 1] - 1];
+    rhs_and_solution[c] = rhs_and_solution[c] / values[cols[c + 1] - 1];
   }
 }
 
@@ -132,7 +132,7 @@
       const double v = values[idx];
       solution[c] -= v * solution[r];
     }
-    solution[c] =  solution[c] / values[cols[c + 1] - 1];
+    solution[c] = solution[c] / values[cols[c + 1] - 1];
   }
 
   SolveUpperTriangularInPlace(num_cols, rows, cols, values, solution);
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
index ba422a4..339c064 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
@@ -28,15 +28,16 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/compressed_col_sparse_matrix_utils.h"
 
 #include <algorithm>
 #include <numeric>
-#include "ceres/compressed_col_sparse_matrix_utils.h"
+
+#include "Eigen/SparseCore"
 #include "ceres/internal/port.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
-#include "Eigen/SparseCore"
 
 namespace ceres {
 namespace internal {
@@ -78,9 +79,7 @@
   expected_scalar_ordering.push_back(8);
 
   vector<int> scalar_ordering;
-  BlockOrderingToScalarOrdering(blocks,
-                                block_ordering,
-                                &scalar_ordering);
+  BlockOrderingToScalarOrdering(blocks, block_ordering, &scalar_ordering);
   EXPECT_EQ(scalar_ordering.size(), expected_scalar_ordering.size());
   for (int i = 0; i < expected_scalar_ordering.size(); ++i) {
     EXPECT_EQ(scalar_ordering[i], expected_scalar_ordering[i]);
@@ -92,11 +91,14 @@
                       const int row_block_id,
                       const int col_block_id,
                       vector<Eigen::Triplet<double>>* triplets) {
-  const int row_offset = std::accumulate(&row_blocks[0], &row_blocks[row_block_id], 0);
-  const int col_offset = std::accumulate(&col_blocks[0], &col_blocks[col_block_id], 0);
+  const int row_offset =
+      std::accumulate(&row_blocks[0], &row_blocks[row_block_id], 0);
+  const int col_offset =
+      std::accumulate(&col_blocks[0], &col_blocks[col_block_id], 0);
   for (int r = 0; r < row_blocks[row_block_id]; ++r) {
     for (int c = 0; c < col_blocks[col_block_id]; ++c) {
-      triplets->push_back(Eigen::Triplet<double>(row_offset + r, col_offset + c, 1.0));
+      triplets->push_back(
+          Eigen::Triplet<double>(row_offset + r, col_offset + c, 1.0));
     }
   }
 }
@@ -110,7 +112,6 @@
   // [2]  x x
   // num_nonzeros = 1 + 3 + 4 + 4 + 1 + 2 = 15
 
-
   vector<int> col_blocks;
   col_blocks.push_back(1);
   col_blocks.push_back(2);
@@ -122,8 +123,10 @@
   row_blocks.push_back(2);
   row_blocks.push_back(2);
 
-  const int num_rows = std::accumulate(row_blocks.begin(), row_blocks.end(), 0.0);
-  const int num_cols = std::accumulate(col_blocks.begin(), col_blocks.end(), 0.0);
+  const int num_rows =
+      std::accumulate(row_blocks.begin(), row_blocks.end(), 0.0);
+  const int num_cols =
+      std::accumulate(col_blocks.begin(), col_blocks.end(), 0.0);
 
   vector<Eigen::Triplet<double>> triplets;
   FillBlock(row_blocks, col_blocks, 0, 0, &triplets);
@@ -152,13 +155,12 @@
 
   vector<int> compressed_block_rows;
   vector<int> compressed_block_cols;
-  CompressedColumnScalarMatrixToBlockMatrix(
-      sparse_matrix.innerIndexPtr(),
-      sparse_matrix.outerIndexPtr(),
-      row_blocks,
-      col_blocks,
-      &compressed_block_rows,
-      &compressed_block_cols);
+  CompressedColumnScalarMatrixToBlockMatrix(sparse_matrix.innerIndexPtr(),
+                                            sparse_matrix.outerIndexPtr(),
+                                            row_blocks,
+                                            col_blocks,
+                                            &compressed_block_rows,
+                                            &compressed_block_cols);
 
   EXPECT_EQ(compressed_block_rows, expected_compressed_block_rows);
   EXPECT_EQ(compressed_block_cols, expected_compressed_block_cols);
@@ -203,13 +205,10 @@
 
 TEST_F(SolveUpperTriangularTest, SolveInPlace) {
   double rhs_and_solution[] = {1.0, 1.0, 2.0, 2.0};
-  const double expected[] = { -1.4706, -1.0962, 6.6667, 2.2477};
+  const double expected[] = {-1.4706, -1.0962, 6.6667, 2.2477};
 
-  SolveUpperTriangularInPlace<int>(cols.size() - 1,
-                                   &rows[0],
-                                   &cols[0],
-                                   &values[0],
-                                   rhs_and_solution);
+  SolveUpperTriangularInPlace<int>(
+      cols.size() - 1, &rows[0], &cols[0], &values[0], rhs_and_solution);
 
   for (int i = 0; i < 4; ++i) {
     EXPECT_NEAR(rhs_and_solution[i], expected[i], 1e-4) << i;
@@ -218,13 +217,10 @@
 
 TEST_F(SolveUpperTriangularTest, TransposeSolveInPlace) {
   double rhs_and_solution[] = {1.0, 1.0, 2.0, 2.0};
-  double expected[] = {1.970288,  1.242498,  6.081864, -0.057255};
+  double expected[] = {1.970288, 1.242498, 6.081864, -0.057255};
 
-  SolveUpperTriangularTransposeInPlace<int>(cols.size() - 1,
-                                            &rows[0],
-                                            &cols[0],
-                                            &values[0],
-                                            rhs_and_solution);
+  SolveUpperTriangularTransposeInPlace<int>(
+      cols.size() - 1, &rows[0], &cols[0], &values[0], rhs_and_solution);
 
   for (int i = 0; i < 4; ++i) {
     EXPECT_NEAR(rhs_and_solution[i], expected[i], 1e-4) << i;
@@ -233,18 +229,16 @@
 
 TEST_F(SolveUpperTriangularTest, RTRSolveWithSparseRHS) {
   double solution[4];
+  // clang-format off
   double expected[] = { 6.8420e+00,   1.0057e+00,  -1.4907e-16,  -1.9335e+00,
                         1.0057e+00,   2.2275e+00,  -1.9493e+00,  -6.5693e-01,
                         -1.4907e-16,  -1.9493e+00,   1.1111e+01,   9.7381e-17,
                         -1.9335e+00,  -6.5693e-01,   9.7381e-17,   1.2631e+00 };
+  // clang-format on
 
   for (int i = 0; i < 4; ++i) {
-    SolveRTRWithSparseRHS<int>(cols.size() - 1,
-                               &rows[0],
-                               &cols[0],
-                               &values[0],
-                               i,
-                               solution);
+    SolveRTRWithSparseRHS<int>(
+        cols.size() - 1, &rows[0], &cols[0], &values[0], i, solution);
     for (int j = 0; j < 4; ++j) {
       EXPECT_NEAR(solution[j], expected[4 * i + j], 1e-3) << i;
     }
diff --git a/internal/ceres/compressed_row_jacobian_writer.cc b/internal/ceres/compressed_row_jacobian_writer.cc
index 1fc0116..8e7e3e7 100644
--- a/internal/ceres/compressed_row_jacobian_writer.cc
+++ b/internal/ceres/compressed_row_jacobian_writer.cc
@@ -44,23 +44,21 @@
 namespace ceres {
 namespace internal {
 
+using std::adjacent_find;
 using std::make_pair;
 using std::pair;
 using std::vector;
-using std::adjacent_find;
 
 void CompressedRowJacobianWriter::PopulateJacobianRowAndColumnBlockVectors(
     const Program* program, CompressedRowSparseMatrix* jacobian) {
-  const vector<ParameterBlock*>& parameter_blocks =
-      program->parameter_blocks();
+  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
   vector<int>& col_blocks = *(jacobian->mutable_col_blocks());
   col_blocks.resize(parameter_blocks.size());
   for (int i = 0; i < parameter_blocks.size(); ++i) {
     col_blocks[i] = parameter_blocks[i]->LocalSize();
   }
 
-  const vector<ResidualBlock*>& residual_blocks =
-      program->residual_blocks();
+  const vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
   vector<int>& row_blocks = *(jacobian->mutable_row_blocks());
   row_blocks.resize(residual_blocks.size());
   for (int i = 0; i < residual_blocks.size(); ++i) {
@@ -69,11 +67,10 @@
 }
 
 void CompressedRowJacobianWriter::GetOrderedParameterBlocks(
-      const Program* program,
-      int residual_id,
-      vector<pair<int, int>>* evaluated_jacobian_blocks) {
-  const ResidualBlock* residual_block =
-      program->residual_blocks()[residual_id];
+    const Program* program,
+    int residual_id,
+    vector<pair<int, int>>* evaluated_jacobian_blocks) {
+  const ResidualBlock* residual_block = program->residual_blocks()[residual_id];
   const int num_parameter_blocks = residual_block->NumParameterBlocks();
 
   for (int j = 0; j < num_parameter_blocks; ++j) {
@@ -88,8 +85,7 @@
 }
 
 SparseMatrix* CompressedRowJacobianWriter::CreateJacobian() const {
-  const vector<ResidualBlock*>& residual_blocks =
-      program_->residual_blocks();
+  const vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
 
   int total_num_residuals = program_->NumResiduals();
   int total_num_effective_parameters = program_->NumEffectiveParameters();
@@ -112,11 +108,10 @@
   // Allocate more space than needed to store the jacobian so that when the LM
   // algorithm adds the diagonal, no reallocation is necessary. This reduces
   // peak memory usage significantly.
-  CompressedRowSparseMatrix* jacobian =
-      new CompressedRowSparseMatrix(
-          total_num_residuals,
-          total_num_effective_parameters,
-          num_jacobian_nonzeros + total_num_effective_parameters);
+  CompressedRowSparseMatrix* jacobian = new CompressedRowSparseMatrix(
+      total_num_residuals,
+      total_num_effective_parameters,
+      num_jacobian_nonzeros + total_num_effective_parameters);
 
   // At this stage, the CompressedRowSparseMatrix is an invalid state. But this
   // seems to be the only way to construct it without doing a memory copy.
@@ -148,8 +143,7 @@
       std::string parameter_block_description;
       for (int j = 0; j < num_parameter_blocks; ++j) {
         ParameterBlock* parameter_block = residual_block->parameter_blocks()[j];
-        parameter_block_description +=
-            parameter_block->ToString() + "\n";
+        parameter_block_description += parameter_block->ToString() + "\n";
       }
       LOG(FATAL) << "Ceres internal error: "
                  << "Duplicate parameter blocks detected in a cost function. "
@@ -196,7 +190,7 @@
 
 void CompressedRowJacobianWriter::Write(int residual_id,
                                         int residual_offset,
-                                        double **jacobians,
+                                        double** jacobians,
                                         SparseMatrix* base_jacobian) {
   CompressedRowSparseMatrix* jacobian =
       down_cast<CompressedRowSparseMatrix*>(base_jacobian);
diff --git a/internal/ceres/compressed_row_jacobian_writer.h b/internal/ceres/compressed_row_jacobian_writer.h
index 9fb414e..b1251ca 100644
--- a/internal/ceres/compressed_row_jacobian_writer.h
+++ b/internal/ceres/compressed_row_jacobian_writer.h
@@ -50,8 +50,7 @@
  public:
   CompressedRowJacobianWriter(Evaluator::Options /* ignored */,
                               Program* program)
-    : program_(program) {
-  }
+      : program_(program) {}
 
   // PopulateJacobianRowAndColumnBlockVectors sets col_blocks and
   // row_blocks for a CompressedRowSparseMatrix, based on the
@@ -64,8 +63,7 @@
   // (Jacobian writers do not fall under any type hierarchy; they only
   // have to provide an interface as specified in program_evaluator.h).
   static void PopulateJacobianRowAndColumnBlockVectors(
-      const Program* program,
-      CompressedRowSparseMatrix* jacobian);
+      const Program* program, CompressedRowSparseMatrix* jacobian);
 
   // It is necessary to determine the order of the jacobian blocks
   // before copying them into a CompressedRowSparseMatrix (or derived
@@ -99,7 +97,7 @@
 
   void Write(int residual_id,
              int residual_offset,
-             double **jacobians,
+             double** jacobians,
              SparseMatrix* base_jacobian);
 
  private:
diff --git a/internal/ceres/compressed_row_sparse_matrix.cc b/internal/ceres/compressed_row_sparse_matrix.cc
index e56de16..900586c 100644
--- a/internal/ceres/compressed_row_sparse_matrix.cc
+++ b/internal/ceres/compressed_row_sparse_matrix.cc
@@ -33,6 +33,7 @@
 #include <algorithm>
 #include <numeric>
 #include <vector>
+
 #include "ceres/crs_matrix.h"
 #include "ceres/internal/port.h"
 #include "ceres/random.h"
diff --git a/internal/ceres/compressed_row_sparse_matrix.h b/internal/ceres/compressed_row_sparse_matrix.h
index 758b40b..203c7ea 100644
--- a/internal/ceres/compressed_row_sparse_matrix.h
+++ b/internal/ceres/compressed_row_sparse_matrix.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_COMPRESSED_ROW_SPARSE_MATRIX_H_
 
 #include <vector>
+
 #include "ceres/internal/port.h"
 #include "ceres/sparse_matrix.h"
 #include "ceres/types.h"
diff --git a/internal/ceres/compressed_row_sparse_matrix_test.cc b/internal/ceres/compressed_row_sparse_matrix_test.cc
index 214f374..91f3ba4 100644
--- a/internal/ceres/compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/compressed_row_sparse_matrix_test.cc
@@ -32,6 +32,8 @@
 
 #include <memory>
 #include <numeric>
+
+#include "Eigen/SparseCore"
 #include "ceres/casts.h"
 #include "ceres/crs_matrix.h"
 #include "ceres/internal/eigen.h"
@@ -41,8 +43,6 @@
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
-#include "Eigen/SparseCore"
-
 namespace ceres {
 namespace internal {
 
@@ -445,11 +445,12 @@
                   0.0,
                   std::numeric_limits<double>::epsilon() * 10)
           << "\n"
-          << dense
-          << "x:\n"
+          << dense << "x:\n"
           << x.transpose() << "\n"
-          << "expected: \n" << expected_y.transpose() << "\n"
-          << "actual: \n" << actual_y.transpose();
+          << "expected: \n"
+          << expected_y.transpose() << "\n"
+          << "actual: \n"
+          << actual_y.transpose();
     }
   }
 }
@@ -513,11 +514,12 @@
                   0.0,
                   std::numeric_limits<double>::epsilon() * 10)
           << "\n"
-          << dense
-          << "x\n"
+          << dense << "x\n"
           << x.transpose() << "\n"
-          << "expected: \n" << expected_y.transpose() << "\n"
-          << "actual: \n" << actual_y.transpose();
+          << "expected: \n"
+          << expected_y.transpose() << "\n"
+          << "actual: \n"
+          << actual_y.transpose();
     }
   }
 }
@@ -579,9 +581,10 @@
                   0.0,
                   std::numeric_limits<double>::epsilon() * 10)
           << "\n"
-          << dense
-          << "expected: \n" << expected.transpose() << "\n"
-          << "actual: \n" << actual.transpose();
+          << dense << "expected: \n"
+          << expected.transpose() << "\n"
+          << "actual: \n"
+          << actual.transpose();
     }
   }
 }
@@ -594,7 +597,6 @@
                       CompressedRowSparseMatrix::UNSYMMETRIC),
     ParamInfoToString);
 
-
 // TODO(sameeragarwal) Add tests for the random matrix creation methods.
 
 }  // namespace internal
diff --git a/internal/ceres/concurrent_queue.h b/internal/ceres/concurrent_queue.h
index 52e2903..a04d147 100644
--- a/internal/ceres/concurrent_queue.h
+++ b/internal/ceres/concurrent_queue.h
@@ -152,7 +152,6 @@
   bool wait_;
 };
 
-
 }  // namespace internal
 }  // namespace ceres
 
diff --git a/internal/ceres/concurrent_queue_test.cc b/internal/ceres/concurrent_queue_test.cc
index ce6d687..430111a 100644
--- a/internal/ceres/concurrent_queue_test.cc
+++ b/internal/ceres/concurrent_queue_test.cc
@@ -37,7 +37,6 @@
 #include <thread>
 
 #include "ceres/concurrent_queue.h"
-
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -304,4 +303,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX_THREADS
+#endif  // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/conditioned_cost_function.cc b/internal/ceres/conditioned_cost_function.cc
index d933ad7..fb4c52a 100644
--- a/internal/ceres/conditioned_cost_function.cc
+++ b/internal/ceres/conditioned_cost_function.cc
@@ -68,7 +68,8 @@
 
 ConditionedCostFunction::~ConditionedCostFunction() {
   if (ownership_ == TAKE_OWNERSHIP) {
-    STLDeleteUniqueContainerPointers(conditioners_.begin(), conditioners_.end());
+    STLDeleteUniqueContainerPointers(conditioners_.begin(),
+                                     conditioners_.end());
   } else {
     wrapped_cost_function_.release();
   }
@@ -77,8 +78,8 @@
 bool ConditionedCostFunction::Evaluate(double const* const* parameters,
                                        double* residuals,
                                        double** jacobians) const {
-  bool success = wrapped_cost_function_->Evaluate(parameters, residuals,
-                                                  jacobians);
+  bool success =
+      wrapped_cost_function_->Evaluate(parameters, residuals, jacobians);
   if (!success) {
     return false;
   }
@@ -102,9 +103,8 @@
 
       double unconditioned_residual = residuals[r];
       double* parameter_pointer = &unconditioned_residual;
-      success = conditioners_[r]->Evaluate(&parameter_pointer,
-                                           &residuals[r],
-                                           conditioner_derivative_pointer2);
+      success = conditioners_[r]->Evaluate(
+          &parameter_pointer, &residuals[r], conditioner_derivative_pointer2);
       if (!success) {
         return false;
       }
@@ -117,7 +117,8 @@
             int parameter_block_size =
                 wrapped_cost_function_->parameter_block_sizes()[i];
             VectorRef jacobian_row(jacobians[i] + r * parameter_block_size,
-                                   parameter_block_size, 1);
+                                   parameter_block_size,
+                                   1);
             jacobian_row *= conditioner_derivative;
           }
         }
diff --git a/internal/ceres/conditioned_cost_function_test.cc b/internal/ceres/conditioned_cost_function_test.cc
index cd15507..f21f84c 100644
--- a/internal/ceres/conditioned_cost_function_test.cc
+++ b/internal/ceres/conditioned_cost_function_test.cc
@@ -125,7 +125,8 @@
   // Make a cost function that computes x - v2
   double v2[kTestCostFunctionSize];
   VectorRef v2_vector(v2, kTestCostFunctionSize, 1);
-  Matrix identity = Matrix::Identity(kTestCostFunctionSize, kTestCostFunctionSize);
+  Matrix identity =
+      Matrix::Identity(kTestCostFunctionSize, kTestCostFunctionSize);
   NormalPrior* difference_cost_function = new NormalPrior(identity, v2_vector);
   CostFunction* conditioner = new LinearCostFunction(2, 7);
   std::vector<CostFunction*> conditioners;
diff --git a/internal/ceres/conjugate_gradients_solver.cc b/internal/ceres/conjugate_gradients_solver.cc
index c6f85c1..3019628 100644
--- a/internal/ceres/conjugate_gradients_solver.cc
+++ b/internal/ceres/conjugate_gradients_solver.cc
@@ -41,6 +41,7 @@
 
 #include <cmath>
 #include <cstddef>
+
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_operator.h"
 #include "ceres/stringprintf.h"
@@ -51,16 +52,13 @@
 namespace internal {
 namespace {
 
-bool IsZeroOrInfinity(double x) {
-  return ((x == 0.0) || std::isinf(x));
-}
+bool IsZeroOrInfinity(double x) { return ((x == 0.0) || std::isinf(x)); }
 
 }  // namespace
 
 ConjugateGradientsSolver::ConjugateGradientsSolver(
     const LinearSolver::Options& options)
-    : options_(options) {
-}
+    : options_(options) {}
 
 LinearSolver::Summary ConjugateGradientsSolver::Solve(
     LinearOperator* A,
@@ -137,7 +135,10 @@
         summary.termination_type = LINEAR_SOLVER_FAILURE;
         summary.message = StringPrintf(
             "Numerical failure. beta = rho_n / rho_{n-1} = %e, "
-            "rho_n = %e, rho_{n-1} = %e", beta, rho, last_rho);
+            "rho_n = %e, rho_{n-1} = %e",
+            beta,
+            rho,
+            last_rho);
         break;
       }
       p = z + beta * p;
@@ -152,16 +153,20 @@
       summary.message = StringPrintf(
           "Matrix is indefinite, no more progress can be made. "
           "p'q = %e. |p| = %e, |q| = %e",
-          pq, p.norm(), q.norm());
+          pq,
+          p.norm(),
+          q.norm());
       break;
     }
 
     const double alpha = rho / pq;
     if (std::isinf(alpha)) {
       summary.termination_type = LINEAR_SOLVER_FAILURE;
-      summary.message =
-          StringPrintf("Numerical failure. alpha = rho / pq = %e, "
-                       "rho = %e, pq = %e.", alpha, rho, pq);
+      summary.message = StringPrintf(
+          "Numerical failure. alpha = rho / pq = %e, rho = %e, pq = %e.",
+          alpha,
+          rho,
+          pq);
       break;
     }
 
@@ -223,7 +228,7 @@
     Q0 = Q1;
 
     // Residual based termination.
-    norm_r = r. norm();
+    norm_r = r.norm();
     if (norm_r <= tol_r &&
         summary.num_iterations >= options_.min_num_iterations) {
       summary.termination_type = LINEAR_SOLVER_SUCCESS;
diff --git a/internal/ceres/conjugate_gradients_solver_test.cc b/internal/ceres/conjugate_gradients_solver_test.cc
index 9311998..b11e522 100644
--- a/internal/ceres/conjugate_gradients_solver_test.cc
+++ b/internal/ceres/conjugate_gradients_solver_test.cc
@@ -31,21 +31,23 @@
 // TODO(sameeragarwal): More comprehensive testing with larger and
 // more badly conditioned problem.
 
-#include <memory>
-#include "gtest/gtest.h"
 #include "ceres/conjugate_gradients_solver.h"
+
+#include <memory>
+
+#include "ceres/internal/eigen.h"
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "ceres/internal/eigen.h"
 #include "ceres/types.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
 
 TEST(ConjugateGradientTest, Solves3x3IdentitySystem) {
-  double diagonal[] = { 1.0, 1.0, 1.0 };
-  std::unique_ptr<TripletSparseMatrix>
-      A(TripletSparseMatrix::CreateSparseDiagonalMatrix(diagonal, 3));
+  double diagonal[] = {1.0, 1.0, 1.0};
+  std::unique_ptr<TripletSparseMatrix> A(
+      TripletSparseMatrix::CreateSparseDiagonalMatrix(diagonal, 3));
   Vector b(3);
   Vector x(3);
 
@@ -75,7 +77,6 @@
   ASSERT_DOUBLE_EQ(3, x(2));
 }
 
-
 TEST(ConjuateGradientTest, Solves3x3SymmetricSystem) {
   std::unique_ptr<TripletSparseMatrix> A(new TripletSparseMatrix(3, 3, 9));
   Vector b(3);
diff --git a/internal/ceres/context.cc b/internal/ceres/context.cc
index e223201..55e7635 100644
--- a/internal/ceres/context.cc
+++ b/internal/ceres/context.cc
@@ -34,8 +34,6 @@
 
 namespace ceres {
 
-Context* Context::Create() {
-  return new internal::ContextImpl();
-}
+Context* Context::Create() { return new internal::ContextImpl(); }
 
 }  // namespace ceres
diff --git a/internal/ceres/context_impl.cc b/internal/ceres/context_impl.cc
index 622f33a..20fe5cb 100644
--- a/internal/ceres/context_impl.cc
+++ b/internal/ceres/context_impl.cc
@@ -37,7 +37,6 @@
 #ifdef CERES_USE_CXX_THREADS
   thread_pool.Resize(num_threads);
 #endif  // CERES_USE_CXX_THREADS
-
 }
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/context_impl.h b/internal/ceres/context_impl.h
index 5c03ad7..90ba344 100644
--- a/internal/ceres/context_impl.h
+++ b/internal/ceres/context_impl.h
@@ -32,7 +32,9 @@
 #define CERES_INTERNAL_CONTEXT_IMPL_H_
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clanf-format on
 
 #include "ceres/context.h"
 
diff --git a/internal/ceres/coordinate_descent_minimizer.cc b/internal/ceres/coordinate_descent_minimizer.cc
index c5d56f3..93096ac 100644
--- a/internal/ceres/coordinate_descent_minimizer.cc
+++ b/internal/ceres/coordinate_descent_minimizer.cc
@@ -64,8 +64,7 @@
   CHECK(context_ != nullptr);
 }
 
-CoordinateDescentMinimizer::~CoordinateDescentMinimizer() {
-}
+CoordinateDescentMinimizer::~CoordinateDescentMinimizer() {}
 
 bool CoordinateDescentMinimizer::Init(
     const Program& program,
@@ -82,13 +81,13 @@
   map<int, set<double*>> group_to_elements = ordering.group_to_elements();
   for (const auto& g_t_e : group_to_elements) {
     const auto& elements = g_t_e.second;
-    for (double* parameter_block: elements) {
+    for (double* parameter_block : elements) {
       parameter_blocks_.push_back(parameter_map.find(parameter_block)->second);
       parameter_block_index[parameter_blocks_.back()] =
           parameter_blocks_.size() - 1;
     }
-    independent_set_offsets_.push_back(
-        independent_set_offsets_.back() + elements.size());
+    independent_set_offsets_.push_back(independent_set_offsets_.back() +
+                                       elements.size());
   }
 
   // The ordering does not have to contain all parameter blocks, so
@@ -126,10 +125,9 @@
   return true;
 }
 
-void CoordinateDescentMinimizer::Minimize(
-    const Minimizer::Options& options,
-    double* parameters,
-    Solver::Summary* summary) {
+void CoordinateDescentMinimizer::Minimize(const Minimizer::Options& options,
+                                          double* parameters,
+                                          Solver::Summary* summary) {
   // Set the state and mark all parameter blocks constant.
   for (int i = 0; i < parameter_blocks_.size(); ++i) {
     ParameterBlock* parameter_block = parameter_blocks_[i];
@@ -202,7 +200,7 @@
         });
   }
 
-  for (int i =  0; i < parameter_blocks_.size(); ++i) {
+  for (int i = 0; i < parameter_blocks_.size(); ++i) {
     parameter_blocks_[i]->SetVarying();
   }
 
@@ -251,10 +249,10 @@
   // Verify that each group is an independent set
   for (const auto& g_t_e : group_to_elements) {
     if (!program.IsParameterBlockSetIndependent(g_t_e.second)) {
-      *message =
-          StringPrintf("The user-provided "
-                       "parameter_blocks_for_inner_iterations does not "
-                       "form an independent set. Group Id: %d", g_t_e.first);
+      *message = StringPrintf(
+          "The user-provided parameter_blocks_for_inner_iterations does not "
+          "form an independent set. Group Id: %d",
+          g_t_e.first);
       return false;
     }
   }
diff --git a/internal/ceres/corrector.cc b/internal/ceres/corrector.cc
index 4ac0dc3..6a79a06 100644
--- a/internal/ceres/corrector.cc
+++ b/internal/ceres/corrector.cc
@@ -30,8 +30,9 @@
 
 #include "ceres/corrector.h"
 
-#include <cstddef>
 #include <cmath>
+#include <cstddef>
+
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 
@@ -147,9 +148,9 @@
     }
 
     for (int r = 0; r < num_rows; ++r) {
-      jacobian[r * num_cols + c] = sqrt_rho1_ *
-          (jacobian[r * num_cols + c] -
-           alpha_sq_norm_ * residuals[r] * r_transpose_j);
+      jacobian[r * num_cols + c] =
+          sqrt_rho1_ * (jacobian[r * num_cols + c] -
+                        alpha_sq_norm_ * residuals[r] * r_transpose_j);
     }
   }
 }
diff --git a/internal/ceres/corrector_test.cc b/internal/ceres/corrector_test.cc
index a6581fd..951041e 100644
--- a/internal/ceres/corrector_test.cc
+++ b/internal/ceres/corrector_test.cc
@@ -32,11 +32,12 @@
 
 #include <algorithm>
 #include <cmath>
-#include <cstring>
 #include <cstdlib>
-#include "gtest/gtest.h"
-#include "ceres/random.h"
+#include <cstring>
+
 #include "ceres/internal/eigen.h"
+#include "ceres/random.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -44,15 +45,13 @@
 // If rho[1] is zero, the Corrector constructor should crash.
 TEST(Corrector, ZeroGradientDeathTest) {
   const double kRho[] = {0.0, 0.0, 1.0};
-  EXPECT_DEATH_IF_SUPPORTED({Corrector c(1.0, kRho);},
-               ".*");
+  EXPECT_DEATH_IF_SUPPORTED({ Corrector c(1.0, kRho); }, ".*");
 }
 
 // If rho[1] is negative, the Corrector constructor should crash.
 TEST(Corrector, NegativeGradientDeathTest) {
   const double kRho[] = {0.0, -0.1, 1.0};
-  EXPECT_DEATH_IF_SUPPORTED({Corrector c(1.0, kRho);},
-               ".*");
+  EXPECT_DEATH_IF_SUPPORTED({ Corrector c(1.0, kRho); }, ".*");
 }
 
 TEST(Corrector, ScalarCorrection) {
@@ -68,8 +67,7 @@
 
   // Thus the expected value of the residual is
   // residual[i] * sqrt(kRho[1]) / (1.0 - kAlpha).
-  const double kExpectedResidual =
-      residuals * sqrt(kRho[1]) / (1 - kAlpha);
+  const double kExpectedResidual = residuals * sqrt(kRho[1]) / (1 - kAlpha);
 
   // The jacobian in this case will be
   // sqrt(kRho[1]) * (1 - kAlpha) * jacobian.
@@ -123,13 +121,11 @@
 
   // Thus the expected value of the residual is
   // residual[i] * sqrt(kRho[1]) / (1.0 - kAlpha).
-  const double kExpectedResidual =
-      residuals * sqrt(kRho[1]) / (1.0 - kAlpha);
+  const double kExpectedResidual = residuals * sqrt(kRho[1]) / (1.0 - kAlpha);
 
   // The jacobian in this case will be scaled by
   // sqrt(rho[1]) * (1 - alpha) * J.
-  const double kExpectedJacobian = sqrt(kRho[1]) *
-      (1.0 - kAlpha) * jacobian;
+  const double kExpectedJacobian = sqrt(kRho[1]) * (1.0 - kAlpha) * jacobian;
 
   Corrector c(sq_norm, kRho);
   c.CorrectJacobian(1, 1, &residuals, &jacobian);
@@ -168,10 +164,8 @@
   srand(5);
   for (int iter = 0; iter < 10000; ++iter) {
     // Initialize the jacobian and residual.
-    for (int i = 0; i < 2 * 3; ++i)
-      jacobian[i] = RandDouble();
-    for (int i = 0; i < 3; ++i)
-      residuals[i] = RandDouble();
+    for (int i = 0; i < 2 * 3; ++i) jacobian[i] = RandDouble();
+    for (int i = 0; i < 3; ++i) residuals[i] = RandDouble();
 
     const double sq_norm = res.dot(res);
 
@@ -188,19 +182,19 @@
 
     // Ground truth values.
     g_res = sqrt(rho[1]) / (1.0 - kAlpha) * res;
-    g_jac = sqrt(rho[1]) * (jac - kAlpha / sq_norm *
-                            res * res.transpose() * jac);
+    g_jac =
+        sqrt(rho[1]) * (jac - kAlpha / sq_norm * res * res.transpose() * jac);
 
     g_grad = rho[1] * jac.transpose() * res;
     g_hess = rho[1] * jac.transpose() * jac +
-        2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
+             2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
 
     Corrector c(sq_norm, rho);
     c.CorrectJacobian(3, 2, residuals, jacobian);
     c.CorrectResiduals(3, residuals);
 
     // Corrected gradient and hessian.
-    c_grad  = jac.transpose() * res;
+    c_grad = jac.transpose() * res;
     c_hess = jac.transpose() * jac;
 
     ASSERT_NEAR((g_res - res).norm(), 0.0, 1e-10);
@@ -236,8 +230,7 @@
   srand(5);
   for (int iter = 0; iter < 10000; ++iter) {
     // Initialize the jacobian.
-    for (int i = 0; i < 2 * 3; ++i)
-      jacobian[i] = RandDouble();
+    for (int i = 0; i < 2 * 3; ++i) jacobian[i] = RandDouble();
 
     // Zero residuals
     res.setZero();
@@ -254,7 +247,7 @@
 
     g_grad = rho[1] * jac.transpose() * res;
     g_hess = rho[1] * jac.transpose() * jac +
-        2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
+             2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
 
     Corrector c(sq_norm, rho);
     c.CorrectJacobian(3, 2, residuals, jacobian);
diff --git a/internal/ceres/cost_function_to_functor_test.cc b/internal/ceres/cost_function_to_functor_test.cc
index 0a6d86c..11f47e3 100644
--- a/internal/ceres/cost_function_to_functor_test.cc
+++ b/internal/ceres/cost_function_to_functor_test.cc
@@ -32,9 +32,10 @@
 
 #include <cstdint>
 #include <memory>
+
+#include "ceres/autodiff_cost_function.h"
 #include "ceres/dynamic_autodiff_cost_function.h"
 #include "ceres/dynamic_cost_function_to_functor.h"
-#include "ceres/autodiff_cost_function.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -53,8 +54,7 @@
       cost_function.parameter_block_sizes();
   const vector<int32_t>& actual_parameter_block_sizes =
       actual_cost_function.parameter_block_sizes();
-  EXPECT_EQ(parameter_block_sizes.size(),
-            actual_parameter_block_sizes.size());
+  EXPECT_EQ(parameter_block_sizes.size(), actual_parameter_block_sizes.size());
 
   int num_parameters = 0;
   for (int i = 0; i < parameter_block_sizes.size(); ++i) {
@@ -68,11 +68,12 @@
   }
 
   std::unique_ptr<double[]> residuals(new double[num_residuals]);
-  std::unique_ptr<double[]> jacobians(new double[num_parameters * num_residuals]);
+  std::unique_ptr<double[]> jacobians(
+      new double[num_parameters * num_residuals]);
 
   std::unique_ptr<double[]> actual_residuals(new double[num_residuals]);
-  std::unique_ptr<double[]> actual_jacobians
-      (new double[num_parameters * num_residuals]);
+  std::unique_ptr<double[]> actual_jacobians(
+      new double[num_parameters * num_residuals]);
 
   std::unique_ptr<double*[]> parameter_blocks(
       new double*[parameter_block_sizes.size()]);
@@ -90,19 +91,17 @@
     num_parameters += parameter_block_sizes[i];
   }
 
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.get(),
-                                     residuals.get(), NULL));
-  EXPECT_TRUE(actual_cost_function.Evaluate(parameter_blocks.get(),
-                                            actual_residuals.get(), NULL));
+  EXPECT_TRUE(
+      cost_function.Evaluate(parameter_blocks.get(), residuals.get(), NULL));
+  EXPECT_TRUE(actual_cost_function.Evaluate(
+      parameter_blocks.get(), actual_residuals.get(), NULL));
   for (int i = 0; i < num_residuals; ++i) {
     EXPECT_NEAR(residuals[i], actual_residuals[i], kTolerance)
         << "residual id: " << i;
   }
 
-
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.get(),
-                                     residuals.get(),
-                                     jacobian_blocks.get()));
+  EXPECT_TRUE(cost_function.Evaluate(
+      parameter_blocks.get(), residuals.get(), jacobian_blocks.get()));
   EXPECT_TRUE(actual_cost_function.Evaluate(parameter_blocks.get(),
                                             actual_residuals.get(),
                                             actual_jacobian_blocks.get()));
@@ -113,8 +112,8 @@
 
   for (int i = 0; i < num_residuals * num_parameters; ++i) {
     EXPECT_NEAR(jacobians[i], actual_jacobians[i], kTolerance)
-        << "jacobian : " << i << " "
-        << jacobians[i] << " " << actual_jacobians[i];
+        << "jacobian : " << i << " " << jacobians[i] << " "
+        << actual_jacobians[i];
   }
 }
 
@@ -132,8 +131,8 @@
  public:
   template <typename T>
   bool operator()(const T* x1, const T* x2, T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1];
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1];
     return true;
   }
 };
@@ -142,8 +141,8 @@
  public:
   template <typename T>
   bool operator()(const T* x1, const T* x2, const T* x3, T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1];
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1];
     return true;
   }
 };
@@ -151,12 +150,12 @@
 struct FourParameterBlockFunctor {
  public:
   template <typename T>
-  bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
-                  T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0]
-        + x4[0] * x4[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1]
-        + x4[1] * x4[1];
+  bool operator()(
+      const T* x1, const T* x2, const T* x3, const T* x4, T* residuals) const {
+    residuals[0] =
+        x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] + x4[0] * x4[0];
+    residuals[1] =
+        x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] + x4[1] * x4[1];
     return true;
   }
 };
@@ -164,12 +163,16 @@
 struct FiveParameterBlockFunctor {
  public:
   template <typename T>
-  bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
-                  const T* x5, T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0]
-        + x4[0] * x4[0] + x5[0] * x5[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1]
-        + x4[1] * x4[1] + x5[1] * x5[1];
+  bool operator()(const T* x1,
+                  const T* x2,
+                  const T* x3,
+                  const T* x4,
+                  const T* x5,
+                  T* residuals) const {
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+                   x4[0] * x4[0] + x5[0] * x5[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+                   x4[1] * x4[1] + x5[1] * x5[1];
     return true;
   }
 };
@@ -177,12 +180,17 @@
 struct SixParameterBlockFunctor {
  public:
   template <typename T>
-  bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
-                  const T* x5, const T* x6,  T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0]
-        + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1]
-        + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1];
+  bool operator()(const T* x1,
+                  const T* x2,
+                  const T* x3,
+                  const T* x4,
+                  const T* x5,
+                  const T* x6,
+                  T* residuals) const {
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+                   x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+                   x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1];
     return true;
   }
 };
@@ -190,12 +198,20 @@
 struct SevenParameterBlockFunctor {
  public:
   template <typename T>
-  bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
-                  const T* x5, const T* x6, const T* x7, T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0]
-        + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1]
-        + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1];
+  bool operator()(const T* x1,
+                  const T* x2,
+                  const T* x3,
+                  const T* x4,
+                  const T* x5,
+                  const T* x6,
+                  const T* x7,
+                  T* residuals) const {
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+                   x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+                   x7[0] * x7[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+                   x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+                   x7[1] * x7[1];
     return true;
   }
 };
@@ -203,15 +219,21 @@
 struct EightParameterBlockFunctor {
  public:
   template <typename T>
-  bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
-                  const T* x5, const T* x6, const T* x7, const T* x8,
+  bool operator()(const T* x1,
+                  const T* x2,
+                  const T* x3,
+                  const T* x4,
+                  const T* x5,
+                  const T* x6,
+                  const T* x7,
+                  const T* x8,
                   T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0]
-        + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0]
-        + x8[0] * x8[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1]
-        + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1]
-        + x8[1] * x8[1];
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+                   x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+                   x7[0] * x7[0] + x8[0] * x8[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+                   x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+                   x7[1] * x7[1] + x8[1] * x8[1];
     return true;
   }
 };
@@ -219,15 +241,22 @@
 struct NineParameterBlockFunctor {
  public:
   template <typename T>
-  bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
-                  const T* x5, const T* x6, const T* x7, const T* x8,
-                  const T* x9, T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0]
-        + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0]
-        + x8[0] * x8[0] + x9[0] * x9[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1]
-        + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1]
-        + x8[1] * x8[1] + x9[1] * x9[1];
+  bool operator()(const T* x1,
+                  const T* x2,
+                  const T* x3,
+                  const T* x4,
+                  const T* x5,
+                  const T* x6,
+                  const T* x7,
+                  const T* x8,
+                  const T* x9,
+                  T* residuals) const {
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+                   x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+                   x7[0] * x7[0] + x8[0] * x8[0] + x9[0] * x9[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+                   x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+                   x7[1] * x7[1] + x8[1] * x8[1] + x9[1] * x9[1];
     return true;
   }
 };
@@ -235,15 +264,25 @@
 struct TenParameterBlockFunctor {
  public:
   template <typename T>
-  bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
-                  const T* x5, const T* x6, const T* x7, const T* x8,
-                  const T* x9, const T* x10, T* residuals) const {
-    residuals[0] = x1[0] * x1[0]  + x2[0] * x2[0] + x3[0] * x3[0]
-        + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0]
-        + x8[0] * x8[0] + x9[0] * x9[0] + x10[0] * x10[0];
-    residuals[1] = x1[1] * x1[1]  + x2[1] * x2[1] + x3[1] * x3[1]
-        + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1]
-        + x8[1] * x8[1] + x9[1] * x9[1] + x10[1] * x10[1];
+  bool operator()(const T* x1,
+                  const T* x2,
+                  const T* x3,
+                  const T* x4,
+                  const T* x5,
+                  const T* x6,
+                  const T* x7,
+                  const T* x8,
+                  const T* x9,
+                  const T* x10,
+                  T* residuals) const {
+    residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+                   x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+                   x7[0] * x7[0] + x8[0] * x8[0] + x9[0] * x9[0] +
+                   x10[0] * x10[0];
+    residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+                   x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+                   x7[1] * x7[1] + x8[1] * x8[1] + x9[1] * x9[1] +
+                   x10[1] * x10[1];
     return true;
   }
 };
@@ -281,39 +320,39 @@
 TEST_BODY(OneParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2
+#define PARAMETER_BLOCK_SIZES 2, 2
 TEST_BODY(TwoParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2
 TEST_BODY(ThreeParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2
 TEST_BODY(FourParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2
 TEST_BODY(FiveParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2
 TEST_BODY(SixParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2
 TEST_BODY(SevenParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2, 2
 TEST_BODY(EightParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2, 2, 2
 TEST_BODY(NineParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
 TEST_BODY(TenParameterBlockFunctor)
 #undef PARAMETER_BLOCK_SIZES
 
@@ -321,14 +360,17 @@
 
 TEST(CostFunctionToFunctor, DynamicNumberOfResiduals) {
   std::unique_ptr<CostFunction> cost_function(
-      new AutoDiffCostFunction<
-      CostFunctionToFunctor<ceres::DYNAMIC, 2, 2 >, ceres::DYNAMIC, 2, 2>(
-          new CostFunctionToFunctor<ceres::DYNAMIC, 2, 2 >(
-              new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2 >(
-                  new TwoParameterBlockFunctor)), 2));
+      new AutoDiffCostFunction<CostFunctionToFunctor<ceres::DYNAMIC, 2, 2>,
+                               ceres::DYNAMIC,
+                               2,
+                               2>(
+          new CostFunctionToFunctor<ceres::DYNAMIC, 2, 2>(
+              new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2>(
+                  new TwoParameterBlockFunctor)),
+          2));
 
   std::unique_ptr<CostFunction> actual_cost_function(
-      new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2 >(
+      new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2>(
           new TwoParameterBlockFunctor));
   ExpectCostFunctionsAreEqual(*cost_function, *actual_cost_function);
 }
@@ -336,8 +378,8 @@
 TEST(CostFunctionToFunctor, DynamicCostFunctionToFunctor) {
   DynamicAutoDiffCostFunction<DynamicTwoParameterBlockFunctor>*
       actual_cost_function(
-      new DynamicAutoDiffCostFunction<DynamicTwoParameterBlockFunctor>(
-          new DynamicTwoParameterBlockFunctor));
+          new DynamicAutoDiffCostFunction<DynamicTwoParameterBlockFunctor>(
+              new DynamicTwoParameterBlockFunctor));
   actual_cost_function->AddParameterBlock(2);
   actual_cost_function->AddParameterBlock(2);
   actual_cost_function->SetNumResiduals(2);
diff --git a/internal/ceres/covariance.cc b/internal/ceres/covariance.cc
index 8256078..8e240ff 100644
--- a/internal/ceres/covariance.cc
+++ b/internal/ceres/covariance.cc
@@ -32,6 +32,7 @@
 
 #include <utility>
 #include <vector>
+
 #include "ceres/covariance_impl.h"
 #include "ceres/problem.h"
 #include "ceres/problem_impl.h"
@@ -46,8 +47,7 @@
   impl_.reset(new internal::CovarianceImpl(options));
 }
 
-Covariance::~Covariance() {
-}
+Covariance::~Covariance() {}
 
 bool Covariance::Compute(
     const vector<pair<const double*, const double*>>& covariance_blocks,
@@ -55,9 +55,8 @@
   return impl_->Compute(covariance_blocks, problem->impl_.get());
 }
 
-bool Covariance::Compute(
-    const vector<const double*>& parameter_blocks,
-    Problem* problem) {
+bool Covariance::Compute(const vector<const double*>& parameter_blocks,
+                         Problem* problem) {
   return impl_->Compute(parameter_blocks, problem->impl_.get());
 }
 
@@ -89,8 +88,8 @@
 }
 
 bool Covariance::GetCovarianceMatrixInTangentSpace(
-    const std::vector<const double *>& parameter_blocks,
-    double *covariance_matrix) const {
+    const std::vector<const double*>& parameter_blocks,
+    double* covariance_matrix) const {
   return impl_->GetCovarianceMatrixInTangentOrAmbientSpace(parameter_blocks,
                                                            false,  // tangent
                                                            covariance_matrix);
diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 34a36c6..229173f 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -31,8 +31,8 @@
 #include "ceres/covariance.h"
 
 #include <algorithm>
-#include <cstdint>
 #include <cmath>
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <utility>
@@ -54,7 +54,7 @@
 using std::pair;
 using std::vector;
 
-class UnaryCostFunction: public CostFunction {
+class UnaryCostFunction : public CostFunction {
  public:
   UnaryCostFunction(const int num_residuals,
                     const int32_t parameter_block_size,
@@ -86,8 +86,7 @@
   vector<double> jacobian_;
 };
 
-
-class BinaryCostFunction: public CostFunction {
+class BinaryCostFunction : public CostFunction {
  public:
   BinaryCostFunction(const int num_residuals,
                      const int32_t parameter_block1_size,
@@ -193,6 +192,7 @@
   //  . . . . . . X X X X
   //  . . . . . . X X X X
 
+  // clang-format off
   int expected_rows[] = {0, 5, 10, 15, 18, 21, 24, 28, 32, 36, 40};
   int expected_cols[] = {0, 6, 7, 8, 9,
                          1, 2, 3, 4, 5,
@@ -204,7 +204,7 @@
                          6, 7, 8, 9,
                          6, 7, 8, 9,
                          6, 7, 8, 9};
-
+  // clang-format on
 
   vector<pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.push_back(make_pair(block1, block1));
@@ -216,8 +216,8 @@
 
   Covariance::Options options;
   CovarianceImpl covariance_impl(options);
-  EXPECT_TRUE(covariance_impl
-              .ComputeCovarianceSparsity(covariance_blocks, &problem));
+  EXPECT_TRUE(
+      covariance_impl.ComputeCovarianceSparsity(covariance_blocks, &problem));
 
   const CompressedRowSparseMatrix* crsm = covariance_impl.covariance_matrix();
 
@@ -228,17 +228,13 @@
   const int* rows = crsm->rows();
   for (int r = 0; r < crsm->num_rows() + 1; ++r) {
     EXPECT_EQ(rows[r], expected_rows[r])
-        << r << " "
-        << rows[r] << " "
-        << expected_rows[r];
+        << r << " " << rows[r] << " " << expected_rows[r];
   }
 
   const int* cols = crsm->cols();
   for (int c = 0; c < crsm->num_nonzeros(); ++c) {
     EXPECT_EQ(cols[c], expected_cols[c])
-        << c << " "
-        << cols[c] << " "
-        << expected_cols[c];
+        << c << " " << cols[c] << " " << expected_cols[c];
   }
 }
 
@@ -280,6 +276,7 @@
   //  . . . X X X X
   //  . . . X X X X
 
+  // clang-format off
   int expected_rows[] = {0, 5, 7, 9, 13, 17, 21, 25};
   int expected_cols[] = {0, 3, 4, 5, 6,
                          1, 2,
@@ -288,6 +285,7 @@
                          3, 4, 5, 6,
                          3, 4, 5, 6,
                          3, 4, 5, 6};
+  // clang-format on
 
   vector<pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.push_back(make_pair(block1, block1));
@@ -299,8 +297,8 @@
 
   Covariance::Options options;
   CovarianceImpl covariance_impl(options);
-  EXPECT_TRUE(covariance_impl
-              .ComputeCovarianceSparsity(covariance_blocks, &problem));
+  EXPECT_TRUE(
+      covariance_impl.ComputeCovarianceSparsity(covariance_blocks, &problem));
 
   const CompressedRowSparseMatrix* crsm = covariance_impl.covariance_matrix();
 
@@ -311,17 +309,13 @@
   const int* rows = crsm->rows();
   for (int r = 0; r < crsm->num_rows() + 1; ++r) {
     EXPECT_EQ(rows[r], expected_rows[r])
-        << r << " "
-        << rows[r] << " "
-        << expected_rows[r];
+        << r << " " << rows[r] << " " << expected_rows[r];
   }
 
   const int* cols = crsm->cols();
   for (int c = 0; c < crsm->num_nonzeros(); ++c) {
     EXPECT_EQ(cols[c], expected_cols[c])
-        << c << " "
-        << cols[c] << " "
-        << expected_cols[c];
+        << c << " " << cols[c] << " " << expected_cols[c];
   }
 }
 
@@ -361,6 +355,7 @@
   //  . . . X X X X
   //  . . . X X X X
 
+  // clang-format off
   int expected_rows[] = {0, 5, 7, 9, 13, 17, 21, 25};
   int expected_cols[] = {0, 3, 4, 5, 6,
                          1, 2,
@@ -369,6 +364,7 @@
                          3, 4, 5, 6,
                          3, 4, 5, 6,
                          3, 4, 5, 6};
+  // clang-format on
 
   vector<pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.push_back(make_pair(block1, block1));
@@ -380,8 +376,8 @@
 
   Covariance::Options options;
   CovarianceImpl covariance_impl(options);
-  EXPECT_TRUE(covariance_impl
-              .ComputeCovarianceSparsity(covariance_blocks, &problem));
+  EXPECT_TRUE(
+      covariance_impl.ComputeCovarianceSparsity(covariance_blocks, &problem));
 
   const CompressedRowSparseMatrix* crsm = covariance_impl.covariance_matrix();
 
@@ -392,17 +388,13 @@
   const int* rows = crsm->rows();
   for (int r = 0; r < crsm->num_rows() + 1; ++r) {
     EXPECT_EQ(rows[r], expected_rows[r])
-        << r << " "
-        << rows[r] << " "
-        << expected_rows[r];
+        << r << " " << rows[r] << " " << expected_rows[r];
   }
 
   const int* cols = crsm->cols();
   for (int c = 0; c < crsm->num_nonzeros(); ++c) {
     EXPECT_EQ(cols[c], expected_cols[c])
-        << c << " "
-        << cols[c] << " "
-        << expected_cols[c];
+        << c << " " << cols[c] << " " << expected_cols[c];
   }
 }
 
@@ -423,40 +415,33 @@
     z[0] = 3;
 
     {
-      double jacobian[] = { 1.0, 0.0, 0.0, 1.0};
+      double jacobian[] = {1.0, 0.0, 0.0, 1.0};
       problem_.AddResidualBlock(new UnaryCostFunction(2, 2, jacobian), NULL, x);
     }
 
     {
-      double jacobian[] = { 2.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 2.0 };
+      double jacobian[] = {2.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 2.0};
       problem_.AddResidualBlock(new UnaryCostFunction(3, 3, jacobian), NULL, y);
     }
 
     {
       double jacobian = 5.0;
-      problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian),
-                                NULL,
-                                z);
+      problem_.AddResidualBlock(
+          new UnaryCostFunction(1, 1, &jacobian), NULL, z);
     }
 
     {
-      double jacobian1[] = { 1.0, 2.0, 3.0 };
-      double jacobian2[] = { -5.0, -6.0 };
+      double jacobian1[] = {1.0, 2.0, 3.0};
+      double jacobian2[] = {-5.0, -6.0};
       problem_.AddResidualBlock(
-          new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2),
-          NULL,
-          y,
-          x);
+          new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2), NULL, y, x);
     }
 
     {
-      double jacobian1[] = {2.0 };
-      double jacobian2[] = { 3.0, -2.0 };
+      double jacobian1[] = {2.0};
+      double jacobian2[] = {3.0, -2.0};
       problem_.AddResidualBlock(
-          new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2),
-          NULL,
-          z,
-          x);
+          new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2), NULL, z, x);
     }
 
     all_covariance_blocks_.push_back(make_pair(x, x));
@@ -482,8 +467,7 @@
 
   // Computes covariance in tangent space.
   void ComputeAndCompareCovarianceBlocksInTangentSpace(
-                                         const Covariance::Options& options,
-                                         const double* expected_covariance) {
+      const Covariance::Options& options, const double* expected_covariance) {
     ComputeAndCompareCovarianceBlocksInTangentOrAmbientSpace(
         options,
         false,  // tangent
@@ -549,8 +533,9 @@
                                     bool lift_covariance_to_ambient_space,
                                     const Covariance& covariance,
                                     const double* expected_covariance) {
-    const BoundsMap& column_bounds = lift_covariance_to_ambient_space ?
-        column_bounds_ : local_column_bounds_;
+    const BoundsMap& column_bounds = lift_covariance_to_ambient_space
+                                         ? column_bounds_
+                                         : local_column_bounds_;
     const int row_begin = FindOrDie(column_bounds, block1).first;
     const int row_end = FindOrDie(column_bounds, block1).second;
     const int col_begin = FindOrDie(column_bounds, block2).first;
@@ -558,13 +543,10 @@
 
     Matrix actual(row_end - row_begin, col_end - col_begin);
     if (lift_covariance_to_ambient_space) {
-      EXPECT_TRUE(covariance.GetCovarianceBlock(block1,
-                                                block2,
-                                                actual.data()));
+      EXPECT_TRUE(covariance.GetCovarianceBlock(block1, block2, actual.data()));
     } else {
-      EXPECT_TRUE(covariance.GetCovarianceBlockInTangentSpace(block1,
-                                                              block2,
-                                                              actual.data()));
+      EXPECT_TRUE(covariance.GetCovarianceBlockInTangentSpace(
+          block1, block2, actual.data()));
     }
 
     int dof = 0;  // degrees of freedom = sum of LocalSize()s
@@ -572,22 +554,22 @@
       dof = std::max(dof, bound.second.second);
     }
     ConstMatrixRef expected(expected_covariance, dof, dof);
-    double diff_norm = (expected.block(row_begin,
-                                       col_begin,
-                                       row_end - row_begin,
-                                       col_end - col_begin) - actual).norm();
+    double diff_norm =
+        (expected.block(
+             row_begin, col_begin, row_end - row_begin, col_end - col_begin) -
+         actual)
+            .norm();
     diff_norm /= (row_end - row_begin) * (col_end - col_begin);
 
     const double kTolerance = 1e-5;
     EXPECT_NEAR(diff_norm, 0.0, kTolerance)
         << "rows: " << row_begin << " " << row_end << "  "
         << "cols: " << col_begin << " " << col_end << "  "
-        << "\n\n expected: \n " << expected.block(row_begin,
-                                                  col_begin,
-                                                  row_end - row_begin,
-                                                  col_end - col_begin)
-        << "\n\n actual: \n " << actual
-        << "\n\n full expected: \n" << expected;
+        << "\n\n expected: \n "
+        << expected.block(
+               row_begin, col_begin, row_end - row_begin, col_end - col_begin)
+        << "\n\n actual: \n " << actual << "\n\n full expected: \n"
+        << expected;
   }
 
   double parameters_[6];
@@ -597,7 +579,6 @@
   BoundsMap local_column_bounds_;
 };
 
-
 TEST_F(CovarianceTest, NormalBehavior) {
   // J
   //
@@ -620,6 +601,7 @@
   //    6  -4  0   0   0 29
 
   // inv(J'J) computed using octave.
+  // clang-format off
   double expected_covariance[] = {
      7.0747e-02,  -8.4923e-03,   1.6821e-02,   3.3643e-02,   5.0464e-02,  -1.5809e-02,  // NOLINT
     -8.4923e-03,   8.1352e-02,   2.4758e-02,   4.9517e-02,   7.4275e-02,   1.2978e-02,  // NOLINT
@@ -628,6 +610,7 @@
      5.0464e-02,   7.4275e-02,  -2.8906e-03,  -5.7813e-03,   2.4133e-01,  -1.9598e-04,  // NOLINT
     -1.5809e-02,   1.2978e-02,  -6.5325e-05,  -1.3065e-04,  -1.9598e-04,   3.9544e-02,  // NOLINT
   };
+  // clang-format on
 
   Covariance::Options options;
 
@@ -669,6 +652,7 @@
   //    6  -4  0   0   0 29
 
   // inv(J'J) computed using octave.
+  // clang-format off
   double expected_covariance[] = {
      7.0747e-02,  -8.4923e-03,   1.6821e-02,   3.3643e-02,   5.0464e-02,  -1.5809e-02,  // NOLINT
     -8.4923e-03,   8.1352e-02,   2.4758e-02,   4.9517e-02,   7.4275e-02,   1.2978e-02,  // NOLINT
@@ -677,6 +661,7 @@
      5.0464e-02,   7.4275e-02,  -2.8906e-03,  -5.7813e-03,   2.4133e-01,  -1.9598e-04,  // NOLINT
     -1.5809e-02,   1.2978e-02,  -6.5325e-05,  -1.3065e-04,  -1.9598e-04,   3.9544e-02,  // NOLINT
   };
+  // clang-format on
 
   Covariance::Options options;
   options.num_threads = 4;
@@ -721,6 +706,7 @@
   //  0  0  0  0  0 29
 
   // pinv(J'J) computed using octave.
+  // clang-format off
   double expected_covariance[] = {
               0,            0,            0,            0,            0,            0,  // NOLINT
               0,            0,            0,            0,            0,            0,  // NOLINT
@@ -728,6 +714,7 @@
               0,            0,     -0.02778,      0.19444,     -0.08333,     -0.00000,  // NOLINT
               0,            0,     -0.04167,     -0.08333,      0.12500,     -0.00000,  // NOLINT
               0,            0,     -0.00000,     -0.00000,     -0.00000,      0.03448   // NOLINT
+      // clang-format on
   };
 
   Covariance::Options options;
@@ -778,6 +765,7 @@
 
   // A * inv((J*A)'*(J*A)) * A'
   // Computed using octave.
+  // clang-format off
   double expected_covariance[] = {
     0.01766,   0.01766,   0.02158,   0.04316,   0.00000,  -0.00122,
     0.01766,   0.01766,   0.02158,   0.04316,   0.00000,  -0.00122,
@@ -786,6 +774,7 @@
     0.00000,   0.00000,   0.00000,   0.00000,   0.00000,   0.00000,
    -0.00122,  -0.00122,  -0.00149,  -0.00298,   0.00000,   0.03457
   };
+  // clang-format on
 
   Covariance::Options options;
 
@@ -840,12 +829,14 @@
 
   // inv((J*A)'*(J*A))
   // Computed using octave.
+  // clang-format off
   double expected_covariance[] = {
     0.01766,   0.02158,   0.04316,   -0.00122,
     0.02158,   0.24860,  -0.00281,   -0.00149,
     0.04316,  -0.00281,   0.24439,   -0.00298,
    -0.00122,  -0.00149,  -0.00298,    0.03457  // NOLINT
   };
+  // clang-format on
 
   Covariance::Options options;
 
@@ -903,12 +894,14 @@
 
   // pinv((J*A)'*(J*A))
   // Computed using octave.
+  // clang-format off
   double expected_covariance[] = {
     0.0, 0.0, 0.0, 0.0,
     0.0, 0.0, 0.0, 0.0,
     0.0, 0.0, 0.0, 0.0,
     0.0, 0.0, 0.0, 0.034482 // NOLINT
   };
+  // clang-format on
 
   Covariance::Options options;
 
@@ -951,6 +944,7 @@
   // 3.4142 is the smallest eigen value of J'J. The following matrix
   // was obtained by dropping the eigenvector corresponding to this
   // eigenvalue.
+  // clang-format off
   double expected_covariance[] = {
      5.4135e-02,  -3.5121e-02,   1.7257e-04,   3.4514e-04,   5.1771e-04,  -1.6076e-02,  // NOLINT
     -3.5121e-02,   3.8667e-02,  -1.9288e-03,  -3.8576e-03,  -5.7864e-03,   1.2549e-02,  // NOLINT
@@ -959,7 +953,7 @@
      5.1771e-04,  -5.7864e-03,  -5.2946e-02,  -1.0589e-01,   9.1162e-02,  -9.9988e-04,  // NOLINT
     -1.6076e-02,   1.2549e-02,  -3.3329e-04,  -6.6659e-04,  -9.9988e-04,   3.9539e-02   // NOLINT
   };
-
+  // clang-format on
 
   {
     Covariance::Options options;
@@ -1109,40 +1103,33 @@
     double* z = y + 3;
 
     {
-      double jacobian[] = { 1.0, 0.0, 0.0, 1.0};
+      double jacobian[] = {1.0, 0.0, 0.0, 1.0};
       problem_.AddResidualBlock(new UnaryCostFunction(2, 2, jacobian), NULL, x);
     }
 
     {
-      double jacobian[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+      double jacobian[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
       problem_.AddResidualBlock(new UnaryCostFunction(3, 3, jacobian), NULL, y);
     }
 
     {
       double jacobian = 5.0;
-      problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian),
-                                NULL,
-                                z);
+      problem_.AddResidualBlock(
+          new UnaryCostFunction(1, 1, &jacobian), NULL, z);
     }
 
     {
-      double jacobian1[] = { 0.0, 0.0, 0.0 };
-      double jacobian2[] = { -5.0, -6.0 };
+      double jacobian1[] = {0.0, 0.0, 0.0};
+      double jacobian2[] = {-5.0, -6.0};
       problem_.AddResidualBlock(
-          new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2),
-          NULL,
-          y,
-          x);
+          new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2), NULL, y, x);
     }
 
     {
-      double jacobian1[] = {2.0 };
-      double jacobian2[] = { 3.0, -2.0 };
+      double jacobian1[] = {2.0};
+      double jacobian2[] = {3.0, -2.0};
       problem_.AddResidualBlock(
-          new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2),
-          NULL,
-          z,
-          x);
+          new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2), NULL, z, x);
     }
 
     all_covariance_blocks_.push_back(make_pair(x, x));
@@ -1180,6 +1167,7 @@
   //   6 -4  0  0  0 29
 
   // pinv(J'J) computed using octave.
+  // clang-format off
   double expected_covariance[] = {
      0.053998,  -0.033145,   0.000000,   0.000000,   0.000000,  -0.015744,
     -0.033145,   0.045067,   0.000000,   0.000000,   0.000000,   0.013074,
@@ -1188,6 +1176,7 @@
      0.000000,   0.000000,   0.000000,   0.000000,   0.000000,   0.000000,
     -0.015744,   0.013074,   0.000000,   0.000000,   0.000000,   0.039543
   };
+  // clang-format on
 
   Covariance::Options options;
   options.algorithm_type = DENSE_SVD;
@@ -1290,11 +1279,11 @@
       jacobian *= (i + 1);
 
       double* block_i = parameters_.get() + i * parameter_block_size_;
-      problem_.AddResidualBlock(new UnaryCostFunction(parameter_block_size_,
-                                                      parameter_block_size_,
-                                                      jacobian.data()),
-                                NULL,
-                                block_i);
+      problem_.AddResidualBlock(
+          new UnaryCostFunction(
+              parameter_block_size_, parameter_block_size_, jacobian.data()),
+          NULL,
+          block_i);
       for (int j = i; j < num_parameter_blocks_; ++j) {
         double* block_j = parameters_.get() + j * parameter_block_size_;
         all_covariance_blocks_.push_back(make_pair(block_i, block_j));
@@ -1326,8 +1315,10 @@
       covariance.GetCovarianceBlock(block_i, block_i, actual.data());
       EXPECT_NEAR((expected - actual).norm(), 0.0, kTolerance)
           << "block: " << i << ", " << i << "\n"
-          << "expected: \n" << expected << "\n"
-          << "actual: \n" << actual;
+          << "expected: \n"
+          << expected << "\n"
+          << "actual: \n"
+          << actual;
 
       expected.setZero();
       for (int j = i + 1; j < num_parameter_blocks_; ++j) {
@@ -1335,8 +1326,10 @@
         covariance.GetCovarianceBlock(block_i, block_j, actual.data());
         EXPECT_NEAR((expected - actual).norm(), 0.0, kTolerance)
             << "block: " << i << ", " << j << "\n"
-            << "expected: \n" << expected << "\n"
-            << "actual: \n" << actual;
+            << "expected: \n"
+            << expected << "\n"
+            << "actual: \n"
+            << actual;
       }
     }
   }
diff --git a/internal/ceres/cubic_interpolation_test.cc b/internal/ceres/cubic_interpolation_test.cc
index 4cf27ff..3907d22 100644
--- a/internal/ceres/cubic_interpolation_test.cc
+++ b/internal/ceres/cubic_interpolation_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/cubic_interpolation.h"
 
 #include <memory>
+
 #include "ceres/jet.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
@@ -65,9 +66,11 @@
 }
 
 TEST(Grid1D, TwoDataDimensionIntegerDataInterleaved) {
+  // clang-format off
   int x[] = {1, 5,
              2, 6,
              3, 7};
+  // clang-format on
 
   Grid1D<int, 2, true> grid(x, 0, 3);
   for (int i = 0; i < 3; ++i) {
@@ -78,10 +81,11 @@
   }
 }
 
-
 TEST(Grid1D, TwoDataDimensionIntegerDataStacked) {
+  // clang-format off
   int x[] = {1, 2, 3,
              5, 6, 7};
+  // clang-format on
 
   Grid1D<int, 2, false> grid(x, 0, 3);
   for (int i = 0; i < 3; ++i) {
@@ -93,8 +97,10 @@
 }
 
 TEST(Grid2D, OneDataDimensionRowMajor) {
+  // clang-format off
   int x[] = {1, 2, 3,
              2, 3, 4};
+  // clang-format on
   Grid2D<int, 1, true, true> grid(x, 0, 2, 0, 3);
   for (int r = 0; r < 2; ++r) {
     for (int c = 0; c < 3; ++c) {
@@ -106,8 +112,10 @@
 }
 
 TEST(Grid2D, OneDataDimensionRowMajorOutOfBounds) {
+  // clang-format off
   int x[] = {1, 2, 3,
              2, 3, 4};
+  // clang-format on
   Grid2D<int, 1, true, true> grid(x, 0, 2, 0, 3);
   double value;
   grid.GetValue(-1, -1, &value);
@@ -141,64 +149,72 @@
 }
 
 TEST(Grid2D, TwoDataDimensionRowMajorInterleaved) {
+  // clang-format off
   int x[] = {1, 4, 2, 8, 3, 12,
              2, 8, 3, 12, 4, 16};
+  // clang-format on
   Grid2D<int, 2, true, true> grid(x, 0, 2, 0, 3);
   for (int r = 0; r < 2; ++r) {
     for (int c = 0; c < 3; ++c) {
       double value[2];
       grid.GetValue(r, c, value);
       EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
-      EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+      EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
     }
   }
 }
 
 TEST(Grid2D, TwoDataDimensionRowMajorStacked) {
+  // clang-format off
   int x[] = {1,  2,  3,
              2,  3,  4,
              4,  8, 12,
              8, 12, 16};
+  // clang-format on
   Grid2D<int, 2, true, false> grid(x, 0, 2, 0, 3);
   for (int r = 0; r < 2; ++r) {
     for (int c = 0; c < 3; ++c) {
       double value[2];
       grid.GetValue(r, c, value);
       EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
-      EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+      EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
     }
   }
 }
 
 TEST(Grid2D, TwoDataDimensionColMajorInterleaved) {
+  // clang-format off
   int x[] = { 1,  4, 2,  8,
               2,  8, 3, 12,
               3, 12, 4, 16};
+  // clang-format on
   Grid2D<int, 2, false, true> grid(x, 0, 2, 0, 3);
   for (int r = 0; r < 2; ++r) {
     for (int c = 0; c < 3; ++c) {
       double value[2];
       grid.GetValue(r, c, value);
       EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
-      EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+      EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
     }
   }
 }
 
 TEST(Grid2D, TwoDataDimensionColMajorStacked) {
+  // clang-format off
   int x[] = {1,   2,
              2,   3,
              3,   4,
              4,   8,
              8,  12,
              12, 16};
+  // clang-format on
   Grid2D<int, 2, false, false> grid(x, 0, 2, 0, 3);
   for (int r = 0; r < 2; ++r) {
     for (int c = 0; c < 3; ++c) {
       double value[2];
       grid.GetValue(r, c, value);
       EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
-      EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+      EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
     }
   }
 }
@@ -214,8 +230,8 @@
 
     for (int x = 0; x < kNumSamples; ++x) {
       for (int dim = 0; dim < kDataDimension; ++dim) {
-      values_[x * kDataDimension + dim] =
-          (dim * dim  + 1) * (a  * x * x * x + b * x * x + c * x + d);
+        values_[x * kDataDimension + dim] =
+            (dim * dim + 1) * (a * x * x * x + b * x * x + c * x + d);
       }
     }
 
@@ -236,8 +252,9 @@
 
       for (int dim = 0; dim < kDataDimension; ++dim) {
         expected_f[dim] =
-            (dim * dim  + 1) * (a  * x * x * x + b * x * x + c * x + d);
-        expected_dfdx[dim] = (dim * dim + 1) * (3.0 * a * x * x + 2.0 * b * x + c);
+            (dim * dim + 1) * (a * x * x * x + b * x * x + c * x + d);
+        expected_dfdx[dim] =
+            (dim * dim + 1) * (3.0 * a * x * x + 2.0 * b * x + c);
       }
 
       interpolator.Evaluate(x, f, dfdx);
@@ -278,7 +295,6 @@
   RunPolynomialInterpolationTest<3>(0.0, 0.4, 1.0, 0.5);
 }
 
-
 TEST(CubicInterpolator, JetEvaluation) {
   const double values[] = {1.0, 2.0, 2.0, 5.0, 3.0, 9.0, 2.0, 7.0};
 
@@ -330,7 +346,8 @@
       }
     }
 
-    Grid2D<double, kDataDimension> grid(values_.get(), 0, kNumRows, 0, kNumCols);
+    Grid2D<double, kDataDimension> grid(
+        values_.get(), 0, kNumRows, 0, kNumCols);
     BiCubicInterpolator<Grid2D<double, kDataDimension>> interpolator(grid);
 
     for (int j = 0; j < kNumRowSamples; ++j) {
@@ -341,8 +358,10 @@
         interpolator.Evaluate(r, c, f, dfdr, dfdc);
         for (int dim = 0; dim < kDataDimension; ++dim) {
           EXPECT_NEAR(f[dim], (dim * dim + 1) * EvaluateF(r, c), kTolerance);
-          EXPECT_NEAR(dfdr[dim], (dim * dim + 1) * EvaluatedFdr(r, c), kTolerance);
-          EXPECT_NEAR(dfdc[dim], (dim * dim + 1) * EvaluatedFdc(r, c), kTolerance);
+          EXPECT_NEAR(
+              dfdr[dim], (dim * dim + 1) * EvaluatedFdr(r, c), kTolerance);
+          EXPECT_NEAR(
+              dfdc[dim], (dim * dim + 1) * EvaluatedFdc(r, c), kTolerance);
         }
       }
     }
@@ -373,7 +392,6 @@
     return (coeff_.row(1) + coeff_.col(1).transpose()) * x;
   }
 
-
   Eigen::Matrix3d coeff_;
   static constexpr int kNumRows = 10;
   static constexpr int kNumCols = 10;
@@ -471,8 +489,10 @@
 }
 
 TEST(BiCubicInterpolator, JetEvaluation) {
+  // clang-format off
   const double values[] = {1.0, 5.0, 2.0, 10.0, 2.0, 6.0, 3.0, 5.0,
                            1.0, 2.0, 2.0,  2.0, 2.0, 2.0, 3.0, 1.0};
+  // clang-format on
 
   Grid2D<double, 2> grid(values, 0, 2, 0, 4);
   BiCubicInterpolator<Grid2D<double, 2>> interpolator(grid);
diff --git a/internal/ceres/cxsparse.cc b/internal/ceres/cxsparse.cc
index 5a02877..0167f98 100644
--- a/internal/ceres/cxsparse.cc
+++ b/internal/ceres/cxsparse.cc
@@ -33,13 +33,12 @@
 
 #ifndef CERES_NO_CXSPARSE
 
-#include "ceres/cxsparse.h"
-
 #include <string>
 #include <vector>
 
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 #include "ceres/compressed_row_sparse_matrix.h"
+#include "ceres/cxsparse.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "glog/logging.h"
 
diff --git a/internal/ceres/cxsparse.h b/internal/ceres/cxsparse.h
index dc4740c..d3f76e0 100644
--- a/internal/ceres/cxsparse.h
+++ b/internal/ceres/cxsparse.h
@@ -166,7 +166,7 @@
 }  // namespace internal
 }  // namespace ceres
 
-#else   // CERES_NO_CXSPARSE
+#else
 
 typedef void cs_dis;
 
diff --git a/internal/ceres/dense_jacobian_writer.h b/internal/ceres/dense_jacobian_writer.h
index 1b04f38..28c60e2 100644
--- a/internal/ceres/dense_jacobian_writer.h
+++ b/internal/ceres/dense_jacobian_writer.h
@@ -35,21 +35,19 @@
 
 #include "ceres/casts.h"
 #include "ceres/dense_sparse_matrix.h"
+#include "ceres/internal/eigen.h"
 #include "ceres/parameter_block.h"
 #include "ceres/program.h"
 #include "ceres/residual_block.h"
 #include "ceres/scratch_evaluate_preparer.h"
-#include "ceres/internal/eigen.h"
 
 namespace ceres {
 namespace internal {
 
 class DenseJacobianWriter {
  public:
-  DenseJacobianWriter(Evaluator::Options /* ignored */,
-                      Program* program)
-    : program_(program) {
-  }
+  DenseJacobianWriter(Evaluator::Options /* ignored */, Program* program)
+      : program_(program) {}
 
   // JacobianWriter interface.
 
@@ -61,14 +59,13 @@
   }
 
   SparseMatrix* CreateJacobian() const {
-    return new DenseSparseMatrix(program_->NumResiduals(),
-                                 program_->NumEffectiveParameters(),
-                                 true);
+    return new DenseSparseMatrix(
+        program_->NumResiduals(), program_->NumEffectiveParameters(), true);
   }
 
   void Write(int residual_id,
              int residual_offset,
-             double **jacobians,
+             double** jacobians,
              SparseMatrix* jacobian) {
     DenseSparseMatrix* dense_jacobian = down_cast<DenseSparseMatrix*>(jacobian);
     const ResidualBlock* residual_block =
@@ -86,15 +83,14 @@
       }
 
       const int parameter_block_size = parameter_block->LocalSize();
-      ConstMatrixRef parameter_jacobian(jacobians[j],
-                                        num_residuals,
-                                        parameter_block_size);
+      ConstMatrixRef parameter_jacobian(
+          jacobians[j], num_residuals, parameter_block_size);
 
-      dense_jacobian->mutable_matrix().block(
-          residual_offset,
-          parameter_block->delta_offset(),
-          num_residuals,
-          parameter_block_size) = parameter_jacobian;
+      dense_jacobian->mutable_matrix().block(residual_offset,
+                                             parameter_block->delta_offset(),
+                                             num_residuals,
+                                             parameter_block_size) =
+          parameter_jacobian;
     }
   }
 
diff --git a/internal/ceres/dense_linear_solver_test.cc b/internal/ceres/dense_linear_solver_test.cc
index 4de745f..3929a6f 100644
--- a/internal/ceres/dense_linear_solver_test.cc
+++ b/internal/ceres/dense_linear_solver_test.cc
@@ -29,6 +29,7 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include <memory>
+
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
 #include "ceres/linear_least_squares_problems.h"
diff --git a/internal/ceres/dense_normal_cholesky_solver.cc b/internal/ceres/dense_normal_cholesky_solver.cc
index fe7d931..51c6390 100644
--- a/internal/ceres/dense_normal_cholesky_solver.cc
+++ b/internal/ceres/dense_normal_cholesky_solver.cc
@@ -132,13 +132,8 @@
   //
   // Note: This is a bit delicate, it assumes that the stride on this
   // matrix is the same as the number of rows.
-  BLAS::SymmetricRankKUpdate(A->num_rows(),
-                             num_cols,
-                             A->values(),
-                             true,
-                             1.0,
-                             0.0,
-                             lhs.data());
+  BLAS::SymmetricRankKUpdate(
+      A->num_rows(), num_cols, A->values(), true, 1.0, 0.0, lhs.data());
 
   if (per_solve_options.D != NULL) {
     // Undo the modifications to the matrix A.
@@ -153,13 +148,10 @@
 
   LinearSolver::Summary summary;
   summary.num_iterations = 1;
-  summary.termination_type =
-      LAPACK::SolveInPlaceUsingCholesky(num_cols,
-                                        lhs.data(),
-                                        x,
-                                        &summary.message);
+  summary.termination_type = LAPACK::SolveInPlaceUsingCholesky(
+      num_cols, lhs.data(), x, &summary.message);
   event_logger.AddEvent("Solve");
   return summary;
 }
-}   // namespace internal
-}   // namespace ceres
+}  // namespace internal
+}  // namespace ceres
diff --git a/internal/ceres/dense_normal_cholesky_solver.h b/internal/ceres/dense_normal_cholesky_solver.h
index 976718e..68ea611 100644
--- a/internal/ceres/dense_normal_cholesky_solver.h
+++ b/internal/ceres/dense_normal_cholesky_solver.h
@@ -73,7 +73,7 @@
 // library. This solver always returns a solution, it is the user's
 // responsibility to judge if the solution is good enough for their
 // purposes.
-class DenseNormalCholeskySolver: public DenseSparseMatrixSolver {
+class DenseNormalCholeskySolver : public DenseSparseMatrixSolver {
  public:
   explicit DenseNormalCholeskySolver(const LinearSolver::Options& options);
 
diff --git a/internal/ceres/dense_qr_solver.cc b/internal/ceres/dense_qr_solver.cc
index 161e9c6..44388f3 100644
--- a/internal/ceres/dense_qr_solver.cc
+++ b/internal/ceres/dense_qr_solver.cc
@@ -31,6 +31,7 @@
 #include "ceres/dense_qr_solver.h"
 
 #include <cstddef>
+
 #include "Eigen/Dense"
 #include "ceres/dense_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
@@ -77,7 +78,7 @@
 
   // TODO(sameeragarwal): Since we are copying anyways, the diagonal
   // can be appended to the matrix instead of doing it on A.
-  lhs_ =  A->matrix();
+  lhs_ = A->matrix();
 
   if (per_solve_options.D != NULL) {
     // Undo the modifications to the matrix A.
@@ -164,5 +165,5 @@
   return summary;
 }
 
-}   // namespace internal
-}   // namespace ceres
+}  // namespace internal
+}  // namespace ceres
diff --git a/internal/ceres/dense_qr_solver.h b/internal/ceres/dense_qr_solver.h
index 9ea959d..a30cd1c 100644
--- a/internal/ceres/dense_qr_solver.h
+++ b/internal/ceres/dense_qr_solver.h
@@ -32,8 +32,8 @@
 #ifndef CERES_INTERNAL_DENSE_QR_SOLVER_H_
 #define CERES_INTERNAL_DENSE_QR_SOLVER_H_
 
-#include "ceres/linear_solver.h"
 #include "ceres/internal/eigen.h"
+#include "ceres/linear_solver.h"
 
 namespace ceres {
 namespace internal {
@@ -78,7 +78,7 @@
 // library. This solver always returns a solution, it is the user's
 // responsibility to judge if the solution is good enough for their
 // purposes.
-class DenseQRSolver: public DenseSparseMatrixSolver {
+class DenseQRSolver : public DenseSparseMatrixSolver {
  public:
   explicit DenseQRSolver(const LinearSolver::Options& options);
 
diff --git a/internal/ceres/dense_sparse_matrix.cc b/internal/ceres/dense_sparse_matrix.cc
index 72e0836..53207fe 100644
--- a/internal/ceres/dense_sparse_matrix.cc
+++ b/internal/ceres/dense_sparse_matrix.cc
@@ -31,17 +31,17 @@
 #include "ceres/dense_sparse_matrix.h"
 
 #include <algorithm>
-#include "ceres/triplet_sparse_matrix.h"
+
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
+#include "ceres/triplet_sparse_matrix.h"
 #include "glog/logging.h"
 
 namespace ceres {
 namespace internal {
 
 DenseSparseMatrix::DenseSparseMatrix(int num_rows, int num_cols)
-    : has_diagonal_appended_(false),
-      has_diagonal_reserved_(false) {
+    : has_diagonal_appended_(false), has_diagonal_reserved_(false) {
   m_.resize(num_rows, num_cols);
   m_.setZero();
 }
@@ -49,11 +49,10 @@
 DenseSparseMatrix::DenseSparseMatrix(int num_rows,
                                      int num_cols,
                                      bool reserve_diagonal)
-    : has_diagonal_appended_(false),
-      has_diagonal_reserved_(reserve_diagonal) {
+    : has_diagonal_appended_(false), has_diagonal_reserved_(reserve_diagonal) {
   if (reserve_diagonal) {
     // Allocate enough space for the diagonal.
-    m_.resize(num_rows +  num_cols, num_cols);
+    m_.resize(num_rows + num_cols, num_cols);
   } else {
     m_.resize(num_rows, num_cols);
   }
@@ -64,9 +63,9 @@
     : m_(Eigen::MatrixXd::Zero(m.num_rows(), m.num_cols())),
       has_diagonal_appended_(false),
       has_diagonal_reserved_(false) {
-  const double *values = m.values();
-  const int *rows = m.rows();
-  const int *cols = m.cols();
+  const double* values = m.values();
+  const int* rows = m.rows();
+  const int* cols = m.cols();
   int num_nonzeros = m.num_nonzeros();
 
   for (int i = 0; i < num_nonzeros; ++i) {
@@ -75,14 +74,9 @@
 }
 
 DenseSparseMatrix::DenseSparseMatrix(const ColMajorMatrix& m)
-    : m_(m),
-      has_diagonal_appended_(false),
-      has_diagonal_reserved_(false) {
-}
+    : m_(m), has_diagonal_appended_(false), has_diagonal_reserved_(false) {}
 
-void DenseSparseMatrix::SetZero() {
-  m_.setZero();
-}
+void DenseSparseMatrix::SetZero() { m_.setZero(); }
 
 void DenseSparseMatrix::RightMultiply(const double* x, double* y) const {
   VectorRef(y, num_rows()) += matrix() * ConstVectorRef(x, num_cols());
@@ -105,7 +99,7 @@
   *dense_matrix = m_.block(0, 0, num_rows(), num_cols());
 }
 
-void DenseSparseMatrix::AppendDiagonal(double *d) {
+void DenseSparseMatrix::AppendDiagonal(double* d) {
   CHECK(!has_diagonal_appended_);
   if (!has_diagonal_reserved_) {
     ColMajorMatrix tmp = m_;
@@ -133,9 +127,7 @@
   return m_.rows();
 }
 
-int DenseSparseMatrix::num_cols() const {
-  return m_.cols();
-}
+int DenseSparseMatrix::num_cols() const { return m_.cols(); }
 
 int DenseSparseMatrix::num_nonzeros() const {
   if (has_diagonal_reserved_ && !has_diagonal_appended_) {
@@ -148,33 +140,30 @@
   return ConstColMajorMatrixRef(
       m_.data(),
       ((has_diagonal_reserved_ && !has_diagonal_appended_)
-       ? m_.rows() - m_.cols()
-       : m_.rows()),
+           ? m_.rows() - m_.cols()
+           : m_.rows()),
       m_.cols(),
       Eigen::Stride<Eigen::Dynamic, 1>(m_.rows(), 1));
 }
 
 ColMajorMatrixRef DenseSparseMatrix::mutable_matrix() {
-  return ColMajorMatrixRef(
-      m_.data(),
-      ((has_diagonal_reserved_ && !has_diagonal_appended_)
-       ? m_.rows() - m_.cols()
-       : m_.rows()),
-      m_.cols(),
-      Eigen::Stride<Eigen::Dynamic, 1>(m_.rows(), 1));
+  return ColMajorMatrixRef(m_.data(),
+                           ((has_diagonal_reserved_ && !has_diagonal_appended_)
+                                ? m_.rows() - m_.cols()
+                                : m_.rows()),
+                           m_.cols(),
+                           Eigen::Stride<Eigen::Dynamic, 1>(m_.rows(), 1));
 }
 
-
 void DenseSparseMatrix::ToTextFile(FILE* file) const {
   CHECK(file != nullptr);
-  const int active_rows =
-      (has_diagonal_reserved_ && !has_diagonal_appended_)
-      ? (m_.rows() - m_.cols())
-      : m_.rows();
+  const int active_rows = (has_diagonal_reserved_ && !has_diagonal_appended_)
+                              ? (m_.rows() - m_.cols())
+                              : m_.rows();
 
   for (int r = 0; r < active_rows; ++r) {
     for (int c = 0; c < m_.cols(); ++c) {
-      fprintf(file,  "% 10d % 10d %17f\n", r, c, m_(r, c));
+      fprintf(file, "% 10d % 10d %17f\n", r, c, m_(r, c));
     }
   }
 }
diff --git a/internal/ceres/dense_sparse_matrix.h b/internal/ceres/dense_sparse_matrix.h
index 6d3d504..34a3be2 100644
--- a/internal/ceres/dense_sparse_matrix.h
+++ b/internal/ceres/dense_sparse_matrix.h
@@ -92,7 +92,7 @@
   // Calling RemoveDiagonal removes the block. It is a fatal error to append a
   // diagonal to a matrix that already has an appended diagonal, and it is also
   // a fatal error to remove a diagonal from a matrix that has none.
-  void AppendDiagonal(double *d);
+  void AppendDiagonal(double* d);
   void RemoveDiagonal();
 
  private:
diff --git a/internal/ceres/dense_sparse_matrix_test.cc b/internal/ceres/dense_sparse_matrix_test.cc
index a0c1cd6..2fa7216 100644
--- a/internal/ceres/dense_sparse_matrix_test.cc
+++ b/internal/ceres/dense_sparse_matrix_test.cc
@@ -35,10 +35,11 @@
 #include "ceres/dense_sparse_matrix.h"
 
 #include <memory>
+
 #include "ceres/casts.h"
+#include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
@@ -67,7 +68,7 @@
 }
 
 class DenseSparseMatrixTest : public ::testing::Test {
- protected :
+ protected:
   void SetUp() final {
     std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(1));
diff --git a/internal/ceres/detect_structure.cc b/internal/ceres/detect_structure.cc
index 959a0ee..4aac445 100644
--- a/internal/ceres/detect_structure.cc
+++ b/internal/ceres/detect_structure.cc
@@ -29,6 +29,7 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/detect_structure.h"
+
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 
@@ -61,8 +62,7 @@
     } else if (*row_block_size != Eigen::Dynamic &&
                *row_block_size != row.block.size) {
       VLOG(2) << "Dynamic row block size because the block size changed from "
-              << *row_block_size << " to "
-              << row.block.size;
+              << *row_block_size << " to " << row.block.size;
       *row_block_size = Eigen::Dynamic;
     }
 
@@ -73,8 +73,7 @@
     } else if (*e_block_size != Eigen::Dynamic &&
                *e_block_size != bs.cols[e_block_id].size) {
       VLOG(2) << "Dynamic e block size because the block size changed from "
-              << *e_block_size << " to "
-              << bs.cols[e_block_id].size;
+              << *e_block_size << " to " << bs.cols[e_block_id].size;
       *e_block_size = Eigen::Dynamic;
     }
 
@@ -100,9 +99,11 @@
       }
     }
 
+    // clang-format off
     const bool is_everything_dynamic = (*row_block_size == Eigen::Dynamic &&
                                         *e_block_size == Eigen::Dynamic &&
                                         *f_block_size == Eigen::Dynamic);
+    // clang-format on
     if (is_everything_dynamic) {
       break;
     }
@@ -110,10 +111,12 @@
 
   CHECK_NE(*row_block_size, 0) << "No rows found";
   CHECK_NE(*e_block_size, 0) << "No e type blocks found";
+  // clang-format off
   VLOG(1) << "Schur complement static structure <"
           << *row_block_size << ","
           << *e_block_size << ","
           << *f_block_size << ">.";
+  // clang-format on
 }
 
 }  // namespace internal
diff --git a/internal/ceres/detect_structure_test.cc b/internal/ceres/detect_structure_test.cc
index a701a19..8f9c5ed 100644
--- a/internal/ceres/detect_structure_test.cc
+++ b/internal/ceres/detect_structure_test.cc
@@ -28,11 +28,12 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/detect_structure.h"
+
 #include "Eigen/Core"
+#include "ceres/block_structure.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
-#include "ceres/block_structure.h"
-#include "ceres/detect_structure.h"
 
 namespace ceres {
 namespace internal {
@@ -78,11 +79,8 @@
   int e_block_size = 0;
   int f_block_size = 0;
   const int num_eliminate_blocks = 1;
-  DetectStructure(bs,
-                  num_eliminate_blocks,
-                  &row_block_size,
-                  &e_block_size,
-                  &f_block_size);
+  DetectStructure(
+      bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
 
   EXPECT_EQ(row_block_size, expected_row_block_size);
   EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -130,11 +128,8 @@
   int e_block_size = 0;
   int f_block_size = 0;
   const int num_eliminate_blocks = 1;
-  DetectStructure(bs,
-                  num_eliminate_blocks,
-                  &row_block_size,
-                  &e_block_size,
-                  &f_block_size);
+  DetectStructure(
+      bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
 
   EXPECT_EQ(row_block_size, expected_row_block_size);
   EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -146,7 +141,6 @@
   const int expected_e_block_size = 3;
   const int expected_f_block_size = Eigen::Dynamic;
 
-
   CompressedRowBlockStructure bs;
 
   bs.cols.push_back(Block());
@@ -183,11 +177,8 @@
   int e_block_size = 0;
   int f_block_size = 0;
   const int num_eliminate_blocks = 1;
-  DetectStructure(bs,
-                  num_eliminate_blocks,
-                  &row_block_size,
-                  &e_block_size,
-                  &f_block_size);
+  DetectStructure(
+      bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
 
   EXPECT_EQ(row_block_size, expected_row_block_size);
   EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -235,11 +226,8 @@
   int e_block_size = 0;
   int f_block_size = 0;
   const int num_eliminate_blocks = 2;
-  DetectStructure(bs,
-                  num_eliminate_blocks,
-                  &row_block_size,
-                  &e_block_size,
-                  &f_block_size);
+  DetectStructure(
+      bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
 
   EXPECT_EQ(row_block_size, expected_row_block_size);
   EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -279,11 +267,8 @@
   int e_block_size = 0;
   int f_block_size = 0;
   const int num_eliminate_blocks = 1;
-  DetectStructure(bs,
-                  num_eliminate_blocks,
-                  &row_block_size,
-                  &e_block_size,
-                  &f_block_size);
+  DetectStructure(
+      bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
 
   EXPECT_EQ(row_block_size, expected_row_block_size);
   EXPECT_EQ(e_block_size, expected_e_block_size);
diff --git a/internal/ceres/dogleg_strategy.cc b/internal/ceres/dogleg_strategy.cc
index ecc6b88..03ae22f 100644
--- a/internal/ceres/dogleg_strategy.cc
+++ b/internal/ceres/dogleg_strategy.cc
@@ -49,7 +49,7 @@
 namespace {
 const double kMaxMu = 1.0;
 const double kMinMu = 1e-8;
-}
+}  // namespace
 
 DoglegStrategy::DoglegStrategy(const TrustRegionStrategy::Options& options)
     : linear_solver_(options.linear_solver),
@@ -122,8 +122,8 @@
   //
   jacobian->SquaredColumnNorm(diagonal_.data());
   for (int i = 0; i < n; ++i) {
-    diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_),
-                            max_diagonal_);
+    diagonal_[i] =
+        std::min(std::max(diagonal_[i], min_diagonal_), max_diagonal_);
   }
   diagonal_ = diagonal_.array().sqrt();
 
@@ -171,9 +171,8 @@
 // The gradient, the Gauss-Newton step, the Cauchy point,
 // and all calculations involving the Jacobian have to
 // be adjusted accordingly.
-void DoglegStrategy::ComputeGradient(
-    SparseMatrix* jacobian,
-    const double* residuals) {
+void DoglegStrategy::ComputeGradient(SparseMatrix* jacobian,
+                                     const double* residuals) {
   gradient_.setZero();
   jacobian->LeftMultiply(residuals, gradient_.data());
   gradient_.array() /= diagonal_.array();
@@ -187,8 +186,7 @@
   Jg.setZero();
   // The Jacobian is scaled implicitly by computing J * (D^-1 * (D^-1 * g))
   // instead of (J * D^-1) * (D^-1 * g).
-  Vector scaled_gradient =
-      (gradient_.array() / diagonal_.array()).matrix();
+  Vector scaled_gradient = (gradient_.array() / diagonal_.array()).matrix();
   jacobian->RightMultiply(scaled_gradient.data(), Jg.data());
   alpha_ = gradient_.squaredNorm() / Jg.squaredNorm();
 }
@@ -217,7 +215,7 @@
   // Case 2. The Cauchy point and the Gauss-Newton steps lie outside
   // the trust region. Rescale the Cauchy point to the trust region
   // and return.
-  if  (gradient_norm * alpha_ >= radius_) {
+  if (gradient_norm * alpha_ >= radius_) {
     dogleg_step = -(radius_ / gradient_norm) * gradient_;
     dogleg_step_norm_ = radius_;
     dogleg_step.array() /= diagonal_.array();
@@ -242,14 +240,12 @@
   //   = alpha * -gradient' gauss_newton_step - alpha^2 |gradient|^2
   const double c = b_dot_a - a_squared_norm;
   const double d = sqrt(c * c + b_minus_a_squared_norm *
-                        (pow(radius_, 2.0) - a_squared_norm));
+                                    (pow(radius_, 2.0) - a_squared_norm));
 
-  double beta =
-      (c <= 0)
-      ? (d - c) /  b_minus_a_squared_norm
-      : (radius_ * radius_ - a_squared_norm) / (d + c);
-  dogleg_step = (-alpha_ * (1.0 - beta)) * gradient_
-      + beta * gauss_newton_step_;
+  double beta = (c <= 0) ? (d - c) / b_minus_a_squared_norm
+                         : (radius_ * radius_ - a_squared_norm) / (d + c);
+  dogleg_step =
+      (-alpha_ * (1.0 - beta)) * gradient_ + beta * gauss_newton_step_;
   dogleg_step_norm_ = dogleg_step.norm();
   dogleg_step.array() /= diagonal_.array();
   VLOG(3) << "Dogleg step size: " << dogleg_step_norm_
@@ -345,13 +341,13 @@
   // correctly determined.
   const double kCosineThreshold = 0.99;
   const Vector2d grad_minimum = subspace_B_ * minimum + subspace_g_;
-  const double cosine_angle = -minimum.dot(grad_minimum) /
-      (minimum.norm() * grad_minimum.norm());
+  const double cosine_angle =
+      -minimum.dot(grad_minimum) / (minimum.norm() * grad_minimum.norm());
   if (cosine_angle < kCosineThreshold) {
     LOG(WARNING) << "First order optimality seems to be violated "
                  << "in the subspace method!\n"
-                 << "Cosine of angle between x and B x + g is "
-                 << cosine_angle << ".\n"
+                 << "Cosine of angle between x and B x + g is " << cosine_angle
+                 << ".\n"
                  << "Taking a regular dogleg step instead.\n"
                  << "Please consider filing a bug report if this "
                  << "happens frequently or consistently.\n";
@@ -423,15 +419,17 @@
   const double trB = subspace_B_.trace();
   const double r2 = radius_ * radius_;
   Matrix2d B_adj;
+  // clang-format off
   B_adj <<  subspace_B_(1, 1) , -subspace_B_(0, 1),
-            -subspace_B_(1, 0) ,  subspace_B_(0, 0);
+           -subspace_B_(1, 0) ,  subspace_B_(0, 0);
+  // clang-format on
 
   Vector polynomial(5);
   polynomial(0) = r2;
   polynomial(1) = 2.0 * r2 * trB;
   polynomial(2) = r2 * (trB * trB + 2.0 * detB) - subspace_g_.squaredNorm();
-  polynomial(3) = -2.0 * (subspace_g_.transpose() * B_adj * subspace_g_
-      - r2 * detB * trB);
+  polynomial(3) =
+      -2.0 * (subspace_g_.transpose() * B_adj * subspace_g_ - r2 * detB * trB);
   polynomial(4) = r2 * detB * detB - (B_adj * subspace_g_).squaredNorm();
 
   return polynomial;
@@ -565,10 +563,8 @@
     // of Jx = -r and later set x = -y to avoid having to modify
     // either jacobian or residuals.
     InvalidateArray(n, gauss_newton_step_.data());
-    linear_solver_summary = linear_solver_->Solve(jacobian,
-                                                  residuals,
-                                                  solve_options,
-                                                  gauss_newton_step_.data());
+    linear_solver_summary = linear_solver_->Solve(
+        jacobian, residuals, solve_options, gauss_newton_step_.data());
 
     if (per_solve_options.dump_format_type == CONSOLE ||
         (per_solve_options.dump_format_type != CONSOLE &&
@@ -641,9 +637,7 @@
   reuse_ = false;
 }
 
-double DoglegStrategy::Radius() const {
-  return radius_;
-}
+double DoglegStrategy::Radius() const { return radius_; }
 
 bool DoglegStrategy::ComputeSubspaceModel(SparseMatrix* jacobian) {
   // Compute an orthogonal basis for the subspace using QR decomposition.
@@ -701,8 +695,8 @@
 
   subspace_g_ = subspace_basis_.transpose() * gradient_;
 
-  Eigen::Matrix<double, 2, Eigen::Dynamic, Eigen::RowMajor>
-      Jb(2, jacobian->num_rows());
+  Eigen::Matrix<double, 2, Eigen::Dynamic, Eigen::RowMajor> Jb(
+      2, jacobian->num_rows());
   Jb.setZero();
 
   Vector tmp;
diff --git a/internal/ceres/dogleg_strategy.h b/internal/ceres/dogleg_strategy.h
index 1150940..9616ffe 100644
--- a/internal/ceres/dogleg_strategy.h
+++ b/internal/ceres/dogleg_strategy.h
@@ -59,9 +59,9 @@
 
   // TrustRegionStrategy interface
   Summary ComputeStep(const PerSolveOptions& per_solve_options,
-                              SparseMatrix* jacobian,
-                              const double* residuals,
-                              double* step) final;
+                      SparseMatrix* jacobian,
+                      const double* residuals,
+                      double* step) final;
   void StepAccepted(double step_quality) final;
   void StepRejected(double step_quality) final;
   void StepIsInvalid();
diff --git a/internal/ceres/dogleg_strategy_test.cc b/internal/ceres/dogleg_strategy_test.cc
index af5b3e8..0c20f25 100644
--- a/internal/ceres/dogleg_strategy_test.cc
+++ b/internal/ceres/dogleg_strategy_test.cc
@@ -28,11 +28,13 @@
 //
 // Author: moll.markus@arcor.de (Markus Moll)
 
+#include "ceres/dogleg_strategy.h"
+
 #include <limits>
 #include <memory>
-#include "ceres/internal/eigen.h"
+
 #include "ceres/dense_qr_solver.h"
-#include "ceres/dogleg_strategy.h"
+#include "ceres/internal/eigen.h"
 #include "ceres/linear_solver.h"
 #include "ceres/trust_region_strategy.h"
 #include "glog/logging.h"
@@ -63,12 +65,14 @@
   void SetUp() final {
     Matrix basis(6, 6);
     // The following lines exceed 80 characters for better readability.
+    // clang-format off
     basis << -0.1046920933796121, -0.7449367449921986, -0.4190744502875876, -0.4480450716142566,  0.2375351607929440, -0.0363053418882862,  // NOLINT
               0.4064975684355914,  0.2681113508511354, -0.7463625494601520, -0.0803264850508117, -0.4463149623021321,  0.0130224954867195,  // NOLINT
              -0.5514387729089798,  0.1026621026168657, -0.5008316122125011,  0.5738122212666414,  0.2974664724007106,  0.1296020877535158,  // NOLINT
               0.5037835370947156,  0.2668479925183712, -0.1051754618492798, -0.0272739396578799,  0.7947481647088278, -0.1776623363955670,  // NOLINT
              -0.4005458426625444,  0.2939330589634109, -0.0682629380550051, -0.2895448882503687, -0.0457239396341685, -0.8139899477847840,  // NOLINT
              -0.3247764582762654,  0.4528151365941945, -0.0276683863102816, -0.6155994592510784,  0.1489240599972848,  0.5362574892189350;  // NOLINT
+    // clang-format on
 
     Vector Ddiag(6);
     Ddiag << 1.0, 2.0, 4.0, 8.0, 16.0, 32.0;
@@ -139,10 +143,8 @@
   DoglegStrategy strategy(options_);
   TrustRegionStrategy::PerSolveOptions pso;
 
-  TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
-                                                              jacobian_.get(),
-                                                              residual_.data(),
-                                                              x_.data());
+  TrustRegionStrategy::Summary summary =
+      strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
 
   EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_LE(x_.norm(), options_.initial_radius * (1.0 + 4.0 * kEpsilon));
@@ -159,10 +161,8 @@
   DoglegStrategy strategy(options_);
   TrustRegionStrategy::PerSolveOptions pso;
 
-  TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
-                                                              jacobian_.get(),
-                                                              residual_.data(),
-                                                              x_.data());
+  TrustRegionStrategy::Summary summary =
+      strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
 
   EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_LE(x_.norm(), options_.initial_radius * (1.0 + 4.0 * kEpsilon));
@@ -179,10 +179,8 @@
   DoglegStrategy strategy(options_);
   TrustRegionStrategy::PerSolveOptions pso;
 
-  TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
-                                                              jacobian_.get(),
-                                                              residual_.data(),
-                                                              x_.data());
+  TrustRegionStrategy::Summary summary =
+      strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
 
   EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_NEAR(x_(0), 1.0, kToleranceLoose);
@@ -216,15 +214,13 @@
 
   // Check if the gradient projects onto itself.
   const Vector gradient = strategy.gradient();
-  EXPECT_NEAR((gradient - basis*(basis.transpose()*gradient)).norm(),
+  EXPECT_NEAR((gradient - basis * (basis.transpose() * gradient)).norm(),
               0.0,
               kTolerance);
 
   // Check if the Gauss-Newton point projects onto itself.
   const Vector gn = strategy.gauss_newton_step();
-  EXPECT_NEAR((gn - basis*(basis.transpose()*gn)).norm(),
-              0.0,
-              kTolerance);
+  EXPECT_NEAR((gn - basis * (basis.transpose() * gn)).norm(), 0.0, kTolerance);
 }
 
 // Test if the step is correct if the gradient and the Gauss-Newton step point
@@ -241,10 +237,8 @@
   DoglegStrategy strategy(options_);
   TrustRegionStrategy::PerSolveOptions pso;
 
-  TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
-                                                              jacobian_.get(),
-                                                              residual_.data(),
-                                                              x_.data());
+  TrustRegionStrategy::Summary summary =
+      strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
 
   EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_NEAR(x_(0), 0.0, kToleranceLoose);
@@ -269,10 +263,8 @@
   DoglegStrategy strategy(options_);
   TrustRegionStrategy::PerSolveOptions pso;
 
-  TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
-                                                              jacobian_.get(),
-                                                              residual_.data(),
-                                                              x_.data());
+  TrustRegionStrategy::Summary summary =
+      strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
 
   EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_NEAR(x_(0), 0.0, kToleranceLoose);
diff --git a/internal/ceres/dynamic_autodiff_cost_function_test.cc b/internal/ceres/dynamic_autodiff_cost_function_test.cc
index 6b57fd3..55d3fe1 100644
--- a/internal/ceres/dynamic_autodiff_cost_function_test.cc
+++ b/internal/ceres/dynamic_autodiff_cost_function_test.cc
@@ -30,10 +30,11 @@
 //         mierle@gmail.com (Keir Mierle)
 //         sameeragarwal@google.com (Sameer Agarwal)
 
-#include <cstddef>
-
-#include <memory>
 #include "ceres/dynamic_autodiff_cost_function.h"
+
+#include <cstddef>
+#include <memory>
+
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -87,9 +88,8 @@
   vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
-  EXPECT_TRUE(cost_function.Evaluate(&parameter_blocks[0],
-                                     residuals.data(),
-                                     NULL));
+  EXPECT_TRUE(
+      cost_function.Evaluate(&parameter_blocks[0], residuals.data(), NULL));
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(1.0 * r, residuals.at(r * 2));
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2 + 1));
@@ -127,9 +127,8 @@
   jacobian.push_back(jacobian_vect[1].data());
 
   // Test jacobian computation.
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
-                                     residuals.data(),
-                                     jacobian.data()));
+  EXPECT_TRUE(cost_function.Evaluate(
+      parameter_blocks.data(), residuals.data(), jacobian.data()));
 
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -138,11 +137,11 @@
   EXPECT_EQ(420, residuals.at(20));
   for (int p = 0; p < 10; ++p) {
     // Check "A" Jacobian.
-    EXPECT_EQ(-1.0, jacobian_vect[0][2*p * 10 + p]);
+    EXPECT_EQ(-1.0, jacobian_vect[0][2 * p * 10 + p]);
     // Check "B" Jacobian.
-    EXPECT_EQ(+1.0, jacobian_vect[0][(2*p+1) * 10 + p]);
-    jacobian_vect[0][2*p * 10 + p] = 0.0;
-    jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+    EXPECT_EQ(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p]);
+    jacobian_vect[0][2 * p * 10 + p] = 0.0;
+    jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
   }
 
   // Check "C" Jacobian for first parameter block.
@@ -194,9 +193,8 @@
   jacobian.push_back(jacobian_vect[1].data());
 
   // Test jacobian computation.
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
-                                     residuals.data(),
-                                     jacobian.data()));
+  EXPECT_TRUE(cost_function.Evaluate(
+      parameter_blocks.data(), residuals.data(), jacobian.data()));
 
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -214,7 +212,8 @@
   }
 }
 
-TEST(DynamicAutodiffCostFunctionTest, JacobianWithSecondParameterBlockConstant) {  // NOLINT
+TEST(DynamicAutodiffCostFunctionTest,
+     JacobianWithSecondParameterBlockConstant) {  // NOLINT
   // Test the residual counting.
   vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
@@ -244,9 +243,8 @@
   jacobian.push_back(NULL);
 
   // Test jacobian computation.
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
-                                     residuals.data(),
-                                     jacobian.data()));
+  EXPECT_TRUE(cost_function.Evaluate(
+      parameter_blocks.data(), residuals.data(), jacobian.data()));
 
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -255,11 +253,11 @@
   EXPECT_EQ(420, residuals.at(20));
   for (int p = 0; p < 10; ++p) {
     // Check "A" Jacobian.
-    EXPECT_EQ(-1.0, jacobian_vect[0][2*p * 10 + p]);
+    EXPECT_EQ(-1.0, jacobian_vect[0][2 * p * 10 + p]);
     // Check "B" Jacobian.
-    EXPECT_EQ(+1.0, jacobian_vect[0][(2*p+1) * 10 + p]);
-    jacobian_vect[0][2*p * 10 + p] = 0.0;
-    jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+    EXPECT_EQ(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p]);
+    jacobian_vect[0][2 * p * 10 + p] = 0.0;
+    jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
   }
 
   // Check "C" Jacobian for first parameter block.
@@ -330,10 +328,10 @@
 
     // Prepare the cost function.
     typedef DynamicAutoDiffCostFunction<MyThreeParameterCostFunctor, 3>
-      DynamicMyThreeParameterCostFunction;
-    DynamicMyThreeParameterCostFunction * cost_function =
-      new DynamicMyThreeParameterCostFunction(
-        new MyThreeParameterCostFunctor());
+        DynamicMyThreeParameterCostFunction;
+    DynamicMyThreeParameterCostFunction* cost_function =
+        new DynamicMyThreeParameterCostFunction(
+            new MyThreeParameterCostFunctor());
     cost_function->AddParameterBlock(1);
     cost_function->AddParameterBlock(2);
     cost_function->AddParameterBlock(3);
@@ -431,9 +429,8 @@
 
 TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
   vector<double> residuals(7, -100000);
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       NULL));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), NULL));
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
   }
@@ -447,9 +444,8 @@
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(jacobian_vect_[2].data());
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -477,9 +473,8 @@
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(NULL);
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -499,9 +494,8 @@
   jacobian.push_back(NULL);
   jacobian.push_back(jacobian_vect_[2].data());
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -567,10 +561,9 @@
 
     // Prepare the cost function.
     typedef DynamicAutoDiffCostFunction<MySixParameterCostFunctor, 3>
-      DynamicMySixParameterCostFunction;
-    DynamicMySixParameterCostFunction * cost_function =
-      new DynamicMySixParameterCostFunction(
-        new MySixParameterCostFunctor());
+        DynamicMySixParameterCostFunction;
+    DynamicMySixParameterCostFunction* cost_function =
+        new DynamicMySixParameterCostFunction(new MySixParameterCostFunctor());
     for (int i = 0; i < 6; ++i) {
       cost_function->AddParameterBlock(1);
     }
@@ -675,9 +668,8 @@
 
 TEST_F(SixParameterCostFunctorTest, TestSixParameterResiduals) {
   vector<double> residuals(7, -100000);
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       NULL));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), NULL));
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
   }
@@ -694,9 +686,8 @@
   jacobian.push_back(jacobian_vect_[4].data());
   jacobian.push_back(jacobian_vect_[5].data());
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -720,9 +711,8 @@
   jacobian.push_back(jacobian_vect_[4].data());
   jacobian.push_back(NULL);
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -751,9 +741,8 @@
   jacobian.push_back(NULL);
   jacobian.push_back(jacobian_vect_[5].data());
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
diff --git a/internal/ceres/dynamic_compressed_row_finalizer.h b/internal/ceres/dynamic_compressed_row_finalizer.h
index a25a308..30c98d8 100644
--- a/internal/ceres/dynamic_compressed_row_finalizer.h
+++ b/internal/ceres/dynamic_compressed_row_finalizer.h
@@ -40,7 +40,7 @@
 struct DynamicCompressedRowJacobianFinalizer {
   void operator()(SparseMatrix* base_jacobian, int num_parameters) {
     DynamicCompressedRowSparseMatrix* jacobian =
-      down_cast<DynamicCompressedRowSparseMatrix*>(base_jacobian);
+        down_cast<DynamicCompressedRowSparseMatrix*>(base_jacobian);
     jacobian->Finalize(num_parameters);
   }
 };
diff --git a/internal/ceres/dynamic_compressed_row_jacobian_writer.h b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
index 6e5ac38..ef8fa25 100644
--- a/internal/ceres/dynamic_compressed_row_jacobian_writer.h
+++ b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
@@ -47,8 +47,7 @@
  public:
   DynamicCompressedRowJacobianWriter(Evaluator::Options /* ignored */,
                                      Program* program)
-    : program_(program) {
-  }
+      : program_(program) {}
 
   // JacobianWriter interface.
 
@@ -70,7 +69,7 @@
   // This method is thread-safe over residual blocks (each `residual_id`).
   void Write(int residual_id,
              int residual_offset,
-             double **jacobians,
+             double** jacobians,
              SparseMatrix* base_jacobian);
 
  private:
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
index f020768..936e682 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
@@ -28,22 +28,19 @@
 //
 // Author: richie.stebbing@gmail.com (Richard Stebbing)
 
-#include <cstring>
 #include "ceres/dynamic_compressed_row_sparse_matrix.h"
 
+#include <cstring>
+
 namespace ceres {
 namespace internal {
 
 DynamicCompressedRowSparseMatrix::DynamicCompressedRowSparseMatrix(
-  int num_rows,
-  int num_cols,
-  int initial_max_num_nonzeros)
-    : CompressedRowSparseMatrix(num_rows,
-                                num_cols,
-                                initial_max_num_nonzeros) {
-    dynamic_cols_.resize(num_rows);
-    dynamic_values_.resize(num_rows);
-  }
+    int num_rows, int num_cols, int initial_max_num_nonzeros)
+    : CompressedRowSparseMatrix(num_rows, num_cols, initial_max_num_nonzeros) {
+  dynamic_cols_.resize(num_rows);
+  dynamic_values_.resize(num_rows);
+}
 
 void DynamicCompressedRowSparseMatrix::InsertEntry(int row,
                                                    int col,
@@ -56,8 +53,7 @@
   dynamic_values_[row].push_back(value);
 }
 
-void DynamicCompressedRowSparseMatrix::ClearRows(int row_start,
-                                                 int num_rows) {
+void DynamicCompressedRowSparseMatrix::ClearRows(int row_start, int num_rows) {
   for (int r = 0; r < num_rows; ++r) {
     const int i = row_start + r;
     CHECK_GE(i, 0);
@@ -99,8 +95,8 @@
   mutable_rows()[num_rows()] = index_into_values_and_cols;
 
   CHECK_EQ(index_into_values_and_cols, num_jacobian_nonzeros)
-    << "Ceres bug: final index into values_ and cols_ should be equal to "
-    << "the number of jacobian nonzeros. Please contact the developers!";
+      << "Ceres bug: final index into values_ and cols_ should be equal to "
+      << "the number of jacobian nonzeros. Please contact the developers!";
 }
 
 }  // namespace internal
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
index 25b51ce..95dc807 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/dynamic_compressed_row_sparse_matrix.h"
 
 #include <memory>
+
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
@@ -60,14 +61,10 @@
     InitialiseDenseReference();
     InitialiseSparseMatrixReferences();
 
-    dcrsm.reset(new DynamicCompressedRowSparseMatrix(num_rows,
-                                                     num_cols,
-                                                     0));
+    dcrsm.reset(new DynamicCompressedRowSparseMatrix(num_rows, num_cols, 0));
   }
 
-  void Finalize() {
-    dcrsm->Finalize(num_additional_elements);
-  }
+  void Finalize() { dcrsm->Finalize(num_additional_elements); }
 
   void InitialiseDenseReference() {
     dense.resize(num_rows, num_cols);
@@ -96,9 +93,8 @@
     }
     ASSERT_EQ(values.size(), expected_num_nonzeros);
 
-    tsm.reset(new TripletSparseMatrix(num_rows,
-                                      num_cols,
-                                      expected_num_nonzeros));
+    tsm.reset(
+        new TripletSparseMatrix(num_rows, num_cols, expected_num_nonzeros));
     copy(rows.begin(), rows.end(), tsm->mutable_rows());
     copy(cols.begin(), cols.end(), tsm->mutable_cols());
     copy(values.begin(), values.end(), tsm->mutable_values());
diff --git a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
index d86cc95..0150f5e 100644
--- a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
+++ b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
@@ -29,10 +29,11 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 //         mierle@gmail.com (Keir Mierle)
 
-#include <cstddef>
-
-#include <memory>
 #include "ceres/dynamic_numeric_diff_cost_function.h"
+
+#include <cstddef>
+#include <memory>
+
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -87,9 +88,8 @@
   vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
-  EXPECT_TRUE(cost_function.Evaluate(&parameter_blocks[0],
-                                     residuals.data(),
-                                     NULL));
+  EXPECT_TRUE(
+      cost_function.Evaluate(&parameter_blocks[0], residuals.data(), NULL));
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(1.0 * r, residuals.at(r * 2));
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2 + 1));
@@ -97,7 +97,6 @@
   EXPECT_EQ(0, residuals.at(20));
 }
 
-
 TEST(DynamicNumericdiffCostFunctionTest, TestJacobian) {
   // Test the residual counting.
   vector<double> param_block_0(10, 0.0);
@@ -128,9 +127,8 @@
   jacobian.push_back(jacobian_vect[1].data());
 
   // Test jacobian computation.
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
-                                     residuals.data(),
-                                     jacobian.data()));
+  EXPECT_TRUE(cost_function.Evaluate(
+      parameter_blocks.data(), residuals.data(), jacobian.data()));
 
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -139,11 +137,11 @@
   EXPECT_EQ(420, residuals.at(20));
   for (int p = 0; p < 10; ++p) {
     // Check "A" Jacobian.
-    EXPECT_NEAR(-1.0, jacobian_vect[0][2*p * 10 + p], kTolerance);
+    EXPECT_NEAR(-1.0, jacobian_vect[0][2 * p * 10 + p], kTolerance);
     // Check "B" Jacobian.
-    EXPECT_NEAR(+1.0, jacobian_vect[0][(2*p+1) * 10 + p], kTolerance);
-    jacobian_vect[0][2*p * 10 + p] = 0.0;
-    jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+    EXPECT_NEAR(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p], kTolerance);
+    jacobian_vect[0][2 * p * 10 + p] = 0.0;
+    jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
   }
 
   // Check "C" Jacobian for first parameter block.
@@ -165,7 +163,8 @@
   }
 }
 
-TEST(DynamicNumericdiffCostFunctionTest, JacobianWithFirstParameterBlockConstant) {  // NOLINT
+TEST(DynamicNumericdiffCostFunctionTest,
+     JacobianWithFirstParameterBlockConstant) {  // NOLINT
   // Test the residual counting.
   vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
@@ -195,9 +194,8 @@
   jacobian.push_back(jacobian_vect[1].data());
 
   // Test jacobian computation.
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
-                                     residuals.data(),
-                                     jacobian.data()));
+  EXPECT_TRUE(cost_function.Evaluate(
+      parameter_blocks.data(), residuals.data(), jacobian.data()));
 
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -215,7 +213,8 @@
   }
 }
 
-TEST(DynamicNumericdiffCostFunctionTest, JacobianWithSecondParameterBlockConstant) {  // NOLINT
+TEST(DynamicNumericdiffCostFunctionTest,
+     JacobianWithSecondParameterBlockConstant) {  // NOLINT
   // Test the residual counting.
   vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
@@ -245,9 +244,8 @@
   jacobian.push_back(NULL);
 
   // Test jacobian computation.
-  EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
-                                     residuals.data(),
-                                     jacobian.data()));
+  EXPECT_TRUE(cost_function.Evaluate(
+      parameter_blocks.data(), residuals.data(), jacobian.data()));
 
   for (int r = 0; r < 10; ++r) {
     EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -256,11 +254,11 @@
   EXPECT_EQ(420, residuals.at(20));
   for (int p = 0; p < 10; ++p) {
     // Check "A" Jacobian.
-    EXPECT_NEAR(-1.0, jacobian_vect[0][2*p * 10 + p], kTolerance);
+    EXPECT_NEAR(-1.0, jacobian_vect[0][2 * p * 10 + p], kTolerance);
     // Check "B" Jacobian.
-    EXPECT_NEAR(+1.0, jacobian_vect[0][(2*p+1) * 10 + p], kTolerance);
-    jacobian_vect[0][2*p * 10 + p] = 0.0;
-    jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+    EXPECT_NEAR(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p], kTolerance);
+    jacobian_vect[0][2 * p * 10 + p] = 0.0;
+    jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
   }
 
   // Check "C" Jacobian for first parameter block.
@@ -331,10 +329,10 @@
 
     // Prepare the cost function.
     typedef DynamicNumericDiffCostFunction<MyThreeParameterCostFunctor>
-      DynamicMyThreeParameterCostFunction;
-    DynamicMyThreeParameterCostFunction * cost_function =
-      new DynamicMyThreeParameterCostFunction(
-        new MyThreeParameterCostFunctor());
+        DynamicMyThreeParameterCostFunction;
+    DynamicMyThreeParameterCostFunction* cost_function =
+        new DynamicMyThreeParameterCostFunction(
+            new MyThreeParameterCostFunctor());
     cost_function->AddParameterBlock(1);
     cost_function->AddParameterBlock(2);
     cost_function->AddParameterBlock(3);
@@ -432,9 +430,8 @@
 
 TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
   vector<double> residuals(7, -100000);
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       NULL));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), NULL));
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
   }
@@ -448,9 +445,8 @@
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(jacobian_vect_[2].data());
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -478,9 +474,8 @@
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(NULL);
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -500,9 +495,8 @@
   jacobian.push_back(NULL);
   jacobian.push_back(jacobian_vect_[2].data());
 
-  EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
-                                       residuals.data(),
-                                       jacobian.data()));
+  EXPECT_TRUE(cost_function_->Evaluate(
+      parameter_blocks_.data(), residuals.data(), jacobian.data()));
 
   for (int i = 0; i < 7; ++i) {
     EXPECT_EQ(expected_residuals_[i], residuals[i]);
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc b/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
index 25d5417..d31c422 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
@@ -95,7 +95,7 @@
       LOG(FATAL) << "Unsupported sparse linear algebra library for "
                  << "dynamic sparsity: "
                  << SparseLinearAlgebraLibraryTypeToString(
-                     options_.sparse_linear_algebra_library_type);
+                        options_.sparse_linear_algebra_library_type);
   }
 
   if (per_solve_options.D != nullptr) {
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver.h b/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
index 4e31c7a..36118ba 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
@@ -35,7 +35,9 @@
 #define CERES_INTERNAL_DYNAMIC_SPARSE_NORMAL_CHOLESKY_SOLVER_H_
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
 
 #include "ceres/linear_solver.h"
 
@@ -59,23 +61,19 @@
   virtual ~DynamicSparseNormalCholeskySolver() {}
 
  private:
-  LinearSolver::Summary SolveImpl(
-      CompressedRowSparseMatrix* A,
-      const double* b,
-      const LinearSolver::PerSolveOptions& options,
-      double* x) final;
+  LinearSolver::Summary SolveImpl(CompressedRowSparseMatrix* A,
+                                  const double* b,
+                                  const LinearSolver::PerSolveOptions& options,
+                                  double* x) final;
 
-  LinearSolver::Summary SolveImplUsingSuiteSparse(
-      CompressedRowSparseMatrix* A,
-      double* rhs_and_solution);
+  LinearSolver::Summary SolveImplUsingSuiteSparse(CompressedRowSparseMatrix* A,
+                                                  double* rhs_and_solution);
 
-  LinearSolver::Summary SolveImplUsingCXSparse(
-      CompressedRowSparseMatrix* A,
-      double* rhs_and_solution);
+  LinearSolver::Summary SolveImplUsingCXSparse(CompressedRowSparseMatrix* A,
+                                               double* rhs_and_solution);
 
-  LinearSolver::Summary SolveImplUsingEigen(
-      CompressedRowSparseMatrix* A,
-      double* rhs_and_solution);
+  LinearSolver::Summary SolveImplUsingEigen(CompressedRowSparseMatrix* A,
+                                            double* rhs_and_solution);
 
   const LinearSolver::Options options_;
 };
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc b/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
index 3d0d46d..8bf609e 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
@@ -29,6 +29,8 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include <memory>
+
+#include "Eigen/Cholesky"
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/context_impl.h"
@@ -39,8 +41,6 @@
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
-#include "Eigen/Cholesky"
-
 namespace ceres {
 namespace internal {
 
diff --git a/internal/ceres/dynamic_sparsity_test.cc b/internal/ceres/dynamic_sparsity_test.cc
index 94ed173..12e62ef 100644
--- a/internal/ceres/dynamic_sparsity_test.cc
+++ b/internal/ceres/dynamic_sparsity_test.cc
@@ -33,6 +33,7 @@
 
 #include <cmath>
 #include <vector>
+
 #include "ceres/ceres.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
@@ -53,6 +54,7 @@
 
 const int kYRows = 212;
 const int kYCols = 2;
+// clang-format off
 const double kYData[kYRows * kYCols] = {
   +3.871364e+00, +9.916027e-01,
   +3.864003e+00, +1.034148e+00,
@@ -267,6 +269,7 @@
   +3.870542e+00, +9.996121e-01,
   +3.865424e+00, +1.028474e+00
 };
+// clang-format on
 
 ConstMatrixRef kY(kYData, kYRows, kYCols);
 
@@ -327,7 +330,8 @@
     return true;
   }
 
-  static CostFunction* Create(const int num_segments, const Eigen::Vector2d& y) {
+  static CostFunction* Create(const int num_segments,
+                              const Eigen::Vector2d& y) {
     return new PointToLineSegmentContourCostFunction(num_segments, y);
   }
 
diff --git a/internal/ceres/eigensparse.h b/internal/ceres/eigensparse.h
index 2e6c6f0..bb89c2c 100644
--- a/internal/ceres/eigensparse.h
+++ b/internal/ceres/eigensparse.h
@@ -56,8 +56,8 @@
 
   // SparseCholesky interface.
   virtual ~EigenSparseCholesky();
-  virtual LinearSolverTerminationType Factorize(
-      CompressedRowSparseMatrix* lhs, std::string* message) = 0;
+  virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+                                                std::string* message) = 0;
   virtual CompressedRowSparseMatrix::StorageType StorageType() const = 0;
   virtual LinearSolverTerminationType Solve(const double* rhs,
                                             double* solution,
@@ -74,8 +74,8 @@
 
   // SparseCholesky interface.
   virtual ~FloatEigenSparseCholesky();
-  virtual LinearSolverTerminationType Factorize(
-      CompressedRowSparseMatrix* lhs, std::string* message) = 0;
+  virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+                                                std::string* message) = 0;
   virtual CompressedRowSparseMatrix::StorageType StorageType() const = 0;
   virtual LinearSolverTerminationType Solve(const double* rhs,
                                             double* solution,
diff --git a/internal/ceres/evaluation_callback_test.cc b/internal/ceres/evaluation_callback_test.cc
index ccca942..0ca2625 100644
--- a/internal/ceres/evaluation_callback_test.cc
+++ b/internal/ceres/evaluation_callback_test.cc
@@ -34,10 +34,10 @@
 #include <limits>
 #include <vector>
 
+#include "ceres/autodiff_cost_function.h"
 #include "ceres/problem.h"
 #include "ceres/problem_impl.h"
 #include "ceres/sized_cost_function.h"
-#include "ceres/autodiff_cost_function.h"
 #include "ceres/solver.h"
 #include "gtest/gtest.h"
 
@@ -249,8 +249,8 @@
  public:
   void PrepareForEvaluation(bool evaluate_jacobians,
                             bool new_evaluation_point) final {
-    (void) evaluate_jacobians;
-    (void) new_evaluation_point;
+    (void)evaluate_jacobians;
+    (void)new_evaluation_point;
     counter_ += 1.0;
   }
 
diff --git a/internal/ceres/evaluator.cc b/internal/ceres/evaluator.cc
index 8387983..5168741 100644
--- a/internal/ceres/evaluator.cc
+++ b/internal/ceres/evaluator.cc
@@ -28,7 +28,10 @@
 //
 // Author: keir@google.com (Keir Mierle)
 
+#include "ceres/evaluator.h"
+
 #include <vector>
+
 #include "ceres/block_evaluate_preparer.h"
 #include "ceres/block_jacobian_writer.h"
 #include "ceres/compressed_row_jacobian_writer.h"
@@ -37,7 +40,6 @@
 #include "ceres/dense_jacobian_writer.h"
 #include "ceres/dynamic_compressed_row_finalizer.h"
 #include "ceres/dynamic_compressed_row_jacobian_writer.h"
-#include "ceres/evaluator.h"
 #include "ceres/internal/port.h"
 #include "ceres/program_evaluator.h"
 #include "ceres/scratch_evaluate_preparer.h"
@@ -56,26 +58,23 @@
   switch (options.linear_solver_type) {
     case DENSE_QR:
     case DENSE_NORMAL_CHOLESKY:
-      return new ProgramEvaluator<ScratchEvaluatePreparer,
-                                  DenseJacobianWriter>(options,
-                                                       program);
+      return new ProgramEvaluator<ScratchEvaluatePreparer, DenseJacobianWriter>(
+          options, program);
     case DENSE_SCHUR:
     case SPARSE_SCHUR:
     case ITERATIVE_SCHUR:
     case CGNR:
-      return new ProgramEvaluator<BlockEvaluatePreparer,
-                                  BlockJacobianWriter>(options,
-                                                       program);
+      return new ProgramEvaluator<BlockEvaluatePreparer, BlockJacobianWriter>(
+          options, program);
     case SPARSE_NORMAL_CHOLESKY:
       if (options.dynamic_sparsity) {
         return new ProgramEvaluator<ScratchEvaluatePreparer,
                                     DynamicCompressedRowJacobianWriter,
                                     DynamicCompressedRowJacobianFinalizer>(
-                                        options, program);
+            options, program);
       } else {
-        return new ProgramEvaluator<BlockEvaluatePreparer,
-                                    BlockJacobianWriter>(options,
-                                                         program);
+        return new ProgramEvaluator<BlockEvaluatePreparer, BlockJacobianWriter>(
+            options, program);
       }
 
     default:
diff --git a/internal/ceres/evaluator.h b/internal/ceres/evaluator.h
index b820958..a668445 100644
--- a/internal/ceres/evaluator.h
+++ b/internal/ceres/evaluator.h
@@ -124,12 +124,8 @@
                 double* residuals,
                 double* gradient,
                 SparseMatrix* jacobian) {
-    return Evaluate(EvaluateOptions(),
-                    state,
-                    cost,
-                    residuals,
-                    gradient,
-                    jacobian);
+    return Evaluate(
+        EvaluateOptions(), state, cost, residuals, gradient, jacobian);
   }
 
   // Make a change delta (of size NumEffectiveParameters()) to state (of size
@@ -152,7 +148,7 @@
 
   // This is the effective number of parameters that the optimizer may adjust.
   // This applies when there are parameterizations on some of the parameters.
-  virtual int NumEffectiveParameters()  const = 0;
+  virtual int NumEffectiveParameters() const = 0;
 
   // The number of residuals in the optimization problem.
   virtual int NumResiduals() const = 0;
diff --git a/internal/ceres/evaluator_test.cc b/internal/ceres/evaluator_test.cc
index 4f023d1..5ddb733 100644
--- a/internal/ceres/evaluator_test.cc
+++ b/internal/ceres/evaluator_test.cc
@@ -34,6 +34,7 @@
 #include "ceres/evaluator.h"
 
 #include <memory>
+
 #include "ceres/casts.h"
 #include "ceres/cost_function.h"
 #include "ceres/crs_matrix.h"
@@ -105,17 +106,16 @@
   EvaluatorTestOptions(LinearSolverType linear_solver_type,
                        int num_eliminate_blocks,
                        bool dynamic_sparsity = false)
-    : linear_solver_type(linear_solver_type),
-      num_eliminate_blocks(num_eliminate_blocks),
-      dynamic_sparsity(dynamic_sparsity) {}
+      : linear_solver_type(linear_solver_type),
+        num_eliminate_blocks(num_eliminate_blocks),
+        dynamic_sparsity(dynamic_sparsity) {}
 
   LinearSolverType linear_solver_type;
   int num_eliminate_blocks;
   bool dynamic_sparsity;
 };
 
-struct EvaluatorTest
-    : public ::testing::TestWithParam<EvaluatorTestOptions> {
+struct EvaluatorTest : public ::testing::TestWithParam<EvaluatorTestOptions> {
   Evaluator* CreateEvaluator(Program* program) {
     // This program is straight from the ProblemImpl, and so has no index/offset
     // yet; compute it here as required by the evaluator implementations.
@@ -123,13 +123,15 @@
 
     if (VLOG_IS_ON(1)) {
       string report;
-      StringAppendF(&report, "Creating evaluator with type: %d",
+      StringAppendF(&report,
+                    "Creating evaluator with type: %d",
                     GetParam().linear_solver_type);
       if (GetParam().linear_solver_type == SPARSE_NORMAL_CHOLESKY) {
-        StringAppendF(&report, ", dynamic_sparsity: %d",
-                      GetParam().dynamic_sparsity);
+        StringAppendF(
+            &report, ", dynamic_sparsity: %d", GetParam().dynamic_sparsity);
       }
-      StringAppendF(&report, " and num_eliminate_blocks: %d",
+      StringAppendF(&report,
+                    " and num_eliminate_blocks: %d",
                     GetParam().num_eliminate_blocks);
       VLOG(1) << report;
     }
@@ -142,7 +144,7 @@
     return Evaluator::Create(options, program, &error);
   }
 
-  void EvaluateAndCompare(ProblemImpl *problem,
+  void EvaluateAndCompare(ProblemImpl* problem,
                           int expected_num_rows,
                           int expected_num_cols,
                           double expected_cost,
@@ -171,12 +173,14 @@
 
     vector<double> state(evaluator->NumParameters());
 
+    // clang-format off
     ASSERT_TRUE(evaluator->Evaluate(
           &state[0],
           &cost,
           expected_residuals != nullptr ? &residuals[0]  : nullptr,
           expected_gradient  != nullptr ? &gradient[0]   : nullptr,
           expected_jacobian  != nullptr ? jacobian.get() : nullptr));
+    // clang-format on
 
     Matrix actual_jacobian;
     if (expected_jacobian != nullptr) {
@@ -196,15 +200,15 @@
   }
 
   // Try all combinations of parameters for the evaluator.
-  void CheckAllEvaluationCombinations(const ExpectedEvaluation &expected) {
+  void CheckAllEvaluationCombinations(const ExpectedEvaluation& expected) {
     for (int i = 0; i < 8; ++i) {
       EvaluateAndCompare(&problem,
                          expected.num_rows,
                          expected.num_cols,
                          expected.cost,
                          (i & 1) ? expected.residuals : nullptr,
-                         (i & 2) ? expected.gradient  : nullptr,
-                         (i & 4) ? expected.jacobian  : nullptr);
+                         (i & 2) ? expected.gradient : nullptr,
+                         (i & 4) ? expected.jacobian : nullptr);
     }
   }
 
@@ -217,15 +221,15 @@
 };
 
 static void SetSparseMatrixConstant(SparseMatrix* sparse_matrix, double value) {
-  VectorRef(sparse_matrix->mutable_values(),
-            sparse_matrix->num_nonzeros()).setConstant(value);
+  VectorRef(sparse_matrix->mutable_values(), sparse_matrix->num_nonzeros())
+      .setConstant(value);
 }
 
 TEST_P(EvaluatorTest, SingleResidualProblem) {
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>,
-                           nullptr,
-                           x, y, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>, nullptr, x, y, z);
 
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     3, 9,
@@ -245,14 +249,15 @@
       1, 2,   1, 2, 3,   1, 2, 3, 4
     }
   };
+  // clang-format on
   CheckAllEvaluationCombinations(expected);
 }
 
 TEST_P(EvaluatorTest, SingleResidualProblemWithPermutedParameters) {
   // Add the parameters in explicit order to force the ordering in the program.
-  problem.AddParameterBlock(x,  2);
-  problem.AddParameterBlock(y,  3);
-  problem.AddParameterBlock(z,  4);
+  problem.AddParameterBlock(x, 2);
+  problem.AddParameterBlock(y, 3);
+  problem.AddParameterBlock(z, 4);
 
   // Then use a cost function which is similar to the others, but swap around
   // the ordering of the parameters to the cost function. This shouldn't affect
@@ -260,10 +265,10 @@
   // At one point the compressed row evaluator had a bug that went undetected
   // for a long time, since by chance most users added parameters to the problem
   // in the same order that they occurred as parameters to a cost function.
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 3, 4, 3, 2>,
-                           nullptr,
-                           z, y, x);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<1, 3, 4, 3, 2>, nullptr, z, y, x);
 
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     3, 9,
@@ -283,6 +288,7 @@
       1, 2,   1, 2, 3,   1, 2, 3, 4
     }
   };
+  // clang-format on
   CheckAllEvaluationCombinations(expected);
 }
 
@@ -303,10 +309,10 @@
   problem.AddParameterBlock(z, 4);
   problem.AddParameterBlock(d, 3);
 
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>,
-                           nullptr,
-                           x, y, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>, nullptr, x, y, z);
 
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     3, 16,
@@ -330,30 +336,29 @@
       0, 0,    1, 2,    0,    1, 2, 3,    0,    1, 2, 3, 4,    0, 0, 0
     }
   };
+  // clang-format on
   CheckAllEvaluationCombinations(expected);
 }
 
 TEST_P(EvaluatorTest, MultipleResidualProblem) {
   // Add the parameters in explicit order to force the ordering in the program.
-  problem.AddParameterBlock(x,  2);
-  problem.AddParameterBlock(y,  3);
-  problem.AddParameterBlock(z,  4);
+  problem.AddParameterBlock(x, 2);
+  problem.AddParameterBlock(y, 3);
+  problem.AddParameterBlock(z, 4);
 
   // f(x, y) in R^2
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 2, 2, 3>,
-                           nullptr,
-                           x, y);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<1, 2, 2, 3>, nullptr, x, y);
 
   // g(x, z) in R^3
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<2, 3, 2, 4>,
-                           nullptr,
-                           x, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<2, 3, 2, 4>, nullptr, x, z);
 
   // h(y, z) in R^4
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<3, 4, 3, 4>,
-                           nullptr,
-                           y, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<3, 4, 3, 4>, nullptr, y, z);
 
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     9, 9,
@@ -385,12 +390,13 @@
                       0, 0,    3, 6, 9,    3, 6, 9, 12
     }
   };
+  // clang-format on
   CheckAllEvaluationCombinations(expected);
 }
 
 TEST_P(EvaluatorTest, MultipleResidualsWithLocalParameterizations) {
   // Add the parameters in explicit order to force the ordering in the program.
-  problem.AddParameterBlock(x,  2);
+  problem.AddParameterBlock(x, 2);
 
   // Fix y's first dimension.
   vector<int> y_fixed;
@@ -403,20 +409,18 @@
   problem.AddParameterBlock(z, 4, new SubsetParameterization(4, z_fixed));
 
   // f(x, y) in R^2
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 2, 2, 3>,
-                           nullptr,
-                           x, y);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<1, 2, 2, 3>, nullptr, x, y);
 
   // g(x, z) in R^3
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<2, 3, 2, 4>,
-                           nullptr,
-                           x, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<2, 3, 2, 4>, nullptr, x, z);
 
   // h(y, z) in R^4
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<3, 4, 3, 4>,
-                           nullptr,
-                           y, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<3, 4, 3, 4>, nullptr, y, z);
 
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     9, 7,
@@ -448,6 +452,7 @@
                       0, 0,    6, 9,    3, 9, 12
     }
   };
+  // clang-format on
   CheckAllEvaluationCombinations(expected);
 }
 
@@ -458,24 +463,21 @@
   double z[4];
 
   // Add the parameters in explicit order to force the ordering in the program.
-  problem.AddParameterBlock(x,  2);
-  problem.AddParameterBlock(y,  3);
-  problem.AddParameterBlock(z,  4);
+  problem.AddParameterBlock(x, 2);
+  problem.AddParameterBlock(y, 3);
+  problem.AddParameterBlock(z, 4);
 
   // f(x, y) in R^2
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 2, 2, 3>,
-                          nullptr,
-                          x, y);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<1, 2, 2, 3>, nullptr, x, y);
 
   // g(x, z) in R^3
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<2, 3, 2, 4>,
-                          nullptr,
-                          x, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<2, 3, 2, 4>, nullptr, x, z);
 
   // h(y, z) in R^4
-  problem.AddResidualBlock(new ParameterIgnoringCostFunction<3, 4, 3, 4>,
-                           nullptr,
-                           y, z);
+  problem.AddResidualBlock(
+      new ParameterIgnoringCostFunction<3, 4, 3, 4>, nullptr, y, z);
 
   // For this test, "z" is constant.
   problem.SetParameterBlockConstant(z);
@@ -493,6 +495,7 @@
   ParameterBlock* parameter_block_z = parameter_blocks->back();
   parameter_blocks->pop_back();
 
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     9, 5,
@@ -523,6 +526,7 @@
                       0, 0,    3, 6, 9
     }
   };
+  // clang-format on
   CheckAllEvaluationCombinations(expected);
 
   // Restore parameter block z, so it will get freed in a consistent way.
diff --git a/internal/ceres/evaluator_test_utils.cc b/internal/ceres/evaluator_test_utils.cc
index 36dc21c..25801db 100644
--- a/internal/ceres/evaluator_test_utils.cc
+++ b/internal/ceres/evaluator_test_utils.cc
@@ -30,6 +30,7 @@
 //         sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/evaluator_test_utils.h"
+
 #include "ceres/internal/eigen.h"
 #include "gtest/gtest.h"
 
@@ -51,37 +52,39 @@
   if (expected_residuals != NULL) {
     ConstVectorRef expected_residuals_vector(expected_residuals,
                                              expected_num_rows);
-    ConstVectorRef actual_residuals_vector(actual_residuals,
-                                           expected_num_rows);
-    EXPECT_TRUE((actual_residuals_vector.array() ==
-                 expected_residuals_vector.array()).all())
-        << "Actual:\n" << actual_residuals_vector
-        << "\nExpected:\n" << expected_residuals_vector;
+    ConstVectorRef actual_residuals_vector(actual_residuals, expected_num_rows);
+    EXPECT_TRUE(
+        (actual_residuals_vector.array() == expected_residuals_vector.array())
+            .all())
+        << "Actual:\n"
+        << actual_residuals_vector << "\nExpected:\n"
+        << expected_residuals_vector;
   }
 
   if (expected_gradient != NULL) {
     ConstVectorRef expected_gradient_vector(expected_gradient,
                                             expected_num_cols);
-    ConstVectorRef actual_gradient_vector(actual_gradient,
-                                            expected_num_cols);
+    ConstVectorRef actual_gradient_vector(actual_gradient, expected_num_cols);
 
-    EXPECT_TRUE((actual_gradient_vector.array() ==
-                 expected_gradient_vector.array()).all())
-        << "Actual:\n" << actual_gradient_vector.transpose()
-        << "\nExpected:\n" << expected_gradient_vector.transpose();
+    EXPECT_TRUE(
+        (actual_gradient_vector.array() == expected_gradient_vector.array())
+            .all())
+        << "Actual:\n"
+        << actual_gradient_vector.transpose() << "\nExpected:\n"
+        << expected_gradient_vector.transpose();
   }
 
   if (expected_jacobian != NULL) {
-    ConstMatrixRef expected_jacobian_matrix(expected_jacobian,
-                                            expected_num_rows,
-                                            expected_num_cols);
-    ConstMatrixRef actual_jacobian_matrix(actual_jacobian,
-                                          expected_num_rows,
-                                          expected_num_cols);
-    EXPECT_TRUE((actual_jacobian_matrix.array() ==
-                 expected_jacobian_matrix.array()).all())
-        << "Actual:\n" << actual_jacobian_matrix
-        << "\nExpected:\n" << expected_jacobian_matrix;
+    ConstMatrixRef expected_jacobian_matrix(
+        expected_jacobian, expected_num_rows, expected_num_cols);
+    ConstMatrixRef actual_jacobian_matrix(
+        actual_jacobian, expected_num_rows, expected_num_cols);
+    EXPECT_TRUE(
+        (actual_jacobian_matrix.array() == expected_jacobian_matrix.array())
+            .all())
+        << "Actual:\n"
+        << actual_jacobian_matrix << "\nExpected:\n"
+        << expected_jacobian_matrix;
   }
 }
 
diff --git a/internal/ceres/file.cc b/internal/ceres/file.cc
index c95a44d..94f2135 100644
--- a/internal/ceres/file.cc
+++ b/internal/ceres/file.cc
@@ -33,6 +33,7 @@
 #include "ceres/file.h"
 
 #include <cstdio>
+
 #include "glog/logging.h"
 
 namespace ceres {
@@ -40,7 +41,7 @@
 
 using std::string;
 
-void WriteStringToFileOrDie(const string &data, const string &filename) {
+void WriteStringToFileOrDie(const string& data, const string& filename) {
   FILE* file_descriptor = fopen(filename.c_str(), "wb");
   if (!file_descriptor) {
     LOG(FATAL) << "Couldn't write to file: " << filename;
@@ -49,7 +50,7 @@
   fclose(file_descriptor);
 }
 
-void ReadFileToStringOrDie(const string &filename, string *data) {
+void ReadFileToStringOrDie(const string& filename, string* data) {
   FILE* file_descriptor = fopen(filename.c_str(), "r");
 
   if (!file_descriptor) {
@@ -63,10 +64,8 @@
 
   // Read the data.
   fseek(file_descriptor, 0L, SEEK_SET);
-  int num_read = fread(&((*data)[0]),
-                       sizeof((*data)[0]),
-                       num_bytes,
-                       file_descriptor);
+  int num_read =
+      fread(&((*data)[0]), sizeof((*data)[0]), num_bytes, file_descriptor);
   if (num_read != num_bytes) {
     LOG(FATAL) << "Couldn't read all of " << filename
                << "expected bytes: " << num_bytes * sizeof((*data)[0])
@@ -77,9 +76,9 @@
 
 string JoinPath(const string& dirname, const string& basename) {
 #ifdef _WIN32
-    static const char separator = '\\';
+  static const char separator = '\\';
 #else
-    static const char separator = '/';
+  static const char separator = '/';
 #endif  // _WIN32
 
   if ((!basename.empty() && basename[0] == separator) || dirname.empty()) {
diff --git a/internal/ceres/file.h b/internal/ceres/file.h
index 219b459..30c0225 100644
--- a/internal/ceres/file.h
+++ b/internal/ceres/file.h
@@ -34,14 +34,15 @@
 #define CERES_INTERNAL_FILE_H_
 
 #include <string>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
 namespace internal {
 
-void WriteStringToFileOrDie(const std::string &data,
-                            const std::string &filename);
-void ReadFileToStringOrDie(const std::string &filename, std::string *data);
+void WriteStringToFileOrDie(const std::string& data,
+                            const std::string& filename);
+void ReadFileToStringOrDie(const std::string& filename, std::string* data);
 
 // Join two path components, adding a slash if necessary.  If basename is an
 // absolute path then JoinPath ignores dirname and simply returns basename.
diff --git a/internal/ceres/fixed_array_test.cc b/internal/ceres/fixed_array_test.cc
index 95cba7f..d418786 100644
--- a/internal/ceres/fixed_array_test.cc
+++ b/internal/ceres/fixed_array_test.cc
@@ -15,6 +15,7 @@
 #include "ceres/internal/fixed_array.h"
 
 #include <stdio.h>
+
 #include <cstring>
 #include <list>
 #include <memory>
diff --git a/internal/ceres/float_cxsparse.h b/internal/ceres/float_cxsparse.h
index 57fc5e4..9a274c2 100644
--- a/internal/ceres/float_cxsparse.h
+++ b/internal/ceres/float_cxsparse.h
@@ -37,6 +37,7 @@
 #if !defined(CERES_NO_CXSPARSE)
 
 #include <memory>
+
 #include "ceres/sparse_cholesky.h"
 
 namespace ceres {
@@ -46,8 +47,7 @@
 // CXSparse.
 class FloatCXSparseCholesky : public SparseCholesky {
  public:
-  static std::unique_ptr<SparseCholesky> Create(
-      OrderingType ordering_type);
+  static std::unique_ptr<SparseCholesky> Create(OrderingType ordering_type);
 };
 
 }  // namespace internal
diff --git a/internal/ceres/float_suitesparse.h b/internal/ceres/float_suitesparse.h
index ac4d409..c436da4 100644
--- a/internal/ceres/float_suitesparse.h
+++ b/internal/ceres/float_suitesparse.h
@@ -32,9 +32,12 @@
 #define CERES_INTERNAL_FLOAT_SUITESPARSE_H_
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
 
 #include <memory>
+
 #include "ceres/sparse_cholesky.h"
 
 #if !defined(CERES_NO_SUITESPARSE)
@@ -46,8 +49,7 @@
 // SuiteSparse.
 class FloatSuiteSparseCholesky : public SparseCholesky {
  public:
-  static std::unique_ptr<SparseCholesky> Create(
-      OrderingType ordering_type);
+  static std::unique_ptr<SparseCholesky> Create(OrderingType ordering_type);
 };
 
 }  // namespace internal
diff --git a/internal/ceres/function_sample.cc b/internal/ceres/function_sample.cc
index 2fd3dbd..3e0ae60 100644
--- a/internal/ceres/function_sample.cc
+++ b/internal/ceres/function_sample.cc
@@ -29,6 +29,7 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/function_sample.h"
+
 #include "ceres/stringprintf.h"
 
 namespace ceres {
@@ -64,9 +65,14 @@
       gradient_is_valid(true) {}
 
 std::string FunctionSample::ToDebugString() const {
-  return StringPrintf("[x: %.8e, value: %.8e, gradient: %.8e, "
-                      "value_is_valid: %d, gradient_is_valid: %d]",
-                      x, value, gradient, value_is_valid, gradient_is_valid);
+  return StringPrintf(
+      "[x: %.8e, value: %.8e, gradient: %.8e, "
+      "value_is_valid: %d, gradient_is_valid: %d]",
+      x,
+      value,
+      gradient,
+      value_is_valid,
+      gradient_is_valid);
 }
 
 }  // namespace internal
diff --git a/internal/ceres/function_sample.h b/internal/ceres/function_sample.h
index df79aef..8889f76 100644
--- a/internal/ceres/function_sample.h
+++ b/internal/ceres/function_sample.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_FUNCTION_SAMPLE_H_
 
 #include <string>
+
 #include "ceres/internal/eigen.h"
 
 namespace ceres {
@@ -85,9 +86,6 @@
   bool gradient_is_valid;
 };
 
-
-
-
 }  // namespace internal
 }  // namespace ceres
 
diff --git a/internal/ceres/generated/.clang-format b/internal/ceres/generated/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/generated/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/generated_bundle_adjustment_tests/.clang-format b/internal/ceres/generated_bundle_adjustment_tests/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/generated_bundle_adjustment_tests/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/gmock/.clang-format b/internal/ceres/gmock/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/gmock/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/gradient_checker.cc b/internal/ceres/gradient_checker.cc
index ef56666..dadaaa0 100644
--- a/internal/ceres/gradient_checker.cc
+++ b/internal/ceres/gradient_checker.cc
@@ -56,7 +56,7 @@
 // the local space of the respective local parameterizations.
 bool EvaluateCostFunction(
     const ceres::CostFunction* function,
-    double const* const * parameters,
+    double const* const* parameters,
     const std::vector<const ceres::LocalParameterization*>&
         local_parameterizations,
     Vector* residuals,
@@ -95,8 +95,8 @@
   CHECK_NE(0, function->num_residuals());
   residuals->resize(function->num_residuals());
   residuals->setZero();
-  if (!function->Evaluate(parameters, residuals->data(),
-                          jacobian_data.data())) {
+  if (!function->Evaluate(
+          parameters, residuals->data(), jacobian_data.data())) {
     return false;
   }
 
@@ -109,20 +109,20 @@
       int local_size = local_parameterizations.at(i)->LocalSize();
       CHECK_EQ(jacobians->at(i).cols(), global_size);
       Matrix global_J_local(global_size, local_size);
-      local_parameterizations.at(i)->ComputeJacobian(
-          parameters[i], global_J_local.data());
+      local_parameterizations.at(i)->ComputeJacobian(parameters[i],
+                                                     global_J_local.data());
       local_jacobians->at(i).noalias() = jacobians->at(i) * global_J_local;
     }
   }
   return true;
 }
-} // namespace
+}  // namespace
 
 GradientChecker::GradientChecker(
-      const CostFunction* function,
-      const vector<const LocalParameterization*>* local_parameterizations,
-      const NumericDiffOptions& options) :
-        function_(function) {
+    const CostFunction* function,
+    const vector<const LocalParameterization*>* local_parameterizations,
+    const NumericDiffOptions& options)
+    : function_(function) {
   CHECK(function != nullptr);
   if (local_parameterizations != NULL) {
     local_parameterizations_ = *local_parameterizations;
@@ -132,8 +132,8 @@
   }
   DynamicNumericDiffCostFunction<CostFunction, RIDDERS>*
       finite_diff_cost_function =
-      new DynamicNumericDiffCostFunction<CostFunction, RIDDERS>(
-          function, DO_NOT_TAKE_OWNERSHIP, options);
+          new DynamicNumericDiffCostFunction<CostFunction, RIDDERS>(
+              function, DO_NOT_TAKE_OWNERSHIP, options);
   finite_diff_cost_function_.reset(finite_diff_cost_function);
 
   const vector<int32_t>& parameter_block_sizes =
@@ -145,7 +145,7 @@
   finite_diff_cost_function->SetNumResiduals(function->num_residuals());
 }
 
-bool GradientChecker::Probe(double const* const * parameters,
+bool GradientChecker::Probe(double const* const* parameters,
                             double relative_precision,
                             ProbeResults* results_param) const {
   int num_residuals = function_->num_residuals();
@@ -171,8 +171,12 @@
   // Evaluate the derivative using the user supplied code.
   vector<Matrix>& jacobians = results->jacobians;
   vector<Matrix>& local_jacobians = results->local_jacobians;
-  if (!EvaluateCostFunction(function_, parameters, local_parameterizations_,
-                       &results->residuals, &jacobians, &local_jacobians)) {
+  if (!EvaluateCostFunction(function_,
+                            parameters,
+                            local_parameterizations_,
+                            &results->residuals,
+                            &jacobians,
+                            &local_jacobians)) {
     results->error_log = "Function evaluation with Jacobians failed.";
     results->return_value = false;
   }
@@ -181,10 +185,14 @@
   vector<Matrix>& numeric_jacobians = results->numeric_jacobians;
   vector<Matrix>& local_numeric_jacobians = results->local_numeric_jacobians;
   Vector finite_diff_residuals;
-  if (!EvaluateCostFunction(finite_diff_cost_function_.get(), parameters,
-                            local_parameterizations_, &finite_diff_residuals,
-                            &numeric_jacobians, &local_numeric_jacobians)) {
-    results->error_log += "\nFunction evaluation with numerical "
+  if (!EvaluateCostFunction(finite_diff_cost_function_.get(),
+                            parameters,
+                            local_parameterizations_,
+                            &finite_diff_residuals,
+                            &numeric_jacobians,
+                            &local_numeric_jacobians)) {
+    results->error_log +=
+        "\nFunction evaluation with numerical "
         "differentiation failed.";
     results->return_value = false;
   }
@@ -194,13 +202,13 @@
   }
 
   for (int i = 0; i < num_residuals; ++i) {
-    if (!IsClose(
-        results->residuals[i],
-        finite_diff_residuals[i],
-        relative_precision,
-        NULL,
-        NULL)) {
-      results->error_log = "Function evaluation with and without Jacobians "
+    if (!IsClose(results->residuals[i],
+                 finite_diff_residuals[i],
+                 relative_precision,
+                 NULL,
+                 NULL)) {
+      results->error_log =
+          "Function evaluation with and without Jacobians "
           "resulted in different residuals.";
       LOG(INFO) << results->residuals.transpose();
       LOG(INFO) << finite_diff_residuals.transpose();
@@ -219,7 +227,7 @@
   for (int k = 0; k < function_->parameter_block_sizes().size(); k++) {
     StringAppendF(&error_log,
                   "========== "
-                  "Jacobian for " "block %d: (%ld by %ld)) "
+                  "Jacobian for block %d: (%ld by %ld)) "
                   "==========\n",
                   k,
                   static_cast<long>(local_jacobians[k].rows()),
@@ -234,28 +242,33 @@
         double term_jacobian = local_jacobians[k](i, j);
         double finite_jacobian = local_numeric_jacobians[k](i, j);
         double relative_error, absolute_error;
-        bool bad_jacobian_entry =
-            !IsClose(term_jacobian,
-                     finite_jacobian,
-                     relative_precision,
-                     &relative_error,
-                     &absolute_error);
+        bool bad_jacobian_entry = !IsClose(term_jacobian,
+                                           finite_jacobian,
+                                           relative_precision,
+                                           &relative_error,
+                                           &absolute_error);
         worst_relative_error = std::max(worst_relative_error, relative_error);
 
         StringAppendF(&error_log,
                       "%6d %4d %4d %17g %17g %17g %17g %17g %17g",
-                      k, i, j,
-                      term_jacobian, finite_jacobian,
-                      absolute_error, relative_error,
+                      k,
+                      i,
+                      j,
+                      term_jacobian,
+                      finite_jacobian,
+                      absolute_error,
+                      relative_error,
                       parameters[k][j],
                       results->residuals[i]);
 
         if (bad_jacobian_entry) {
           num_bad_jacobian_components++;
-          StringAppendF(
-              &error_log,
-              " ------ (%d,%d,%d) Relative error worse than %g",
-              k, i, j, relative_precision);
+          StringAppendF(&error_log,
+                        " ------ (%d,%d,%d) Relative error worse than %g",
+                        k,
+                        i,
+                        j,
+                        relative_precision);
         }
         error_log += "\n";
       }
@@ -264,11 +277,12 @@
 
   // Since there were some bad errors, dump comprehensive debug info.
   if (num_bad_jacobian_components) {
-    string header = StringPrintf("\nDetected %d bad Jacobian component(s). "
+    string header = StringPrintf(
+        "\nDetected %d bad Jacobian component(s). "
         "Worst relative error was %g.\n",
         num_bad_jacobian_components,
         worst_relative_error);
-     results->error_log = header + "\n" + error_log;
+    results->error_log = header + "\n" + error_log;
     return false;
   }
   return true;
diff --git a/internal/ceres/gradient_checker_test.cc b/internal/ceres/gradient_checker_test.cc
index b2dd35e..31dc97b 100644
--- a/internal/ceres/gradient_checker_test.cc
+++ b/internal/ceres/gradient_checker_test.cc
@@ -169,8 +169,6 @@
   vector<vector<double>> a_;  // our vectors.
 };
 
-
-
 static void CheckDimensions(const GradientChecker::ProbeResults& results,
                             const std::vector<int>& parameter_sizes,
                             const std::vector<int>& local_parameter_sizes,
diff --git a/internal/ceres/gradient_checking_cost_function.cc b/internal/ceres/gradient_checking_cost_function.cc
index 13d6c58..2eb6d62 100644
--- a/internal/ceres/gradient_checking_cost_function.cc
+++ b/internal/ceres/gradient_checking_cost_function.cc
@@ -38,6 +38,7 @@
 #include <string>
 #include <vector>
 
+#include "ceres/dynamic_numeric_diff_cost_function.h"
 #include "ceres/gradient_checker.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/parameter_block.h"
@@ -45,7 +46,6 @@
 #include "ceres/problem_impl.h"
 #include "ceres/program.h"
 #include "ceres/residual_block.h"
-#include "ceres/dynamic_numeric_diff_cost_function.h"
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
@@ -81,7 +81,7 @@
     set_num_residuals(function->num_residuals());
   }
 
-  virtual ~GradientCheckingCostFunction() { }
+  virtual ~GradientCheckingCostFunction() {}
 
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -92,9 +92,8 @@
     }
 
     GradientChecker::ProbeResults results;
-    bool okay = gradient_checker_.Probe(parameters,
-                                        relative_precision_,
-                                        &results);
+    bool okay =
+        gradient_checker_.Probe(parameters, relative_precision_, &results);
 
     // If the cost function returned false, there's nothing we can say about
     // the gradients.
@@ -117,8 +116,9 @@
     }
 
     if (!okay) {
-      std::string error_log = "Gradient Error detected!\nExtra info for "
-          "this residual: " + extra_info_ + "\n" + results.error_log;
+      std::string error_log =
+          "Gradient Error detected!\nExtra info for this residual: " +
+          extra_info_ + "\n" + results.error_log;
       callback_->SetGradientErrorDetected(error_log);
     }
     return true;
@@ -135,13 +135,12 @@
 }  // namespace
 
 GradientCheckingIterationCallback::GradientCheckingIterationCallback()
-    : gradient_error_detected_(false) {
-}
+    : gradient_error_detected_(false) {}
 
 CallbackReturnType GradientCheckingIterationCallback::operator()(
     const IterationSummary& summary) {
   if (gradient_error_detected_) {
-    LOG(ERROR)<< "Gradient error detected. Terminating solver.";
+    LOG(ERROR) << "Gradient error detected. Terminating solver.";
     return SOLVER_ABORT;
   }
   return SOLVER_CONTINUE;
@@ -166,7 +165,8 @@
   return new GradientCheckingCostFunction(cost_function,
                                           local_parameterizations,
                                           numeric_diff_options,
-                                          relative_precision, extra_info,
+                                          relative_precision,
+                                          extra_info,
                                           callback);
 }
 
@@ -193,8 +193,8 @@
   NumericDiffOptions numeric_diff_options;
   numeric_diff_options.relative_step_size = relative_step_size;
 
-  ProblemImpl* gradient_checking_problem_impl = new ProblemImpl(
-      gradient_checking_problem_options);
+  ProblemImpl* gradient_checking_problem_impl =
+      new ProblemImpl(gradient_checking_problem_options);
 
   Program* program = problem_impl->mutable_program();
 
@@ -213,7 +213,7 @@
           parameter_block->mutable_user_state());
     }
 
-    for (int i = 0; i <  parameter_block->Size(); ++i) {
+    for (int i = 0; i < parameter_block->Size(); ++i) {
       gradient_checking_problem_impl->SetParameterUpperBound(
           parameter_block->mutable_user_state(),
           i,
@@ -235,8 +235,8 @@
     // Build a human readable string which identifies the
     // ResidualBlock. This is used by the GradientCheckingCostFunction
     // when logging debugging information.
-    string extra_info = StringPrintf(
-        "Residual block id %d; depends on parameters [", i);
+    string extra_info =
+        StringPrintf("Residual block id %d; depends on parameters [", i);
     vector<double*> parameter_blocks;
     vector<const LocalParameterization*> local_parameterizations;
     parameter_blocks.reserve(residual_block->NumParameterBlocks());
@@ -277,13 +277,11 @@
   // depend on this being the case, so we explicitly call
   // SetParameterBlockStatePtrsToUserStatePtrs to ensure that this is
   // the case.
-  gradient_checking_problem_impl
-      ->mutable_program()
+  gradient_checking_problem_impl->mutable_program()
       ->SetParameterBlockStatePtrsToUserStatePtrs();
 
   return gradient_checking_problem_impl;
 }
 
-
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/gradient_checking_cost_function.h b/internal/ceres/gradient_checking_cost_function.h
index e9a34f7..ab6e9f8 100644
--- a/internal/ceres/gradient_checking_cost_function.h
+++ b/internal/ceres/gradient_checking_cost_function.h
@@ -60,6 +60,7 @@
   // Retrieve error status (not thread safe).
   bool gradient_error_detected() const { return gradient_error_detected_; }
   const std::string& error_log() const { return error_log_; }
+
  private:
   bool gradient_error_detected_;
   std::string error_log_;
diff --git a/internal/ceres/gradient_checking_cost_function_test.cc b/internal/ceres/gradient_checking_cost_function_test.cc
index ff211ed..9ca51f8 100644
--- a/internal/ceres/gradient_checking_cost_function_test.cc
+++ b/internal/ceres/gradient_checking_cost_function_test.cc
@@ -53,10 +53,10 @@
 namespace internal {
 
 using std::vector;
+using testing::_;
 using testing::AllOf;
 using testing::AnyNumber;
 using testing::HasSubstr;
-using testing::_;
 
 // Pick a (non-quadratic) function whose derivative are easy:
 //
@@ -65,12 +65,12 @@
 //
 // where 'a' is a vector of the same size as 'x'. In the block
 // version, they are both block vectors, of course.
-template<int bad_block = 1, int bad_variable = 2>
+template <int bad_block = 1, int bad_variable = 2>
 class TestTerm : public CostFunction {
  public:
   // The constructor of this function needs to know the number
   // of blocks desired, and the size of each block.
-  TestTerm(int arity, int const *dim) : arity_(arity) {
+  TestTerm(int arity, int const* dim) : arity_(arity) {
     // Make 'arity' random vectors.
     a_.resize(arity_);
     for (int j = 0; j < arity_; ++j) {
@@ -107,7 +107,7 @@
         if (jacobians[j]) {
           for (int u = 0; u < parameter_block_sizes()[j]; ++u) {
             // See comments before class.
-            jacobians[j][u] = - f * a_[j][u];
+            jacobians[j][u] = -f * a_[j][u];
 
             if (bad_block == j && bad_variable == u) {
               // Whoopsiedoopsie! Deliberately introduce a faulty jacobian entry
@@ -135,7 +135,7 @@
 
   // Test with 3 blocks of size 2, 3 and 4.
   int const arity = 3;
-  int const dim[arity] = { 2, 3, 4 };
+  int const dim[arity] = {2, 3, 4};
 
   // Make a random set of blocks.
   vector<double*> parameters(arity);
@@ -164,17 +164,16 @@
   TestTerm<-1, -1> term(arity, dim);
   GradientCheckingIterationCallback callback;
   std::unique_ptr<CostFunction> gradient_checking_cost_function(
-      CreateGradientCheckingCostFunction(&term, NULL,
+      CreateGradientCheckingCostFunction(&term,
+                                         NULL,
                                          kRelativeStepSize,
                                          kRelativePrecision,
-                                         "Ignored.", &callback));
-  term.Evaluate(&parameters[0],
-                &original_residual,
-                &original_jacobians[0]);
+                                         "Ignored.",
+                                         &callback));
+  term.Evaluate(&parameters[0], &original_residual, &original_jacobians[0]);
 
-  gradient_checking_cost_function->Evaluate(&parameters[0],
-                                            &residual,
-                                            &jacobians[0]);
+  gradient_checking_cost_function->Evaluate(
+      &parameters[0], &residual, &jacobians[0]);
   EXPECT_EQ(original_residual, residual);
 
   for (int j = 0; j < arity; j++) {
@@ -193,7 +192,7 @@
 
   // Test with 3 blocks of size 2, 3 and 4.
   int const arity = 3;
-  int const dim[arity] = { 2, 3, 4 };
+  int const dim[arity] = {2, 3, 4};
 
   // Make a random set of blocks.
   vector<double*> parameters(arity);
@@ -221,17 +220,18 @@
     TestTerm<1, 2> term(arity, dim);
     GradientCheckingIterationCallback callback;
     std::unique_ptr<CostFunction> gradient_checking_cost_function(
-        CreateGradientCheckingCostFunction(&term, NULL,
+        CreateGradientCheckingCostFunction(&term,
+                                           NULL,
                                            kRelativeStepSize,
                                            kRelativePrecision,
-                                           "Fuzzy banana", &callback));
-    EXPECT_TRUE(
-        gradient_checking_cost_function->Evaluate(&parameters[0], &residual,
-                                                  &jacobians[0]));
+                                           "Fuzzy banana",
+                                           &callback));
+    EXPECT_TRUE(gradient_checking_cost_function->Evaluate(
+        &parameters[0], &residual, &jacobians[0]));
     EXPECT_TRUE(callback.gradient_error_detected());
     EXPECT_TRUE(callback.error_log().find("Fuzzy banana") != std::string::npos);
-    EXPECT_TRUE(callback.error_log().find("(1,0,2) Relative error worse than")
-                != std::string::npos);
+    EXPECT_TRUE(callback.error_log().find(
+                    "(1,0,2) Relative error worse than") != std::string::npos);
   }
 
   // The gradient is correct, so no errors are reported.
@@ -240,13 +240,14 @@
     TestTerm<-1, -1> term(arity, dim);
     GradientCheckingIterationCallback callback;
     std::unique_ptr<CostFunction> gradient_checking_cost_function(
-        CreateGradientCheckingCostFunction(&term, NULL,
+        CreateGradientCheckingCostFunction(&term,
+                                           NULL,
                                            kRelativeStepSize,
                                            kRelativePrecision,
-                                           "Fuzzy banana", &callback));
-    EXPECT_TRUE(
-        gradient_checking_cost_function->Evaluate(&parameters[0], &residual,
-                                                  &jacobians[0]));
+                                           "Fuzzy banana",
+                                           &callback));
+    EXPECT_TRUE(gradient_checking_cost_function->Evaluate(
+        &parameters[0], &residual, &jacobians[0]));
     EXPECT_FALSE(callback.gradient_error_detected());
   }
 
@@ -279,7 +280,7 @@
 };
 
 // Trivial cost function that accepts two arguments.
-class BinaryCostFunction: public CostFunction {
+class BinaryCostFunction : public CostFunction {
  public:
   BinaryCostFunction(int num_residuals,
                      int32_t parameter_block1_size,
@@ -300,7 +301,7 @@
 };
 
 // Trivial cost function that accepts three arguments.
-class TernaryCostFunction: public CostFunction {
+class TernaryCostFunction : public CostFunction {
  public:
   TernaryCostFunction(int num_residuals,
                       int32_t parameter_block1_size,
@@ -324,7 +325,7 @@
 
 // Verify that the two ParameterBlocks are formed from the same user
 // array and have the same LocalParameterization object.
-static void ParameterBlocksAreEquivalent(const ParameterBlock*  left,
+static void ParameterBlocksAreEquivalent(const ParameterBlock* left,
                                          const ParameterBlock* right) {
   CHECK(left != nullptr);
   CHECK(right != nullptr);
@@ -349,8 +350,10 @@
   problem_impl.SetParameterBlockConstant(y);
   problem_impl.AddParameterBlock(z, 5);
   problem_impl.AddParameterBlock(w, 4, new QuaternionParameterization);
-  problem_impl.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
-  problem_impl.AddResidualBlock(new BinaryCostFunction(6, 5, 4) ,
+  // clang-format off
+  problem_impl.AddResidualBlock(new UnaryCostFunction(2, 3),
+                                NULL, x);
+  problem_impl.AddResidualBlock(new BinaryCostFunction(6, 5, 4),
                                 NULL, z, y);
   problem_impl.AddResidualBlock(new BinaryCostFunction(3, 3, 5),
                                 new TrivialLoss, x, z);
@@ -358,6 +361,7 @@
                                 NULL, z, x);
   problem_impl.AddResidualBlock(new TernaryCostFunction(1, 5, 3, 4),
                                 NULL, z, x, y);
+  // clang-format on
 
   GradientCheckingIterationCallback callback;
   std::unique_ptr<ProblemImpl> gradient_checking_problem_impl(
@@ -392,8 +396,7 @@
 
   for (int i = 0; i < program.residual_blocks().size(); ++i) {
     // Compare the sizes of the two ResidualBlocks.
-    const ResidualBlock* original_residual_block =
-        program.residual_blocks()[i];
+    const ResidualBlock* original_residual_block = program.residual_blocks()[i];
     const ResidualBlock* new_residual_block =
         gradient_checking_program.residual_blocks()[i];
     EXPECT_EQ(original_residual_block->NumParameterBlocks(),
@@ -412,15 +415,14 @@
   }
 }
 
-
 TEST(GradientCheckingProblemImpl, ConstrainedProblemBoundsArePropagated) {
   // Parameter blocks with arbitrarily chosen initial values.
   double x[] = {1.0, 2.0, 3.0};
   ProblemImpl problem_impl;
   problem_impl.AddParameterBlock(x, 3);
   problem_impl.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
-  problem_impl.SetParameterLowerBound(x,0,0.9);
-  problem_impl.SetParameterUpperBound(x,1,2.5);
+  problem_impl.SetParameterLowerBound(x, 0, 0.9);
+  problem_impl.SetParameterUpperBound(x, 1, 2.5);
 
   GradientCheckingIterationCallback callback;
   std::unique_ptr<ProblemImpl> gradient_checking_problem_impl(
diff --git a/internal/ceres/gradient_problem.cc b/internal/ceres/gradient_problem.cc
index 4ebd3e6..ba33fbc 100644
--- a/internal/ceres/gradient_problem.cc
+++ b/internal/ceres/gradient_problem.cc
@@ -29,6 +29,7 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/gradient_problem.h"
+
 #include "ceres/local_parameterization.h"
 #include "glog/logging.h"
 
@@ -38,14 +39,13 @@
     : function_(function),
       parameterization_(
           new IdentityParameterization(function_->NumParameters())),
-      scratch_(new double[function_->NumParameters()]) {
-}
+      scratch_(new double[function_->NumParameters()]) {}
 
 GradientProblem::GradientProblem(FirstOrderFunction* function,
                                  LocalParameterization* parameterization)
-      : function_(function),
-        parameterization_(parameterization),
-        scratch_(new double[function_->NumParameters()]) {
+    : function_(function),
+      parameterization_(parameterization),
+      scratch_(new double[function_->NumParameters()]) {
   CHECK_EQ(function_->NumParameters(), parameterization_->GlobalSize());
 }
 
@@ -57,7 +57,6 @@
   return parameterization_->LocalSize();
 }
 
-
 bool GradientProblem::Evaluate(const double* parameters,
                                double* cost,
                                double* gradient) const {
@@ -66,10 +65,8 @@
   }
 
   return (function_->Evaluate(parameters, cost, scratch_.get()) &&
-          parameterization_->MultiplyByJacobian(parameters,
-                                                1,
-                                                scratch_.get(),
-                                                gradient));
+          parameterization_->MultiplyByJacobian(
+              parameters, 1, scratch_.get(), gradient));
 }
 
 bool GradientProblem::Plus(const double* x,
diff --git a/internal/ceres/gradient_problem_evaluator.h b/internal/ceres/gradient_problem_evaluator.h
index c5ad1d7..d224dbe 100644
--- a/internal/ceres/gradient_problem_evaluator.h
+++ b/internal/ceres/gradient_problem_evaluator.h
@@ -76,9 +76,7 @@
     return problem_.Plus(state, delta, state_plus_delta);
   }
 
-  int NumParameters() const final {
-    return problem_.NumParameters();
-  }
+  int NumParameters() const final { return problem_.NumParameters(); }
 
   int NumEffectiveParameters() const final {
     return problem_.NumLocalParameters();
diff --git a/internal/ceres/gradient_problem_solver.cc b/internal/ceres/gradient_problem_solver.cc
index 1639e30..b72fad9 100644
--- a/internal/ceres/gradient_problem_solver.cc
+++ b/internal/ceres/gradient_problem_solver.cc
@@ -31,6 +31,7 @@
 #include "ceres/gradient_problem_solver.h"
 
 #include <memory>
+
 #include "ceres/callbacks.h"
 #include "ceres/gradient_problem.h"
 #include "ceres/gradient_problem_evaluator.h"
@@ -45,8 +46,8 @@
 #include "ceres/wall_time.h"
 
 namespace ceres {
-using internal::StringPrintf;
 using internal::StringAppendF;
+using internal::StringPrintf;
 using std::string;
 
 namespace {
@@ -83,7 +84,6 @@
 #undef COPY_OPTION
 }
 
-
 }  // namespace
 
 bool GradientProblemSolver::Options::IsValid(std::string* error) const {
@@ -92,8 +92,7 @@
   return solver_options.IsValid(error);
 }
 
-GradientProblemSolver::~GradientProblemSolver() {
-}
+GradientProblemSolver::~GradientProblemSolver() {}
 
 void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options,
                                   const GradientProblem& problem,
@@ -111,6 +110,7 @@
 
   CHECK(summary != nullptr);
   *summary = Summary();
+  // clang-format off
   summary->num_parameters                    = problem.NumParameters();
   summary->num_local_parameters              = problem.NumLocalParameters();
   summary->line_search_direction_type        = options.line_search_direction_type;         //  NOLINT
@@ -118,6 +118,7 @@
   summary->line_search_type                  = options.line_search_type;
   summary->max_lbfgs_rank                    = options.max_lbfgs_rank;
   summary->nonlinear_conjugate_gradient_type = options.nonlinear_conjugate_gradient_type;  //  NOLINT
+  // clang-format on
 
   // Check validity
   if (!options.IsValid(&summary->message)) {
@@ -163,11 +164,13 @@
 
   minimizer->Minimize(minimizer_options, solution.data(), &solver_summary);
 
+  // clang-format off
   summary->termination_type = solver_summary.termination_type;
   summary->message          = solver_summary.message;
   summary->initial_cost     = solver_summary.initial_cost;
   summary->final_cost       = solver_summary.final_cost;
   summary->iterations       = solver_summary.iterations;
+  // clang-format on
   summary->line_search_polynomial_minimization_time_in_seconds =
       solver_summary.line_search_polynomial_minimization_time_in_seconds;
 
@@ -200,15 +203,16 @@
 }
 
 string GradientProblemSolver::Summary::BriefReport() const {
-  return StringPrintf("Ceres GradientProblemSolver Report: "
-                      "Iterations: %d, "
-                      "Initial cost: %e, "
-                      "Final cost: %e, "
-                      "Termination: %s",
-                      static_cast<int>(iterations.size()),
-                      initial_cost,
-                      final_cost,
-                      TerminationTypeToString(termination_type));
+  return StringPrintf(
+      "Ceres GradientProblemSolver Report: "
+      "Iterations: %d, "
+      "Initial cost: %e, "
+      "Final cost: %e, "
+      "Termination: %s",
+      static_cast<int>(iterations.size()),
+      initial_cost,
+      final_cost,
+      TerminationTypeToString(termination_type));
 }
 
 string GradientProblemSolver::Summary::FullReport() const {
@@ -218,60 +222,63 @@
 
   StringAppendF(&report, "Parameters          % 25d\n", num_parameters);
   if (num_local_parameters != num_parameters) {
-    StringAppendF(&report, "Local parameters    % 25d\n",
-                  num_local_parameters);
+    StringAppendF(&report, "Local parameters    % 25d\n", num_local_parameters);
   }
 
   string line_search_direction_string;
   if (line_search_direction_type == LBFGS) {
     line_search_direction_string = StringPrintf("LBFGS (%d)", max_lbfgs_rank);
   } else if (line_search_direction_type == NONLINEAR_CONJUGATE_GRADIENT) {
-    line_search_direction_string =
-        NonlinearConjugateGradientTypeToString(
-            nonlinear_conjugate_gradient_type);
+    line_search_direction_string = NonlinearConjugateGradientTypeToString(
+        nonlinear_conjugate_gradient_type);
   } else {
     line_search_direction_string =
         LineSearchDirectionTypeToString(line_search_direction_type);
   }
 
-  StringAppendF(&report, "Line search direction     %19s\n",
+  StringAppendF(&report,
+                "Line search direction     %19s\n",
                 line_search_direction_string.c_str());
 
-  const string line_search_type_string =
-      StringPrintf("%s %s",
-                   LineSearchInterpolationTypeToString(
-                       line_search_interpolation_type),
-                   LineSearchTypeToString(line_search_type));
-  StringAppendF(&report, "Line search type          %19s\n",
+  const string line_search_type_string = StringPrintf(
+      "%s %s",
+      LineSearchInterpolationTypeToString(line_search_interpolation_type),
+      LineSearchTypeToString(line_search_type));
+  StringAppendF(&report,
+                "Line search type          %19s\n",
                 line_search_type_string.c_str());
   StringAppendF(&report, "\n");
 
   StringAppendF(&report, "\nCost:\n");
   StringAppendF(&report, "Initial        % 30e\n", initial_cost);
-  if (termination_type != FAILURE &&
-      termination_type != USER_FAILURE) {
+  if (termination_type != FAILURE && termination_type != USER_FAILURE) {
     StringAppendF(&report, "Final          % 30e\n", final_cost);
-    StringAppendF(&report, "Change         % 30e\n",
-                  initial_cost - final_cost);
+    StringAppendF(&report, "Change         % 30e\n", initial_cost - final_cost);
   }
 
-  StringAppendF(&report, "\nMinimizer iterations         % 16d\n",
+  StringAppendF(&report,
+                "\nMinimizer iterations         % 16d\n",
                 static_cast<int>(iterations.size()));
 
   StringAppendF(&report, "\nTime (in seconds):\n");
-  StringAppendF(&report, "\n  Cost evaluation     %23.6f (%d)\n",
+  StringAppendF(&report,
+                "\n  Cost evaluation     %23.6f (%d)\n",
                 cost_evaluation_time_in_seconds,
                 num_cost_evaluations);
-  StringAppendF(&report, "  Gradient & cost evaluation %16.6f (%d)\n",
+  StringAppendF(&report,
+                "  Gradient & cost evaluation %16.6f (%d)\n",
                 gradient_evaluation_time_in_seconds,
                 num_gradient_evaluations);
-  StringAppendF(&report, "  Polynomial minimization   %17.6f\n",
+  StringAppendF(&report,
+                "  Polynomial minimization   %17.6f\n",
                 line_search_polynomial_minimization_time_in_seconds);
-  StringAppendF(&report, "Total               %25.6f\n\n",
-                total_time_in_seconds);
+  StringAppendF(
+      &report, "Total               %25.6f\n\n", total_time_in_seconds);
 
-  StringAppendF(&report, "Termination:        %25s (%s)\n",
-                TerminationTypeToString(termination_type), message.c_str());
+  StringAppendF(&report,
+                "Termination:        %25s (%s)\n",
+                TerminationTypeToString(termination_type),
+                message.c_str());
   return report;
 }
 
diff --git a/internal/ceres/gradient_problem_solver_test.cc b/internal/ceres/gradient_problem_solver_test.cc
index 1a08c48..f01d206 100644
--- a/internal/ceres/gradient_problem_solver_test.cc
+++ b/internal/ceres/gradient_problem_solver_test.cc
@@ -28,9 +28,9 @@
 //
 // Author: strandmark@google.com (Petter Strandmark)
 
-#include "ceres/gradient_problem.h"
 #include "ceres/gradient_problem_solver.h"
 
+#include "ceres/gradient_problem.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -89,18 +89,17 @@
 };
 
 struct RememberingCallback : public IterationCallback {
-  explicit RememberingCallback(double *x) : calls(0), x(x) {}
+  explicit RememberingCallback(double* x) : calls(0), x(x) {}
   virtual ~RememberingCallback() {}
   CallbackReturnType operator()(const IterationSummary& summary) final {
     x_values.push_back(*x);
     return SOLVER_CONTINUE;
   }
   int calls;
-  double *x;
+  double* x;
   std::vector<double> x_values;
 };
 
-
 TEST(Solver, UpdateStateEveryIterationOption) {
   double x = 50.0;
   const double original_x = x;
diff --git a/internal/ceres/gradient_problem_test.cc b/internal/ceres/gradient_problem_test.cc
index 640cf5f..8934138 100644
--- a/internal/ceres/gradient_problem_test.cc
+++ b/internal/ceres/gradient_problem_test.cc
@@ -65,9 +65,7 @@
 
 TEST(GradientProblem, TakesOwnershipOfFirstOrderFunction) {
   bool is_destructed = false;
-  {
-    ceres::GradientProblem problem(new QuadraticTestFunction(&is_destructed));
-  }
+  { ceres::GradientProblem problem(new QuadraticTestFunction(&is_destructed)); }
   EXPECT_TRUE(is_destructed);
 }
 
diff --git a/internal/ceres/graph.h b/internal/ceres/graph.h
index 4e1fd81..9b26158 100644
--- a/internal/ceres/graph.h
+++ b/internal/ceres/graph.h
@@ -32,9 +32,10 @@
 #define CERES_INTERNAL_GRAPH_H_
 
 #include <limits>
-#include <unordered_set>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
+
 #include "ceres/map_util.h"
 #include "ceres/pair_hash.h"
 #include "ceres/types.h"
@@ -93,9 +94,7 @@
     return FindOrDie(edges_, vertex);
   }
 
-  const std::unordered_set<Vertex>& vertices() const {
-    return vertices_;
-  }
+  const std::unordered_set<Vertex>& vertices() const { return vertices_; }
 
  private:
   std::unordered_set<Vertex> vertices_;
@@ -121,9 +120,7 @@
 
   // Uses weight = 1.0. If vertex already exists, its weight is set to
   // 1.0.
-  void AddVertex(const Vertex& vertex) {
-    AddVertex(vertex, 1.0);
-  }
+  void AddVertex(const Vertex& vertex) { AddVertex(vertex, 1.0); }
 
   bool RemoveVertex(const Vertex& vertex) {
     if (vertices_.find(vertex) == vertices_.end()) {
@@ -184,11 +181,11 @@
   // the edge weight is zero.
   double EdgeWeight(const Vertex& vertex1, const Vertex& vertex2) const {
     if (vertex1 < vertex2) {
-      return FindWithDefault(edge_weights_,
-                             std::make_pair(vertex1, vertex2), 0.0);
+      return FindWithDefault(
+          edge_weights_, std::make_pair(vertex1, vertex2), 0.0);
     } else {
-      return FindWithDefault(edge_weights_,
-                             std::make_pair(vertex2, vertex1), 0.0);
+      return FindWithDefault(
+          edge_weights_, std::make_pair(vertex2, vertex1), 0.0);
     }
   }
 
@@ -198,9 +195,7 @@
     return FindOrDie(edges_, vertex);
   }
 
-  const std::unordered_set<Vertex>& vertices() const {
-    return vertices_;
-  }
+  const std::unordered_set<Vertex>& vertices() const { return vertices_; }
 
   static double InvalidWeight() {
     return std::numeric_limits<double>::quiet_NaN();
diff --git a/internal/ceres/graph_algorithms.h b/internal/ceres/graph_algorithms.h
index b062931..7d63b33 100644
--- a/internal/ceres/graph_algorithms.h
+++ b/internal/ceres/graph_algorithms.h
@@ -36,8 +36,9 @@
 #include <algorithm>
 #include <unordered_map>
 #include <unordered_set>
-#include <vector>
 #include <utility>
+#include <vector>
+
 #include "ceres/graph.h"
 #include "ceres/wall_time.h"
 #include "glog/logging.h"
@@ -50,8 +51,7 @@
 template <typename Vertex>
 class VertexTotalOrdering {
  public:
-  explicit VertexTotalOrdering(const Graph<Vertex>& graph)
-      : graph_(graph) {}
+  explicit VertexTotalOrdering(const Graph<Vertex>& graph) : graph_(graph) {}
 
   bool operator()(const Vertex& lhs, const Vertex& rhs) const {
     if (graph_.Neighbors(lhs).size() == graph_.Neighbors(rhs).size()) {
@@ -67,8 +67,7 @@
 template <typename Vertex>
 class VertexDegreeLessThan {
  public:
-  explicit VertexDegreeLessThan(const Graph<Vertex>& graph)
-      : graph_(graph) {}
+  explicit VertexDegreeLessThan(const Graph<Vertex>& graph) : graph_(graph) {}
 
   bool operator()(const Vertex& lhs, const Vertex& rhs) const {
     return graph_.Neighbors(lhs).size() < graph_.Neighbors(rhs).size();
@@ -177,8 +176,9 @@
 
   std::vector<Vertex> vertex_queue(*ordering);
 
-  std::stable_sort(vertex_queue.begin(), vertex_queue.end(),
-                  VertexDegreeLessThan<Vertex>(graph));
+  std::stable_sort(vertex_queue.begin(),
+                   vertex_queue.end(),
+                   VertexDegreeLessThan<Vertex>(graph));
 
   // Mark all vertices white.
   std::unordered_map<Vertex, char> vertex_color;
@@ -257,8 +257,8 @@
 // spanning forest, or a collection of linear paths that span the
 // graph G.
 template <typename Vertex>
-WeightedGraph<Vertex>*
-Degree2MaximumSpanningForest(const WeightedGraph<Vertex>& graph) {
+WeightedGraph<Vertex>* Degree2MaximumSpanningForest(
+    const WeightedGraph<Vertex>& graph) {
   // Array of edges sorted in decreasing order of their weights.
   std::vector<std::pair<double, std::pair<Vertex, Vertex>>> weighted_edges;
   WeightedGraph<Vertex>* forest = new WeightedGraph<Vertex>();
@@ -294,7 +294,7 @@
 
   // Greedily add edges to the spanning tree/forest as long as they do
   // not violate the degree/cycle constraint.
-  for (int i =0; i < weighted_edges.size(); ++i) {
+  for (int i = 0; i < weighted_edges.size(); ++i) {
     const std::pair<Vertex, Vertex>& edge = weighted_edges[i].second;
     const Vertex vertex1 = edge.first;
     const Vertex vertex2 = edge.second;
diff --git a/internal/ceres/graph_algorithms_test.cc b/internal/ceres/graph_algorithms_test.cc
index 2aef327..d5dd02e 100644
--- a/internal/ceres/graph_algorithms_test.cc
+++ b/internal/ceres/graph_algorithms_test.cc
@@ -111,8 +111,8 @@
   graph.AddEdge(0, 1, 0.5);
   graph.AddEdge(1, 0, 0.5);
 
-  std::unique_ptr<WeightedGraph<int> > forest(
-					      Degree2MaximumSpanningForest(graph));
+  std::unique_ptr<WeightedGraph<int>> forest(
+      Degree2MaximumSpanningForest(graph));
 
   const std::unordered_set<int>& vertices = forest->vertices();
   EXPECT_EQ(vertices.size(), 2);
@@ -135,7 +135,8 @@
   graph.AddEdge(0, 3, 3.0);
   graph.AddEdge(0, 4, 4.0);
 
-  std::unique_ptr<WeightedGraph<int> > forest(Degree2MaximumSpanningForest(graph));
+  std::unique_ptr<WeightedGraph<int>> forest(
+      Degree2MaximumSpanningForest(graph));
   const std::unordered_set<int>& vertices = forest->vertices();
   EXPECT_EQ(vertices.size(), 5);
 
@@ -200,7 +201,6 @@
   }
 }
 
-
 TEST(StableIndependentSet, BreakTies) {
   Graph<int> graph;
   graph.AddVertex(0);
diff --git a/internal/ceres/graph_test.cc b/internal/ceres/graph_test.cc
index 8f05475..2154a06 100644
--- a/internal/ceres/graph_test.cc
+++ b/internal/ceres/graph_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/graph.h"
 
 #include <unordered_set>
+
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/gtest/.clang-format b/internal/ceres/gtest/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/gtest/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/householder_vector_test.cc b/internal/ceres/householder_vector_test.cc
index 10b3e88..6f3b172 100644
--- a/internal/ceres/householder_vector_test.cc
+++ b/internal/ceres/householder_vector_test.cc
@@ -29,6 +29,7 @@
 // Author: vitus@google.com (Michael Vitus)
 
 #include "ceres/internal/householder_vector.h"
+
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 #include "gtest/gtest.h"
diff --git a/internal/ceres/implicit_schur_complement.cc b/internal/ceres/implicit_schur_complement.cc
index bf680d1..f2196d4 100644
--- a/internal/ceres/implicit_schur_complement.cc
+++ b/internal/ceres/implicit_schur_complement.cc
@@ -43,13 +43,9 @@
 
 ImplicitSchurComplement::ImplicitSchurComplement(
     const LinearSolver::Options& options)
-    : options_(options),
-      D_(NULL),
-      b_(NULL) {
-}
+    : options_(options), D_(NULL), b_(NULL) {}
 
-ImplicitSchurComplement::~ImplicitSchurComplement() {
-}
+ImplicitSchurComplement::~ImplicitSchurComplement() {}
 
 void ImplicitSchurComplement::Init(const BlockSparseMatrix& A,
                                    const double* D,
@@ -88,7 +84,7 @@
   // the block diagonals and invert them.
   AddDiagonalAndInvert(D_, block_diagonal_EtE_inverse_.get());
   if (options_.preconditioner_type == JACOBI) {
-    AddDiagonalAndInvert((D_ ==  NULL) ? NULL : D_ + A_->num_cols_e(),
+    AddDiagonalAndInvert((D_ == NULL) ? NULL : D_ + A_->num_cols_e(),
                          block_diagonal_FtF_inverse_.get());
   }
 
@@ -125,8 +121,8 @@
   if (D_ != NULL) {
     ConstVectorRef Dref(D_ + A_->num_cols_e(), num_cols());
     VectorRef(y, num_cols()) =
-        (Dref.array().square() *
-         ConstVectorRef(x, num_cols()).array()).matrix();
+        (Dref.array().square() * ConstVectorRef(x, num_cols()).array())
+            .matrix();
   } else {
     VectorRef(y, num_cols()).setZero();
   }
@@ -139,8 +135,7 @@
 // entries D, add them to the diagonal of the matrix and compute the
 // inverse of each diagonal block.
 void ImplicitSchurComplement::AddDiagonalAndInvert(
-    const double* D,
-    BlockSparseMatrix* block_diagonal) {
+    const double* D, BlockSparseMatrix* block_diagonal) {
   const CompressedRowBlockStructure* block_diagonal_structure =
       block_diagonal->block_structure();
   for (int r = 0; r < block_diagonal_structure->rows.size(); ++r) {
@@ -148,17 +143,16 @@
     const int row_block_size = block_diagonal_structure->rows[r].block.size;
     const Cell& cell = block_diagonal_structure->rows[r].cells[0];
     MatrixRef m(block_diagonal->mutable_values() + cell.position,
-                row_block_size, row_block_size);
+                row_block_size,
+                row_block_size);
 
     if (D != NULL) {
       ConstVectorRef d(D + row_block_pos, row_block_size);
       m += d.array().square().matrix().asDiagonal();
     }
 
-    m = m
-        .selfadjointView<Eigen::Upper>()
-        .llt()
-        .solve(Matrix::Identity(row_block_size, row_block_size));
+    m = m.selfadjointView<Eigen::Upper>().llt().solve(
+        Matrix::Identity(row_block_size, row_block_size));
   }
 }
 
@@ -167,7 +161,7 @@
 void ImplicitSchurComplement::BackSubstitute(const double* x, double* y) {
   const int num_cols_e = A_->num_cols_e();
   const int num_cols_f = A_->num_cols_f();
-  const int num_cols =  A_->num_cols();
+  const int num_cols = A_->num_cols();
   const int num_rows = A_->num_rows();
 
   // y1 = F x
@@ -190,7 +184,7 @@
   // computed via back substitution. The second block of variables
   // corresponds to the Schur complement system, so we just copy those
   // values from the solution to the Schur complement.
-  VectorRef(y + num_cols_e, num_cols_f) =  ConstVectorRef(x, num_cols_f);
+  VectorRef(y + num_cols_e, num_cols_f) = ConstVectorRef(x, num_cols_f);
 }
 
 // Compute the RHS of the Schur complement system.
diff --git a/internal/ceres/implicit_schur_complement.h b/internal/ceres/implicit_schur_complement.h
index f4ddf72..cc22f24 100644
--- a/internal/ceres/implicit_schur_complement.h
+++ b/internal/ceres/implicit_schur_complement.h
@@ -35,10 +35,11 @@
 #define CERES_INTERNAL_IMPLICIT_SCHUR_COMPLEMENT_H_
 
 #include <memory>
+
+#include "ceres/internal/eigen.h"
 #include "ceres/linear_operator.h"
 #include "ceres/linear_solver.h"
 #include "ceres/partitioned_matrix_view.h"
-#include "ceres/internal/eigen.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -129,7 +130,7 @@
 
   int num_rows() const final { return A_->num_cols_f(); }
   int num_cols() const final { return A_->num_cols_f(); }
-  const Vector& rhs()    const { return rhs_;             }
+  const Vector& rhs() const { return rhs_; }
 
   const BlockSparseMatrix* block_diagonal_EtE_inverse() const {
     return block_diagonal_EtE_inverse_.get();
diff --git a/internal/ceres/implicit_schur_complement_test.cc b/internal/ceres/implicit_schur_complement_test.cc
index 4e3a598..b6d886f 100644
--- a/internal/ceres/implicit_schur_complement_test.cc
+++ b/internal/ceres/implicit_schur_complement_test.cc
@@ -32,6 +32,7 @@
 
 #include <cstddef>
 #include <memory>
+
 #include "Eigen/Dense"
 #include "ceres/block_random_access_dense_matrix.h"
 #include "ceres/block_sparse_matrix.h"
@@ -54,7 +55,7 @@
 const double kEpsilon = 1e-14;
 
 class ImplicitSchurComplementTest : public ::testing::Test {
- protected :
+ protected:
   void SetUp() final {
     std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(2));
@@ -115,8 +116,11 @@
     VectorRef schur_solution(solution->data() + num_cols_ - num_schur_rows,
                              num_schur_rows);
     schur_solution = lhs->selfadjointView<Eigen::Upper>().llt().solve(*rhs);
-    eliminator->BackSubstitute(BlockSparseMatrixData(*A_), b_.get(), D,
-                               schur_solution.data(), solution->data());
+    eliminator->BackSubstitute(BlockSparseMatrixData(*A_),
+                               b_.get(),
+                               D,
+                               schur_solution.data(),
+                               solution->data());
   }
 
   AssertionResult TestImplicitSchurComplement(double* D) {
@@ -150,18 +154,18 @@
       // the explicit schur complement.
       if ((y - z).norm() > kEpsilon) {
         return testing::AssertionFailure()
-            << "Explicit and Implicit SchurComplements differ in "
-            << "column " << i << ". explicit: " << y.transpose()
-            << " implicit: " << z.transpose();
+               << "Explicit and Implicit SchurComplements differ in "
+               << "column " << i << ". explicit: " << y.transpose()
+               << " implicit: " << z.transpose();
       }
     }
 
     // Compare the rhs of the reduced linear system
     if ((isc.rhs() - rhs).norm() > kEpsilon) {
       return testing::AssertionFailure()
-            << "Explicit and Implicit SchurComplements differ in "
-            << "rhs. explicit: " << rhs.transpose()
-            << " implicit: " << isc.rhs().transpose();
+             << "Explicit and Implicit SchurComplements differ in "
+             << "rhs. explicit: " << rhs.transpose()
+             << " implicit: " << isc.rhs().transpose();
     }
 
     // Reference solution to the f_block.
@@ -174,9 +178,9 @@
     isc.BackSubstitute(reference_f_sol.data(), sol.data());
     if ((sol - reference_solution).norm() > kEpsilon) {
       return testing::AssertionFailure()
-          << "Explicit and Implicit SchurComplements solutions differ. "
-          << "explicit: " << reference_solution.transpose()
-          << " implicit: " << sol.transpose();
+             << "Explicit and Implicit SchurComplements solutions differ. "
+             << "explicit: " << reference_solution.transpose()
+             << " implicit: " << sol.transpose();
     }
 
     return testing::AssertionSuccess();
diff --git a/internal/ceres/inner_product_computer.cc b/internal/ceres/inner_product_computer.cc
index 2bf8836..ef38b7b 100644
--- a/internal/ceres/inner_product_computer.cc
+++ b/internal/ceres/inner_product_computer.cc
@@ -31,12 +31,12 @@
 #include "ceres/inner_product_computer.h"
 
 #include <algorithm>
+
 #include "ceres/small_blas.h"
 
 namespace ceres {
 namespace internal {
 
-
 // Create the CompressedRowSparseMatrix matrix that will contain the
 // inner product.
 //
@@ -297,7 +297,7 @@
       const Cell& cell1 = m_row.cells[c1];
       const int c1_size = bs->cols[cell1.block_id].size;
       const int row_nnz = rows[bs->cols[cell1.block_id].position + 1] -
-          rows[bs->cols[cell1.block_id].position];
+                          rows[bs->cols[cell1.block_id].position];
 
       int c2_begin, c2_end;
       if (storage_type == CompressedRowSparseMatrix::LOWER_TRIANGULAR) {
@@ -311,6 +311,7 @@
       for (int c2 = c2_begin; c2 < c2_end; ++c2, ++cursor) {
         const Cell& cell2 = m_row.cells[c2];
         const int c2_size = bs->cols[cell2.block_id].size;
+        // clang-format off
         MatrixTransposeMatrixMultiply<Eigen::Dynamic, Eigen::Dynamic,
                                       Eigen::Dynamic, Eigen::Dynamic, 1>(
                                           m_values + cell1.position,
@@ -319,6 +320,7 @@
                                           m_row.block.size, c2_size,
                                           values + result_offsets_[cursor],
                                           0, 0, c1_size, row_nnz);
+        // clang-format on
       }
     }
   }
diff --git a/internal/ceres/inner_product_computer_test.cc b/internal/ceres/inner_product_computer_test.cc
index 31cd829..ac564f4 100644
--- a/internal/ceres/inner_product_computer_test.cc
+++ b/internal/ceres/inner_product_computer_test.cc
@@ -32,6 +32,8 @@
 
 #include <memory>
 #include <numeric>
+
+#include "Eigen/SparseCore"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/random.h"
@@ -39,8 +41,6 @@
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
-#include "Eigen/SparseCore"
-
 namespace ceres {
 namespace internal {
 
@@ -134,7 +134,6 @@
         inner_product_computer.reset(InnerProductComputer::Create(
             *random_matrix, CompressedRowSparseMatrix::UPPER_TRIANGULAR));
         COMPUTE_AND_COMPARE;
-
       }
     }
   }
@@ -215,7 +214,6 @@
             end_row_block,
             CompressedRowSparseMatrix::UPPER_TRIANGULAR));
         COMPUTE_AND_COMPARE;
-
       }
     }
   }
diff --git a/internal/ceres/invert_psd_matrix.h b/internal/ceres/invert_psd_matrix.h
index 21d301a..ac8808b 100644
--- a/internal/ceres/invert_psd_matrix.h
+++ b/internal/ceres/invert_psd_matrix.h
@@ -31,9 +31,9 @@
 #ifndef CERES_INTERNAL_INVERT_PSD_MATRIX_H_
 #define CERES_INTERNAL_INVERT_PSD_MATRIX_H_
 
+#include "Eigen/Dense"
 #include "ceres/internal/eigen.h"
 #include "glog/logging.h"
-#include "Eigen/Dense"
 
 namespace ceres {
 namespace internal {
@@ -76,4 +76,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_INTERNAL_INVERT_PSD_MATRIX_H_
+#endif  // CERES_INTERNAL_INVERT_PSD_MATRIX_H_
diff --git a/internal/ceres/is_close.cc b/internal/ceres/is_close.cc
index a91a174..0becf55 100644
--- a/internal/ceres/is_close.cc
+++ b/internal/ceres/is_close.cc
@@ -35,9 +35,11 @@
 
 namespace ceres {
 namespace internal {
-bool IsClose(double x, double y, double relative_precision,
-             double *relative_error,
-             double *absolute_error) {
+bool IsClose(double x,
+             double y,
+             double relative_precision,
+             double* relative_error,
+             double* absolute_error) {
   double local_absolute_error;
   double local_relative_error;
   if (!absolute_error) {
diff --git a/internal/ceres/is_close.h b/internal/ceres/is_close.h
index 7789448..d0b5e6b 100644
--- a/internal/ceres/is_close.h
+++ b/internal/ceres/is_close.h
@@ -43,8 +43,8 @@
 bool IsClose(double x,
              double y,
              double relative_precision,
-             double *relative_error,
-             double *absolute_error);
+             double* relative_error,
+             double* absolute_error);
 }  // namespace internal
 }  // namespace ceres
 
diff --git a/internal/ceres/is_close_test.cc b/internal/ceres/is_close_test.cc
index 8f7aaba..12d6236 100644
--- a/internal/ceres/is_close_test.cc
+++ b/internal/ceres/is_close_test.cc
@@ -31,6 +31,7 @@
 // This file contains tests for the IsClose function.
 
 #include "ceres/is_close.h"
+
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/iterative_refiner.cc b/internal/ceres/iterative_refiner.cc
index fb0e45b..5f0bfdd 100644
--- a/internal/ceres/iterative_refiner.cc
+++ b/internal/ceres/iterative_refiner.cc
@@ -28,9 +28,10 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-#include <string>
 #include "ceres/iterative_refiner.h"
 
+#include <string>
+
 #include "Eigen/Core"
 #include "ceres/sparse_cholesky.h"
 #include "ceres/sparse_matrix.h"
diff --git a/internal/ceres/iterative_refiner.h b/internal/ceres/iterative_refiner.h
index f969935..b2c39b5 100644
--- a/internal/ceres/iterative_refiner.h
+++ b/internal/ceres/iterative_refiner.h
@@ -32,7 +32,10 @@
 #define CERES_INTERNAL_ITERATIVE_REFINER_H_
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
+
 #include "ceres/internal/eigen.h"
 
 namespace ceres {
diff --git a/internal/ceres/iterative_refiner_test.cc b/internal/ceres/iterative_refiner_test.cc
index c474ede..49887c6 100644
--- a/internal/ceres/iterative_refiner_test.cc
+++ b/internal/ceres/iterative_refiner_test.cc
@@ -93,8 +93,8 @@
   virtual ~FakeSparseCholesky() {}
 
   LinearSolverTerminationType Solve(const double* rhs_ptr,
-                                            double* solution_ptr,
-                                            std::string* message) final {
+                                    double* solution_ptr,
+                                    std::string* message) final {
     const int num_cols = lhs_.cols();
     VectorRef solution(solution_ptr, num_cols);
     ConstVectorRef rhs(rhs_ptr, num_cols);
@@ -106,14 +106,14 @@
   CompressedRowSparseMatrix::StorageType StorageType() const final
       DO_NOT_CALL_WITH_RETURN(CompressedRowSparseMatrix::UPPER_TRIANGULAR);
   LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
-                                                std::string* message) final
+                                        std::string* message) final
       DO_NOT_CALL_WITH_RETURN(LINEAR_SOLVER_FAILURE);
 
-  LinearSolverTerminationType FactorAndSolve(
-      CompressedRowSparseMatrix* lhs,
-      const double* rhs,
-      double* solution,
-      std::string* message) final DO_NOT_CALL_WITH_RETURN(LINEAR_SOLVER_FAILURE);
+  LinearSolverTerminationType FactorAndSolve(CompressedRowSparseMatrix* lhs,
+                                             const double* rhs,
+                                             double* solution,
+                                             std::string* message) final
+      DO_NOT_CALL_WITH_RETURN(LINEAR_SOLVER_FAILURE);
 
  private:
   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> lhs_;
diff --git a/internal/ceres/iterative_schur_complement_solver.cc b/internal/ceres/iterative_schur_complement_solver.cc
index 6076c38..143df5e 100644
--- a/internal/ceres/iterative_schur_complement_solver.cc
+++ b/internal/ceres/iterative_schur_complement_solver.cc
@@ -55,8 +55,7 @@
 
 IterativeSchurComplementSolver::IterativeSchurComplementSolver(
     const LinearSolver::Options& options)
-    : options_(options) {
-}
+    : options_(options) {}
 
 IterativeSchurComplementSolver::~IterativeSchurComplementSolver() {}
 
diff --git a/internal/ceres/iterative_schur_complement_solver.h b/internal/ceres/iterative_schur_complement_solver.h
index 9aed94f..ca002d2 100644
--- a/internal/ceres/iterative_schur_complement_solver.h
+++ b/internal/ceres/iterative_schur_complement_solver.h
@@ -32,8 +32,9 @@
 #define CERES_INTERNAL_ITERATIVE_SCHUR_COMPLEMENT_SOLVER_H_
 
 #include <memory>
-#include "ceres/linear_solver.h"
+
 #include "ceres/internal/eigen.h"
+#include "ceres/linear_solver.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -70,17 +71,17 @@
 class IterativeSchurComplementSolver : public BlockSparseMatrixSolver {
  public:
   explicit IterativeSchurComplementSolver(const LinearSolver::Options& options);
-  IterativeSchurComplementSolver(const IterativeSchurComplementSolver&) = delete;
+  IterativeSchurComplementSolver(const IterativeSchurComplementSolver&) =
+      delete;
   void operator=(const IterativeSchurComplementSolver&) = delete;
 
   virtual ~IterativeSchurComplementSolver();
 
  private:
-  LinearSolver::Summary SolveImpl(
-      BlockSparseMatrix* A,
-      const double* b,
-      const LinearSolver::PerSolveOptions& options,
-      double* x) final;
+  LinearSolver::Summary SolveImpl(BlockSparseMatrix* A,
+                                  const double* b,
+                                  const LinearSolver::PerSolveOptions& options,
+                                  double* x) final;
 
   void CreatePreconditioner(BlockSparseMatrix* A);
 
diff --git a/internal/ceres/iterative_schur_complement_solver_test.cc b/internal/ceres/iterative_schur_complement_solver_test.cc
index 3bf2d92..fdd65c7 100644
--- a/internal/ceres/iterative_schur_complement_solver_test.cc
+++ b/internal/ceres/iterative_schur_complement_solver_test.cc
@@ -36,6 +36,7 @@
 
 #include <cstddef>
 #include <memory>
+
 #include "Eigen/Dense"
 #include "ceres/block_random_access_dense_matrix.h"
 #include "ceres/block_sparse_matrix.h"
@@ -58,7 +59,7 @@
 const double kEpsilon = 1e-14;
 
 class IterativeSchurComplementSolverTest : public ::testing::Test {
- protected :
+ protected:
   void SetUpProblem(int problem_id) {
     std::unique_ptr<LinearLeastSquaresProblem> problem(
         CreateLinearLeastSquaresProblemFromId(problem_id));
@@ -74,9 +75,8 @@
   }
 
   AssertionResult TestSolver(double* D) {
-    TripletSparseMatrix triplet_A(A_->num_rows(),
-                                  A_->num_cols(),
-                                  A_->num_nonzeros());
+    TripletSparseMatrix triplet_A(
+        A_->num_rows(), A_->num_cols(), A_->num_nonzeros());
     A_->ToTripletSparseMatrix(&triplet_A);
 
     DenseSparseMatrix dense_A(triplet_A);
@@ -99,15 +99,15 @@
     IterativeSchurComplementSolver isc(options);
 
     Vector isc_sol(num_cols_);
-    per_solve_options.r_tolerance  = 1e-12;
+    per_solve_options.r_tolerance = 1e-12;
     isc.Solve(A_.get(), b_.get(), per_solve_options, isc_sol.data());
     double diff = (isc_sol - reference_solution).norm();
     if (diff < kEpsilon) {
       return testing::AssertionSuccess();
     } else {
       return testing::AssertionFailure()
-          << "The reference solution differs from the ITERATIVE_SCHUR"
-          << " solution by " << diff << " which is more than " << kEpsilon;
+             << "The reference solution differs from the ITERATIVE_SCHUR"
+             << " solution by " << diff << " which is more than " << kEpsilon;
     }
   }
 
diff --git a/internal/ceres/jet_test.cc b/internal/ceres/jet_test.cc
index f1e9586..36f279d 100644
--- a/internal/ceres/jet_test.cc
+++ b/internal/ceres/jet_test.cc
@@ -62,30 +62,32 @@
 // On a 32-bit optimized build, the mismatch is about 1.4e-14.
 double const kTolerance = 1e-13;
 
-void ExpectJetsClose(const J &x, const J &y) {
+void ExpectJetsClose(const J& x, const J& y) {
   ExpectClose(x.a, y.a, kTolerance);
   ExpectClose(x.v[0], y.v[0], kTolerance);
   ExpectClose(x.v[1], y.v[1], kTolerance);
 }
 
 const double kStep = 1e-8;
-const double kNumericalTolerance = 1e-6; // Numeric derivation is quite inexact
+const double kNumericalTolerance = 1e-6;  // Numeric derivation is quite inexact
 
 // Differentiate using Jet and confirm results with numerical derivation.
-template<typename Function>
+template <typename Function>
 void NumericalTest(const char* name, const Function& f, const double x) {
   const double exact_dx = f(MakeJet(x, 1.0, 0.0)).v[0];
   const double estimated_dx =
-    (f(J(x + kStep)).a - f(J(x - kStep)).a) / (2.0 * kStep);
-  VL << name << "(" << x << "), exact dx: "
-     << exact_dx << ", estimated dx: " << estimated_dx;
+      (f(J(x + kStep)).a - f(J(x - kStep)).a) / (2.0 * kStep);
+  VL << name << "(" << x << "), exact dx: " << exact_dx
+     << ", estimated dx: " << estimated_dx;
   ExpectClose(exact_dx, estimated_dx, kNumericalTolerance);
 }
 
 // Same as NumericalTest, but given a function taking two arguments.
-template<typename Function>
-void NumericalTest2(const char* name, const Function& f,
-                    const double x, const double y) {
+template <typename Function>
+void NumericalTest2(const char* name,
+                    const Function& f,
+                    const double x,
+                    const double y) {
   const J exact_delta = f(MakeJet(x, 1.0, 0.0), MakeJet(y, 0.0, 1.0));
   const double exact_dx = exact_delta.v[0];
   const double exact_dy = exact_delta.v[1];
@@ -97,14 +99,14 @@
   EXPECT_EQ(exact_dy, f(MakeJet(x, 0.0, 0.0), MakeJet(y, 0.0, 1.0)).v[1]);
 
   const double estimated_dx =
-    (f(J(x + kStep), J(y)).a - f(J(x - kStep), J(y)).a) / (2.0 * kStep);
+      (f(J(x + kStep), J(y)).a - f(J(x - kStep), J(y)).a) / (2.0 * kStep);
   const double estimated_dy =
-    (f(J(x), J(y + kStep)).a - f(J(x), J(y - kStep)).a) / (2.0 * kStep);
-  VL << name << "(" << x << ", " << y << "), exact dx: "
-     << exact_dx << ", estimated dx: " << estimated_dx;
+      (f(J(x), J(y + kStep)).a - f(J(x), J(y - kStep)).a) / (2.0 * kStep);
+  VL << name << "(" << x << ", " << y << "), exact dx: " << exact_dx
+     << ", estimated dx: " << estimated_dx;
   ExpectClose(exact_dx, estimated_dx, kNumericalTolerance);
-  VL << name << "(" << x << ", " << y << "), exact dy: "
-     << exact_dy << ", estimated dy: " << estimated_dy;
+  VL << name << "(" << x << ", " << y << "), exact dy: " << exact_dy
+     << ", estimated dy: " << estimated_dy;
   ExpectClose(exact_dy, estimated_dy, kNumericalTolerance);
 }
 
@@ -113,12 +115,12 @@
 TEST(Jet, Jet) {
   // Pick arbitrary values for x and y.
   J x = MakeJet(2.3, -2.7, 1e-3);
-  J y = MakeJet(1.7,  0.5, 1e+2);
+  J y = MakeJet(1.7, 0.5, 1e+2);
 
   VL << "x = " << x;
   VL << "y = " << y;
 
-  { // Check that log(exp(x)) == x.
+  {  // Check that log(exp(x)) == x.
     J z = exp(x);
     J w = log(z);
     VL << "z = " << z;
@@ -126,7 +128,7 @@
     ExpectJetsClose(w, x);
   }
 
-  { // Check that (x * y) / x == y.
+  {  // Check that (x * y) / x == y.
     J z = x * y;
     J w = z / x;
     VL << "z = " << z;
@@ -134,7 +136,7 @@
     ExpectJetsClose(w, y);
   }
 
-  { // Check that sqrt(x * x) == x.
+  {  // Check that sqrt(x * x) == x.
     J z = x * x;
     J w = sqrt(z);
     VL << "z = " << z;
@@ -142,7 +144,7 @@
     ExpectJetsClose(w, x);
   }
 
-  { // Check that sqrt(y) * sqrt(y) == y.
+  {  // Check that sqrt(y) * sqrt(y) == y.
     J z = sqrt(y);
     J w = z * z;
     VL << "z = " << z;
@@ -153,23 +155,23 @@
   NumericalTest("sqrt", sqrt<double, 2>, 0.00001);
   NumericalTest("sqrt", sqrt<double, 2>, 1.0);
 
-  { // Check that cos(2*x) = cos(x)^2 - sin(x)^2
+  {  // Check that cos(2*x) = cos(x)^2 - sin(x)^2
     J z = cos(J(2.0) * x);
-    J w = cos(x)*cos(x) - sin(x)*sin(x);
+    J w = cos(x) * cos(x) - sin(x) * sin(x);
     VL << "z = " << z;
     VL << "w = " << w;
     ExpectJetsClose(w, z);
   }
 
-  { // Check that sin(2*x) = 2*cos(x)*sin(x)
+  {  // Check that sin(2*x) = 2*cos(x)*sin(x)
     J z = sin(J(2.0) * x);
-    J w = J(2.0)*cos(x)*sin(x);
+    J w = J(2.0) * cos(x) * sin(x);
     VL << "z = " << z;
     VL << "w = " << w;
     ExpectJetsClose(w, z);
   }
 
-  { // Check that cos(x)*cos(x) + sin(x)*sin(x) = 1
+  {  // Check that cos(x)*cos(x) + sin(x)*sin(x) = 1
     J z = cos(x) * cos(x);
     J w = sin(x) * sin(x);
     VL << "z = " << z;
@@ -177,7 +179,7 @@
     ExpectJetsClose(z + w, J(1.0));
   }
 
-  { // Check that atan2(r*sin(t), r*cos(t)) = t.
+  {  // Check that atan2(r*sin(t), r*cos(t)) = t.
     J t = MakeJet(0.7, -0.3, +1.5);
     J r = MakeJet(2.3, 0.13, -2.4);
     VL << "t = " << t;
@@ -189,7 +191,7 @@
     ExpectJetsClose(u, t);
   }
 
-  { // Check that tan(x) = sin(x) / cos(x).
+  {  // Check that tan(x) = sin(x) / cos(x).
     J z = tan(x);
     J w = sin(x) / cos(x);
     VL << "z = " << z;
@@ -197,7 +199,7 @@
     ExpectJetsClose(z, w);
   }
 
-  { // Check that tan(atan(x)) = x.
+  {  // Check that tan(atan(x)) = x.
     J z = tan(atan(x));
     J w = x;
     VL << "z = " << z;
@@ -205,7 +207,7 @@
     ExpectJetsClose(z, w);
   }
 
-  { // Check that cosh(x)*cosh(x) - sinh(x)*sinh(x) = 1
+  {  // Check that cosh(x)*cosh(x) - sinh(x)*sinh(x) = 1
     J z = cosh(x) * cosh(x);
     J w = sinh(x) * sinh(x);
     VL << "z = " << z;
@@ -213,7 +215,7 @@
     ExpectJetsClose(z - w, J(1.0));
   }
 
-  { // Check that tanh(x + y) = (tanh(x) + tanh(y)) / (1 + tanh(x) tanh(y))
+  {  // Check that tanh(x + y) = (tanh(x) + tanh(y)) / (1 + tanh(x) tanh(y))
     J z = tanh(x + y);
     J w = (tanh(x) + tanh(y)) / (J(1.0) + tanh(x) * tanh(y));
     VL << "z = " << z;
@@ -221,7 +223,7 @@
     ExpectJetsClose(z, w);
   }
 
-  { // Check that pow(x, 1) == x.
+  {  // Check that pow(x, 1) == x.
     VL << "x = " << x;
 
     J u = pow(x, 1.);
@@ -230,7 +232,7 @@
     ExpectJetsClose(x, u);
   }
 
-  { // Check that pow(x, 1) == x.
+  {  // Check that pow(x, 1) == x.
     J y = MakeJet(1, 0.0, 0.0);
     VL << "x = " << x;
     VL << "y = " << y;
@@ -241,7 +243,7 @@
     ExpectJetsClose(x, u);
   }
 
-  { // Check that pow(e, log(x)) == x.
+  {  // Check that pow(e, log(x)) == x.
     J logx = log(x);
 
     VL << "x = " << x;
@@ -253,7 +255,7 @@
     ExpectJetsClose(x, u);
   }
 
-  { // Check that pow(e, log(x)) == x.
+  {  // Check that pow(e, log(x)) == x.
     J logx = log(x);
     J e = MakeJet(kE, 0., 0.);
     VL << "x = " << x;
@@ -265,7 +267,7 @@
     ExpectJetsClose(x, u);
   }
 
-  { // Check that pow(e, log(x)) == x.
+  {  // Check that pow(e, log(x)) == x.
     J logx = log(x);
     J e = MakeJet(kE, 0., 0.);
     VL << "x = " << x;
@@ -277,13 +279,13 @@
     ExpectJetsClose(x, u);
   }
 
-  { // Check that pow(x,y) = exp(y*log(x)).
+  {  // Check that pow(x,y) = exp(y*log(x)).
     J logx = log(x);
     J e = MakeJet(kE, 0., 0.);
     VL << "x = " << x;
     VL << "logx = " << logx;
 
-    J u = pow(e, y*logx);
+    J u = pow(e, y * logx);
     J v = pow(x, y);
     VL << "u = " << u;
     VL << "v = " << v;
@@ -291,7 +293,7 @@
     ExpectJetsClose(v, u);
   }
 
-  { // Check that pow(0, y) == 0 for y > 1, with both arguments Jets.
+  {  // Check that pow(0, y) == 0 for y > 1, with both arguments Jets.
     // This tests special case handling inside pow().
     J a = MakeJet(0, 1, 2);
     J b = MakeJet(2, 3, 4);
@@ -303,7 +305,7 @@
     ExpectJetsClose(c, MakeJet(0, 0, 0));
   }
 
-  { // Check that pow(0, y) == 0 for y == 1, with both arguments Jets.
+  {  // Check that pow(0, y) == 0 for y == 1, with both arguments Jets.
     // This tests special case handling inside pow().
     J a = MakeJet(0, 1, 2);
     J b = MakeJet(1, 3, 4);
@@ -315,10 +317,10 @@
     ExpectJetsClose(c, MakeJet(0, 1, 2));
   }
 
-  { // Check that pow(0, <1) is not finite, with both arguments Jets.
+  {  // Check that pow(0, <1) is not finite, with both arguments Jets.
     for (int i = 1; i < 10; i++) {
       J a = MakeJet(0, 1, 2);
-      J b = MakeJet(i*0.1, 3, 4);       // b = 0.1 ... 0.9
+      J b = MakeJet(i * 0.1, 3, 4);  // b = 0.1 ... 0.9
       VL << "a = " << a;
       VL << "b = " << b;
 
@@ -330,7 +332,7 @@
     }
     for (int i = -10; i < 0; i++) {
       J a = MakeJet(0, 1, 2);
-      J b = MakeJet(i*0.1, 3, 4);       // b = -1,-0.9 ... -0.1
+      J b = MakeJet(i * 0.1, 3, 4);  // b = -1,-0.9 ... -0.1
       VL << "a = " << a;
       VL << "b = " << b;
 
@@ -356,7 +358,7 @@
     }
   }
 
-  { // Check that pow(<0, b) is correct for integer b.
+  {  // Check that pow(<0, b) is correct for integer b.
     // This tests special case handling inside pow().
     J a = MakeJet(-1.5, 3, 4);
 
@@ -375,7 +377,7 @@
     }
   }
 
-  { // Check that pow(<0, b) is correct for noninteger b.
+  {  // Check that pow(<0, b) is correct for noninteger b.
     // This tests special case handling inside pow().
     J a = MakeJet(-1.5, 3, 4);
     J b = MakeJet(-2.5, 0, 5);
@@ -435,7 +437,7 @@
     EXPECT_FALSE(IsFinite(c.v[1]));
   }
 
-  { // Check that 1 + x == x + 1.
+  {  // Check that 1 + x == x + 1.
     J a = x + 1.0;
     J b = 1.0 + x;
     J c = x;
@@ -445,7 +447,7 @@
     ExpectJetsClose(a, c);
   }
 
-  { // Check that 1 - x == -(x - 1).
+  {  // Check that 1 - x == -(x - 1).
     J a = 1.0 - x;
     J b = -(x - 1.0);
     J c = x;
@@ -455,7 +457,7 @@
     ExpectJetsClose(a, -c);
   }
 
-  { // Check that (x/s)*s == (x*s)/s.
+  {  // Check that (x/s)*s == (x*s)/s.
     J a = x / 5.0;
     J b = x * 5.0;
     J c = x;
@@ -468,7 +470,7 @@
     ExpectJetsClose(b, d);
   }
 
-  { // Check that x / y == 1 / (y / x).
+  {  // Check that x / y == 1 / (y / x).
     J a = x / y;
     J b = 1.0 / (y / x);
     VL << "a = " << a;
@@ -477,26 +479,26 @@
     ExpectJetsClose(a, b);
   }
 
-  { // Check that abs(-x * x) == sqrt(x * x).
+  {  // Check that abs(-x * x) == sqrt(x * x).
     ExpectJetsClose(abs(-x), sqrt(x * x));
   }
 
-  { // Check that cos(acos(x)) == x.
+  {  // Check that cos(acos(x)) == x.
     J a = MakeJet(0.1, -2.7, 1e-3);
     ExpectJetsClose(cos(acos(a)), a);
     ExpectJetsClose(acos(cos(a)), a);
 
-    J b = MakeJet(0.6,  0.5, 1e+2);
+    J b = MakeJet(0.6, 0.5, 1e+2);
     ExpectJetsClose(cos(acos(b)), b);
     ExpectJetsClose(acos(cos(b)), b);
   }
 
-  { // Check that sin(asin(x)) == x.
+  {  // Check that sin(asin(x)) == x.
     J a = MakeJet(0.1, -2.7, 1e-3);
     ExpectJetsClose(sin(asin(a)), a);
     ExpectJetsClose(asin(sin(a)), a);
 
-    J b = MakeJet(0.4,  0.5, 1e+2);
+    J b = MakeJet(0.4, 0.5, 1e+2);
     ExpectJetsClose(sin(asin(b)), b);
     ExpectJetsClose(asin(sin(b)), b);
   }
@@ -529,49 +531,49 @@
     ExpectJetsClose(BesselJ0(z) + BesselJn(2, z), (2.0 / z) * BesselJ1(z));
   }
 
-  { // Check that floor of a positive number works.
+  {  // Check that floor of a positive number works.
     J a = MakeJet(0.1, -2.7, 1e-3);
     J b = floor(a);
     J expected = MakeJet(floor(a.a), 0.0, 0.0);
     EXPECT_EQ(expected, b);
   }
 
-  { // Check that floor of a negative number works.
+  {  // Check that floor of a negative number works.
     J a = MakeJet(-1.1, -2.7, 1e-3);
     J b = floor(a);
     J expected = MakeJet(floor(a.a), 0.0, 0.0);
     EXPECT_EQ(expected, b);
   }
 
-  { // Check that floor of a positive number works.
+  {  // Check that floor of a positive number works.
     J a = MakeJet(10.123, -2.7, 1e-3);
     J b = floor(a);
     J expected = MakeJet(floor(a.a), 0.0, 0.0);
     EXPECT_EQ(expected, b);
   }
 
-  { // Check that ceil of a positive number works.
+  {  // Check that ceil of a positive number works.
     J a = MakeJet(0.1, -2.7, 1e-3);
     J b = ceil(a);
     J expected = MakeJet(ceil(a.a), 0.0, 0.0);
     EXPECT_EQ(expected, b);
   }
 
-  { // Check that ceil of a negative number works.
+  {  // Check that ceil of a negative number works.
     J a = MakeJet(-1.1, -2.7, 1e-3);
     J b = ceil(a);
     J expected = MakeJet(ceil(a.a), 0.0, 0.0);
     EXPECT_EQ(expected, b);
   }
 
-  { // Check that ceil of a positive number works.
+  {  // Check that ceil of a positive number works.
     J a = MakeJet(10.123, -2.7, 1e-3);
     J b = ceil(a);
     J expected = MakeJet(ceil(a.a), 0.0, 0.0);
     EXPECT_EQ(expected, b);
   }
 
-  { // Check that erf works.
+  {  // Check that erf works.
     J a = MakeJet(10.123, -2.7, 1e-3);
     J b = erf(a);
     J expected = MakeJet(erf(a.a), 0.0, 0.0);
@@ -582,7 +584,7 @@
   NumericalTest("erf", erf<double, 2>, 0.5);
   NumericalTest("erf", erf<double, 2>, 100.0);
 
-  { // Check that erfc works.
+  {  // Check that erfc works.
     J a = MakeJet(10.123, -2.7, 1e-3);
     J b = erfc(a);
     J expected = MakeJet(erfc(a.a), 0.0, 0.0);
@@ -593,7 +595,7 @@
   NumericalTest("erfc", erfc<double, 2>, 0.5);
   NumericalTest("erfc", erfc<double, 2>, 100.0);
 
-  { // Check that cbrt(x * x * x) == x.
+  {  // Check that cbrt(x * x * x) == x.
     J z = x * x * x;
     J w = cbrt(z);
     VL << "z = " << z;
@@ -601,7 +603,7 @@
     ExpectJetsClose(w, x);
   }
 
-  { // Check that cbrt(y) * cbrt(y) * cbrt(y) == y.
+  {  // Check that cbrt(y) * cbrt(y) * cbrt(y) == y.
     J z = cbrt(y);
     J w = z * z * z;
     VL << "z = " << z;
@@ -609,7 +611,7 @@
     ExpectJetsClose(w, y);
   }
 
-  { // Check that cbrt(x) == pow(x, 1/3).
+  {  // Check that cbrt(x) == pow(x, 1/3).
     J z = cbrt(x);
     J w = pow(x, 1.0 / 3.0);
     VL << "z = " << z;
@@ -621,7 +623,7 @@
   NumericalTest("cbrt", cbrt<double, 2>, 1e-5);
   NumericalTest("cbrt", cbrt<double, 2>, 1.0);
 
-  { // Check that exp2(x) == exp(x * log(2))
+  {  // Check that exp2(x) == exp(x * log(2))
     J z = exp2(x);
     J w = exp(x * log(2.0));
     VL << "z = " << z;
@@ -636,7 +638,7 @@
   NumericalTest("exp2", exp2<double, 2>, 1e-5);
   NumericalTest("exp2", exp2<double, 2>, 1.0);
 
-  { // Check that log2(x) == log(x) / log(2)
+  {  // Check that log2(x) == log(x) / log(2)
     J z = log2(x);
     J w = log(x) / log(2.0);
     VL << "z = " << z;
@@ -647,15 +649,15 @@
   NumericalTest("log2", log2<double, 2>, 1.0);
   NumericalTest("log2", log2<double, 2>, 100.0);
 
-  { // Check that hypot(x, y) == sqrt(x^2 + y^2)
+  {  // Check that hypot(x, y) == sqrt(x^2 + y^2)
     J h = hypot(x, y);
-    J s = sqrt(x*x + y*y);
+    J s = sqrt(x * x + y * y);
     VL << "h = " << h;
     VL << "s = " << s;
     ExpectJetsClose(h, s);
   }
 
-  { // Check that hypot(x, x) == sqrt(2) * abs(x)
+  {  // Check that hypot(x, x) == sqrt(2) * abs(x)
     J h = hypot(x, x);
     J s = sqrt(2.0) * abs(x);
     VL << "h = " << h;
@@ -663,35 +665,35 @@
     ExpectJetsClose(h, s);
   }
 
-  { // Check that the derivative is zero tangentially to the circle:
+  {  // Check that the derivative is zero tangentially to the circle:
     J h = hypot(MakeJet(2.0, 1.0, 1.0), MakeJet(2.0, 1.0, -1.0));
     VL << "h = " << h;
     ExpectJetsClose(h, MakeJet(sqrt(8.0), std::sqrt(2.0), 0.0));
   }
 
-  { // Check that hypot(x, 0) == x
+  {  // Check that hypot(x, 0) == x
     J zero = MakeJet(0.0, 2.0, 3.14);
     J h = hypot(x, zero);
     VL << "h = " << h;
     ExpectJetsClose(x, h);
   }
 
-  { // Check that hypot(0, y) == y
+  {  // Check that hypot(0, y) == y
     J zero = MakeJet(0.0, 2.0, 3.14);
     J h = hypot(zero, y);
     VL << "h = " << h;
     ExpectJetsClose(y, h);
   }
 
-  { // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x underflows:
-    EXPECT_EQ(DBL_MIN * DBL_MIN, 0.0); // Make sure it underflows
+  {  // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x underflows:
+    EXPECT_EQ(DBL_MIN * DBL_MIN, 0.0);  // Make sure it underflows
     J huge = MakeJet(DBL_MIN, 2.0, 3.14);
     J h = hypot(huge, J(0.0));
     VL << "h = " << h;
     ExpectJetsClose(h, huge);
   }
 
-  { // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x overflows:
+  {  // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x overflows:
     EXPECT_EQ(DBL_MAX * DBL_MAX, std::numeric_limits<double>::infinity());
     J huge = MakeJet(DBL_MAX, 2.0, 3.14);
     J h = hypot(huge, J(0.0));
@@ -699,6 +701,7 @@
     ExpectJetsClose(h, huge);
   }
 
+  // clang-format off
   NumericalTest2("hypot", hypot<double, 2>,  0.0,   1e-5);
   NumericalTest2("hypot", hypot<double, 2>, -1e-5,  0.0);
   NumericalTest2("hypot", hypot<double, 2>,  1e-5,  1e-5);
@@ -708,6 +711,7 @@
   NumericalTest2("hypot", hypot<double, 2>, -1e-3,  1.0);
   NumericalTest2("hypot", hypot<double, 2>, -1e-3, -1.0);
   NumericalTest2("hypot", hypot<double, 2>,  1.0,   2.0);
+  // clang-format on
 
   {
     J z = fmax(x, y);
@@ -720,14 +724,13 @@
     VL << "z = " << z;
     ExpectJetsClose(y, z);
   }
-
 }
 
 TEST(Jet, JetsInEigenMatrices) {
   J x = MakeJet(2.3, -2.7, 1e-3);
-  J y = MakeJet(1.7,  0.5, 1e+2);
+  J y = MakeJet(1.7, 0.5, 1e+2);
   J z = MakeJet(5.3, -4.7, 1e-3);
-  J w = MakeJet(9.7,  1.5, 10.1);
+  J w = MakeJet(9.7, 1.5, 10.1);
 
   Eigen::Matrix<J, 2, 2> M;
   Eigen::Matrix<J, 2, 1> v, r1, r2;
@@ -795,11 +798,11 @@
   Eigen::Matrix<J, 3, 1> b, x;
   for (int i = 0; i < 3; ++i) {
     for (int j = 0; j < 3; ++j) {
-      A(i,j) = MakeJet(0.0, i, j * j);
+      A(i, j) = MakeJet(0.0, i, j * j);
     }
     b(i) = MakeJet(i, i, i);
     x(i) = MakeJet(0.0, 0.0, 0.0);
-    A(i,i) = MakeJet(1.0, i, i * i);
+    A(i, i) = MakeJet(1.0, i, i * i);
   }
   x = A.llt().solve(b);
   for (int i = 0; i < 3; ++i) {
@@ -812,11 +815,11 @@
   Eigen::Matrix<J, 3, 1> b, x;
   for (int i = 0; i < 3; ++i) {
     for (int j = 0; j < 3; ++j) {
-      A(i,j) = MakeJet(0.0, i, j * j);
+      A(i, j) = MakeJet(0.0, i, j * j);
     }
     b(i) = MakeJet(i, i, i);
     x(i) = MakeJet(0.0, 0.0, 0.0);
-    A(i,i) = MakeJet(1.0, i, i * i);
+    A(i, i) = MakeJet(1.0, i, i * i);
   }
   x = A.ldlt().solve(b);
   for (int i = 0; i < 3; ++i) {
@@ -829,11 +832,11 @@
   Eigen::Matrix<J, 3, 1> b, x;
   for (int i = 0; i < 3; ++i) {
     for (int j = 0; j < 3; ++j) {
-      A(i,j) = MakeJet(0.0, i, j * j);
+      A(i, j) = MakeJet(0.0, i, j * j);
     }
     b(i) = MakeJet(i, i, i);
     x(i) = MakeJet(0.0, 0.0, 0.0);
-    A(i,i) = MakeJet(1.0, i, i * i);
+    A(i, i) = MakeJet(1.0, i, i * i);
   }
 
   x = A.lu().solve(b);
@@ -845,7 +848,7 @@
 // ScalarBinaryOpTraits is only supported on Eigen versions >= 3.3
 TEST(JetTraitsTest, MatrixScalarUnaryOps) {
   const J x = MakeJet(2.3, -2.7, 1e-3);
-  const J y = MakeJet(1.7,  0.5, 1e+2);
+  const J y = MakeJet(1.7, 0.5, 1e+2);
   Eigen::Matrix<J, 2, 1> a;
   a << x, y;
 
@@ -856,9 +859,9 @@
 
 TEST(JetTraitsTest, MatrixScalarBinaryOps) {
   const J x = MakeJet(2.3, -2.7, 1e-3);
-  const J y = MakeJet(1.7,  0.5, 1e+2);
+  const J y = MakeJet(1.7, 0.5, 1e+2);
   const J z = MakeJet(5.3, -4.7, 1e-3);
-  const J w = MakeJet(9.7,  1.5, 10.1);
+  const J w = MakeJet(9.7, 1.5, 10.1);
 
   Eigen::Matrix<J, 2, 2> M;
   Eigen::Vector2d v;
@@ -886,7 +889,7 @@
 
 TEST(JetTraitsTest, ArrayScalarUnaryOps) {
   const J x = MakeJet(2.3, -2.7, 1e-3);
-  const J y = MakeJet(1.7,  0.5, 1e+2);
+  const J y = MakeJet(1.7, 0.5, 1e+2);
   Eigen::Array<J, 2, 1> a;
   a << x, y;
 
@@ -897,7 +900,7 @@
 
 TEST(JetTraitsTest, ArrayScalarBinaryOps) {
   const J x = MakeJet(2.3, -2.7, 1e-3);
-  const J y = MakeJet(1.7,  0.5, 1e+2);
+  const J y = MakeJet(1.7, 0.5, 1e+2);
 
   Eigen::Array<J, 2, 1> a;
   Eigen::Array2d b;
@@ -922,8 +925,8 @@
 }
 
 TEST(Jet, nested3x) {
-  typedef Jet<J,2> JJ;
-  typedef Jet<JJ,2> JJJ;
+  typedef Jet<J, 2> JJ;
+  typedef Jet<JJ, 2> JJJ;
 
   JJJ x;
   x.a = JJ(J(1, 0), 0);
diff --git a/internal/ceres/lapack.cc b/internal/ceres/lapack.cc
index 37efbcd..a159ec7 100644
--- a/internal/ceres/lapack.cc
+++ b/internal/ceres/lapack.cc
@@ -36,11 +36,7 @@
 
 #ifndef CERES_NO_LAPACK
 // C interface to the LAPACK Cholesky factorization and triangular solve.
-extern "C" void dpotrf_(char* uplo,
-                       int* n,
-                       double* a,
-                       int* lda,
-                       int* info);
+extern "C" void dpotrf_(char* uplo, int* n, double* a, int* lda, int* info);
 
 extern "C" void dpotrs_(char* uplo,
                         int* n,
@@ -92,10 +88,10 @@
   }
 
   if (info > 0) {
-    *message =
-        StringPrintf(
-            "LAPACK::dpotrf numerical failure. "
-             "The leading minor of order %d is not positive definite.", info);
+    *message = StringPrintf(
+        "LAPACK::dpotrf numerical failure. "
+        "The leading minor of order %d is not positive definite.",
+        info);
     return LINEAR_SOLVER_FAILURE;
   }
 
diff --git a/internal/ceres/lapack.h b/internal/ceres/lapack.h
index 5bb1a22..5c5bf8b 100644
--- a/internal/ceres/lapack.h
+++ b/internal/ceres/lapack.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_LAPACK_H_
 
 #include <string>
+
 #include "ceres/internal/port.h"
 #include "ceres/linear_solver.h"
 
diff --git a/internal/ceres/levenberg_marquardt_strategy.cc b/internal/ceres/levenberg_marquardt_strategy.cc
index 9eec631..cb0e937 100644
--- a/internal/ceres/levenberg_marquardt_strategy.cc
+++ b/internal/ceres/levenberg_marquardt_strategy.cc
@@ -61,8 +61,7 @@
   CHECK_GT(max_radius_, 0.0);
 }
 
-LevenbergMarquardtStrategy::~LevenbergMarquardtStrategy() {
-}
+LevenbergMarquardtStrategy::~LevenbergMarquardtStrategy() {}
 
 TrustRegionStrategy::Summary LevenbergMarquardtStrategy::ComputeStep(
     const TrustRegionStrategy::PerSolveOptions& per_solve_options,
@@ -81,8 +80,8 @@
 
     jacobian->SquaredColumnNorm(diagonal_.data());
     for (int i = 0; i < num_parameters; ++i) {
-      diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_),
-                              max_diagonal_);
+      diagonal_[i] =
+          std::min(std::max(diagonal_[i], min_diagonal_), max_diagonal_);
     }
   }
 
@@ -112,7 +111,7 @@
   if (linear_solver_summary.termination_type == LINEAR_SOLVER_FATAL_ERROR) {
     LOG(WARNING) << "Linear solver fatal error: "
                  << linear_solver_summary.message;
-  } else if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE)  {
+  } else if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE) {
     LOG(WARNING) << "Linear solver failure. Failed to compute a step: "
                  << linear_solver_summary.message;
   } else if (!IsArrayValid(num_parameters, step)) {
@@ -138,7 +137,6 @@
     }
   }
 
-
   TrustRegionStrategy::Summary summary;
   summary.residual_norm = linear_solver_summary.residual_norm;
   summary.num_iterations = linear_solver_summary.num_iterations;
@@ -148,8 +146,8 @@
 
 void LevenbergMarquardtStrategy::StepAccepted(double step_quality) {
   CHECK_GT(step_quality, 0.0);
-  radius_ = radius_ / std::max(1.0 / 3.0,
-                               1.0 - pow(2.0 * step_quality - 1.0, 3));
+  radius_ =
+      radius_ / std::max(1.0 / 3.0, 1.0 - pow(2.0 * step_quality - 1.0, 3));
   radius_ = std::min(max_radius_, radius_);
   decrease_factor_ = 2.0;
   reuse_diagonal_ = false;
@@ -161,9 +159,7 @@
   reuse_diagonal_ = true;
 }
 
-double LevenbergMarquardtStrategy::Radius() const {
-  return radius_;
-}
+double LevenbergMarquardtStrategy::Radius() const { return radius_; }
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/levenberg_marquardt_strategy.h b/internal/ceres/levenberg_marquardt_strategy.h
index 8fb37f3..4cadd6d 100644
--- a/internal/ceres/levenberg_marquardt_strategy.h
+++ b/internal/ceres/levenberg_marquardt_strategy.h
@@ -74,7 +74,7 @@
   const double max_diagonal_;
   double decrease_factor_;
   bool reuse_diagonal_;
-  Vector diagonal_;   // diagonal_ =  diag(J'J)
+  Vector diagonal_;  // diagonal_ =  diag(J'J)
   // Scaled copy of diagonal_. Stored here as optimization to prevent
   // allocations in every iteration and reuse when a step fails and
   // ComputeStep is called again.
diff --git a/internal/ceres/levenberg_marquardt_strategy_test.cc b/internal/ceres/levenberg_marquardt_strategy_test.cc
index f8f06bf..500f269 100644
--- a/internal/ceres/levenberg_marquardt_strategy_test.cc
+++ b/internal/ceres/levenberg_marquardt_strategy_test.cc
@@ -28,9 +28,11 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-#include <memory>
-#include "ceres/internal/eigen.h"
 #include "ceres/levenberg_marquardt_strategy.h"
+
+#include <memory>
+
+#include "ceres/internal/eigen.h"
 #include "ceres/linear_solver.h"
 #include "ceres/trust_region_strategy.h"
 #include "glog/logging.h"
@@ -38,11 +40,11 @@
 #include "gmock/mock-log.h"
 #include "gtest/gtest.h"
 
+using testing::_;
 using testing::AllOf;
 using testing::AnyNumber;
 using testing::HasSubstr;
 using testing::ScopedMockLog;
-using testing::_;
 
 namespace ceres {
 namespace internal {
@@ -54,9 +56,7 @@
 class RegularizationCheckingLinearSolver : public DenseSparseMatrixSolver {
  public:
   RegularizationCheckingLinearSolver(const int num_cols, const double* diagonal)
-      : num_cols_(num_cols),
-        diagonal_(diagonal) {
-  }
+      : num_cols_(num_cols), diagonal_(diagonal) {}
 
   virtual ~RegularizationCheckingLinearSolver() {}
 
@@ -152,11 +152,11 @@
 #if defined(_MSC_VER)
     // Use GLOG_WARNING to support MSVC if GLOG_NO_ABBREVIATED_SEVERITIES
     // is defined.
-    EXPECT_CALL(log, Log(GLOG_WARNING, _,
-                         HasSubstr("Failed to compute a step")));
+    EXPECT_CALL(log,
+                Log(GLOG_WARNING, _, HasSubstr("Failed to compute a step")));
 #else
-    EXPECT_CALL(log, Log(google::WARNING, _,
-                         HasSubstr("Failed to compute a step")));
+    EXPECT_CALL(log,
+                Log(google::WARNING, _, HasSubstr("Failed to compute a step")));
 #endif
 
     TrustRegionStrategy::Summary summary =
diff --git a/internal/ceres/line_search.cc b/internal/ceres/line_search.cc
index 352c64f..3f5103f 100644
--- a/internal/ceres/line_search.cc
+++ b/internal/ceres/line_search.cc
@@ -57,10 +57,10 @@
 const int kErrorMessageNumericPrecision = 8;
 }  // namespace
 
-ostream& operator<<(ostream &os, const FunctionSample& sample);
+ostream& operator<<(ostream& os, const FunctionSample& sample);
 
 // Convenience stream operator for pushing FunctionSamples into log messages.
-ostream& operator<<(ostream &os, const FunctionSample& sample) {
+ostream& operator<<(ostream& os, const FunctionSample& sample) {
   os << sample.ToDebugString();
   return os;
 }
@@ -73,17 +73,17 @@
                                string* error) {
   LineSearch* line_search = NULL;
   switch (line_search_type) {
-  case ceres::ARMIJO:
-    line_search = new ArmijoLineSearch(options);
-    break;
-  case ceres::WOLFE:
-    line_search = new WolfeLineSearch(options);
-    break;
-  default:
-    *error = string("Invalid line search algorithm type: ") +
-        LineSearchTypeToString(line_search_type) +
-        string(", unable to create line search.");
-    return NULL;
+    case ceres::ARMIJO:
+      line_search = new ArmijoLineSearch(options);
+      break;
+    case ceres::WOLFE:
+      line_search = new WolfeLineSearch(options);
+      break;
+    default:
+      *error = string("Invalid line search algorithm type: ") +
+               LineSearchTypeToString(line_search_type) +
+               string(", unable to create line search.");
+      return NULL;
   }
   return line_search;
 }
@@ -96,8 +96,7 @@
       initial_evaluator_residual_time_in_seconds(0.0),
       initial_evaluator_jacobian_time_in_seconds(0.0) {}
 
-void LineSearchFunction::Init(const Vector& position,
-                              const Vector& direction) {
+void LineSearchFunction::Init(const Vector& position, const Vector& direction) {
   position_ = position;
   direction_ = direction;
 }
@@ -200,9 +199,9 @@
   summary->polynomial_minimization_time_in_seconds = 0.0;
   options().function->ResetTimeStatistics();
   this->DoSearch(step_size_estimate, initial_cost, initial_gradient, summary);
-  options().function->
-      TimeStatistics(&summary->cost_evaluation_time_in_seconds,
-                     &summary->gradient_evaluation_time_in_seconds);
+  options().function->TimeStatistics(
+      &summary->cost_evaluation_time_in_seconds,
+      &summary->gradient_evaluation_time_in_seconds);
 
   summary->total_time_in_seconds = WallTimeInSeconds() - start_time;
 }
@@ -218,8 +217,7 @@
     const double min_step_size,
     const double max_step_size) const {
   if (!current.value_is_valid ||
-      (interpolation_type == BISECTION &&
-       max_step_size <= current.x)) {
+      (interpolation_type == BISECTION && max_step_size <= current.x)) {
     // Either: sample is invalid; or we are using BISECTION and contracting
     // the step size.
     return std::min(std::max(current.x * 0.5, min_step_size), max_step_size);
@@ -274,8 +272,8 @@
   }
 
   double step_size = 0.0, unused_min_value = 0.0;
-  MinimizeInterpolatingPolynomial(samples, min_step_size, max_step_size,
-                                  &step_size, &unused_min_value);
+  MinimizeInterpolatingPolynomial(
+      samples, min_step_size, max_step_size, &step_size, &unused_min_value);
   return step_size;
 }
 
@@ -315,40 +313,38 @@
 
   function->Evaluate(step_size_estimate, kEvaluateGradient, &current);
   while (!current.value_is_valid ||
-         current.value > (initial_cost
-                          + options().sufficient_decrease
-                          * initial_gradient
-                          * current.x)) {
+         current.value > (initial_cost + options().sufficient_decrease *
+                                             initial_gradient * current.x)) {
     // If current.value_is_valid is false, we treat it as if the cost at that
     // point is not large enough to satisfy the sufficient decrease condition.
     ++summary->num_iterations;
     if (summary->num_iterations >= options().max_num_iterations) {
-      summary->error =
-          StringPrintf("Line search failed: Armijo failed to find a point "
-                       "satisfying the sufficient decrease condition within "
-                       "specified max_num_iterations: %d.",
-                       options().max_num_iterations);
+      summary->error = StringPrintf(
+          "Line search failed: Armijo failed to find a point "
+          "satisfying the sufficient decrease condition within "
+          "specified max_num_iterations: %d.",
+          options().max_num_iterations);
       LOG_IF(WARNING, !options().is_silent) << summary->error;
       return;
     }
 
     const double polynomial_minimization_start_time = WallTimeInSeconds();
-    const double step_size =
-        this->InterpolatingPolynomialMinimizingStepSize(
-            options().interpolation_type,
-            initial_position,
-            previous,
-            current,
-            (options().max_step_contraction * current.x),
-            (options().min_step_contraction * current.x));
+    const double step_size = this->InterpolatingPolynomialMinimizingStepSize(
+        options().interpolation_type,
+        initial_position,
+        previous,
+        current,
+        (options().max_step_contraction * current.x),
+        (options().min_step_contraction * current.x));
     summary->polynomial_minimization_time_in_seconds +=
         (WallTimeInSeconds() - polynomial_minimization_start_time);
 
     if (step_size * descent_direction_max_norm < options().min_step_size) {
-      summary->error =
-          StringPrintf("Line search failed: step_size too small: %.5e "
-                       "with descent_direction_max_norm: %.5e.", step_size,
-                       descent_direction_max_norm);
+      summary->error = StringPrintf(
+          "Line search failed: step_size too small: %.5e "
+          "with descent_direction_max_norm: %.5e.",
+          step_size,
+          descent_direction_max_norm);
       LOG_IF(WARNING, !options().is_silent) << summary->error;
       return;
     }
@@ -435,8 +431,8 @@
   }
 
   VLOG(3) << std::scientific << std::setprecision(kErrorMessageNumericPrecision)
-          << "Starting line search zoom phase with bracket_low: "
-          << bracket_low << ", bracket_high: " << bracket_high
+          << "Starting line search zoom phase with bracket_low: " << bracket_low
+          << ", bracket_high: " << bracket_high
           << ", bracket width: " << fabs(bracket_low.x - bracket_high.x)
           << ", bracket abs delta cost: "
           << fabs(bracket_low.value - bracket_high.value);
@@ -461,11 +457,9 @@
   //          but still has bracket_high.value < initial_position.value.
   //   3. bracket_high is chosen after bracket_low, s.t.
   //      bracket_low.gradient * (bracket_high.x - bracket_low.x) < 0.
-  if (!this->ZoomPhase(initial_position,
-                       bracket_low,
-                       bracket_high,
-                       &solution,
-                       summary) && !solution.value_is_valid) {
+  if (!this->ZoomPhase(
+          initial_position, bracket_low, bracket_high, &solution, summary) &&
+      !solution.value_is_valid) {
     // Failed to find a valid point (given the specified decrease parameters)
     // within the specified bracket.
     return;
@@ -501,20 +495,18 @@
 //
 // Returns false if no step size > minimum step size was found which
 // satisfies at least the Armijo condition.
-bool WolfeLineSearch::BracketingPhase(
-    const FunctionSample& initial_position,
-    const double step_size_estimate,
-    FunctionSample* bracket_low,
-    FunctionSample* bracket_high,
-    bool* do_zoom_search,
-    Summary* summary) const {
+bool WolfeLineSearch::BracketingPhase(const FunctionSample& initial_position,
+                                      const double step_size_estimate,
+                                      FunctionSample* bracket_low,
+                                      FunctionSample* bracket_high,
+                                      bool* do_zoom_search,
+                                      Summary* summary) const {
   LineSearchFunction* function = options().function;
 
   FunctionSample previous = initial_position;
   FunctionSample current;
 
-  const double descent_direction_max_norm =
-      function->DirectionInfinityNorm();
+  const double descent_direction_max_norm = function->DirectionInfinityNorm();
 
   *do_zoom_search = false;
   *bracket_low = initial_position;
@@ -536,10 +528,9 @@
     ++summary->num_iterations;
 
     if (current.value_is_valid &&
-        (current.value > (initial_position.value
-                          + options().sufficient_decrease
-                          * initial_position.gradient
-                          * current.x) ||
+        (current.value > (initial_position.value +
+                          options().sufficient_decrease *
+                              initial_position.gradient * current.x) ||
          (previous.value_is_valid && current.value > previous.value))) {
       // Bracket found: current step size violates Armijo sufficient decrease
       // condition, or has stepped past an inflection point of f() relative to
@@ -556,8 +547,8 @@
     }
 
     if (current.value_is_valid &&
-        fabs(current.gradient) <=
-        -options().sufficient_curvature_decrease * initial_position.gradient) {
+        fabs(current.gradient) <= -options().sufficient_curvature_decrease *
+                                      initial_position.gradient) {
       // Current step size satisfies the strong Wolfe conditions, and is thus a
       // valid termination point, therefore a Zoom not required.
       *bracket_low = current;
@@ -585,8 +576,8 @@
       break;
 
     } else if (current.value_is_valid &&
-               fabs(current.x - previous.x) * descent_direction_max_norm
-               < options().min_step_size) {
+               fabs(current.x - previous.x) * descent_direction_max_norm <
+                   options().min_step_size) {
       // We have shrunk the search bracket to a width less than our tolerance,
       // and still not found either a point satisfying the strong Wolfe
       // conditions, or a valid bracket containing such a point. Stop searching
@@ -595,9 +586,9 @@
       LOG_IF(WARNING, !options().is_silent)
           << "Line search failed: Wolfe bracketing phase shrank "
           << "bracket width: " << fabs(current.x - previous.x)
-          <<  ", to < tolerance: " << options().min_step_size
-          << ", with descent_direction_max_norm: "
-          << descent_direction_max_norm << ", and failed to find "
+          << ", to < tolerance: " << options().min_step_size
+          << ", with descent_direction_max_norm: " << descent_direction_max_norm
+          << ", and failed to find "
           << "a point satisfying the strong Wolfe conditions or a "
           << "bracketing containing such a point. Accepting "
           << "point found satisfying Armijo condition only, to "
@@ -609,18 +600,20 @@
       // Check num iterations bound here so that we always evaluate the
       // max_num_iterations-th iteration against all conditions, and
       // then perform no additional (unused) evaluations.
-      summary->error =
-          StringPrintf("Line search failed: Wolfe bracketing phase failed to "
-                       "find a point satisfying strong Wolfe conditions, or a "
-                       "bracket containing such a point within specified "
-                       "max_num_iterations: %d", options().max_num_iterations);
+      summary->error = StringPrintf(
+          "Line search failed: Wolfe bracketing phase failed to "
+          "find a point satisfying strong Wolfe conditions, or a "
+          "bracket containing such a point within specified "
+          "max_num_iterations: %d",
+          options().max_num_iterations);
       LOG_IF(WARNING, !options().is_silent) << summary->error;
       // Ensure that bracket_low is always set to the step size amongst all
       // those tested which minimizes f() and satisfies the Armijo condition
       // when we terminate due to the 'artificial' max_num_iterations condition.
       *bracket_low =
           current.value_is_valid && current.value < bracket_low->value
-          ? current : *bracket_low;
+              ? current
+              : *bracket_low;
       break;
     }
     // Either: f(current) is invalid; or, f(current) is valid, but does not
@@ -632,17 +625,16 @@
     // size.
     //
     // In Nocedal & Wright [1] (p60), the step-size can only increase in the
-    // bracketing phase: step_size_{k+1} \in [step_size_k, step_size_k * factor].
-    // However this does not account for the function returning invalid values
-    // which we support, in which case we need to contract the step size whilst
-    // ensuring that we do not invert the bracket, i.e, we require that:
+    // bracketing phase: step_size_{k+1} \in [step_size_k, step_size_k *
+    // factor]. However this does not account for the function returning invalid
+    // values which we support, in which case we need to contract the step size
+    // whilst ensuring that we do not invert the bracket, i.e, we require that:
     // step_size_{k-1} <= step_size_{k+1} < step_size_k.
     const double min_step_size =
-        current.value_is_valid
-        ? current.x : previous.x;
+        current.value_is_valid ? current.x : previous.x;
     const double max_step_size =
-        current.value_is_valid
-        ? (current.x * options().max_step_expansion) : current.x;
+        current.value_is_valid ? (current.x * options().max_step_expansion)
+                               : current.x;
 
     // We are performing 2-point interpolation only here, but the API of
     // InterpolatingPolynomialMinimizingStepSize() allows for up to
@@ -652,21 +644,21 @@
     DCHECK(!unused_previous.value_is_valid);
     // Contracts step size if f(current) is not valid.
     const double polynomial_minimization_start_time = WallTimeInSeconds();
-    const double step_size =
-        this->InterpolatingPolynomialMinimizingStepSize(
-            options().interpolation_type,
-            previous,
-            unused_previous,
-            current,
-            min_step_size,
-            max_step_size);
+    const double step_size = this->InterpolatingPolynomialMinimizingStepSize(
+        options().interpolation_type,
+        previous,
+        unused_previous,
+        current,
+        min_step_size,
+        max_step_size);
     summary->polynomial_minimization_time_in_seconds +=
         (WallTimeInSeconds() - polynomial_minimization_start_time);
     if (step_size * descent_direction_max_norm < options().min_step_size) {
-      summary->error =
-          StringPrintf("Line search failed: step_size too small: %.5e "
-                       "with descent_direction_max_norm: %.5e", step_size,
-                       descent_direction_max_norm);
+      summary->error = StringPrintf(
+          "Line search failed: step_size too small: %.5e "
+          "with descent_direction_max_norm: %.5e",
+          step_size,
+          descent_direction_max_norm);
       LOG_IF(WARNING, !options().is_silent) << summary->error;
       return false;
     }
@@ -684,8 +676,8 @@
   // Ensure that even if a valid bracket was found, we will only mark a zoom
   // as required if the bracket's width is greater than our minimum tolerance.
   if (*do_zoom_search &&
-      fabs(bracket_high->x - bracket_low->x) * descent_direction_max_norm
-      < options().min_step_size) {
+      fabs(bracket_high->x - bracket_low->x) * descent_direction_max_norm <
+          options().min_step_size) {
     *do_zoom_search = false;
   }
 
@@ -707,8 +699,7 @@
       << std::scientific << std::setprecision(kErrorMessageNumericPrecision)
       << "Ceres bug: f_low input to Wolfe Zoom invalid, please contact "
       << "the developers!, initial_position: " << initial_position
-      << ", bracket_low: " << bracket_low
-      << ", bracket_high: "<< bracket_high;
+      << ", bracket_low: " << bracket_low << ", bracket_high: " << bracket_high;
   // We do not require bracket_high.gradient_is_valid as the gradient condition
   // for a valid bracket is only dependent upon bracket_low.gradient, and
   // in order to minimize jacobian evaluations, bracket_high.gradient may
@@ -725,8 +716,7 @@
       << std::scientific << std::setprecision(kErrorMessageNumericPrecision)
       << "Ceres bug: f_high input to Wolfe Zoom invalid, please "
       << "contact the developers!, initial_position: " << initial_position
-      << ", bracket_low: " << bracket_low
-      << ", bracket_high: "<< bracket_high;
+      << ", bracket_low: " << bracket_low << ", bracket_high: " << bracket_high;
 
   if (bracket_low.gradient * (bracket_high.x - bracket_low.x) >= 0) {
     // The third condition for a valid initial bracket:
@@ -738,17 +728,17 @@
     // returns inconsistent gradient values relative to the function values,
     // we do not CHECK_LT(), but we do stop processing and return an invalid
     // value.
-    summary->error =
-        StringPrintf("Line search failed: Wolfe zoom phase passed a bracket "
-                     "which does not satisfy: bracket_low.gradient * "
-                     "(bracket_high.x - bracket_low.x) < 0 [%.8e !< 0] "
-                     "with initial_position: %s, bracket_low: %s, bracket_high:"
-                     " %s, the most likely cause of which is the cost function "
-                     "returning inconsistent gradient & function values.",
-                     bracket_low.gradient * (bracket_high.x - bracket_low.x),
-                     initial_position.ToDebugString().c_str(),
-                     bracket_low.ToDebugString().c_str(),
-                     bracket_high.ToDebugString().c_str());
+    summary->error = StringPrintf(
+        "Line search failed: Wolfe zoom phase passed a bracket "
+        "which does not satisfy: bracket_low.gradient * "
+        "(bracket_high.x - bracket_low.x) < 0 [%.8e !< 0] "
+        "with initial_position: %s, bracket_low: %s, bracket_high:"
+        " %s, the most likely cause of which is the cost function "
+        "returning inconsistent gradient & function values.",
+        bracket_low.gradient * (bracket_high.x - bracket_low.x),
+        initial_position.ToDebugString().c_str(),
+        bracket_low.ToDebugString().c_str(),
+        bracket_high.ToDebugString().c_str());
     LOG_IF(WARNING, !options().is_silent) << summary->error;
     solution->value_is_valid = false;
     return false;
@@ -763,24 +753,25 @@
     // not satisfy the Wolfe condition.
     *solution = bracket_low;
     if (summary->num_iterations >= options().max_num_iterations) {
-      summary->error =
-          StringPrintf("Line search failed: Wolfe zoom phase failed to "
-                       "find a point satisfying strong Wolfe conditions "
-                       "within specified max_num_iterations: %d, "
-                       "(num iterations taken for bracketing: %d).",
-                       options().max_num_iterations, num_bracketing_iterations);
+      summary->error = StringPrintf(
+          "Line search failed: Wolfe zoom phase failed to "
+          "find a point satisfying strong Wolfe conditions "
+          "within specified max_num_iterations: %d, "
+          "(num iterations taken for bracketing: %d).",
+          options().max_num_iterations,
+          num_bracketing_iterations);
       LOG_IF(WARNING, !options().is_silent) << summary->error;
       return false;
     }
-    if (fabs(bracket_high.x - bracket_low.x) * descent_direction_max_norm
-        < options().min_step_size) {
+    if (fabs(bracket_high.x - bracket_low.x) * descent_direction_max_norm <
+        options().min_step_size) {
       // Bracket width has been reduced below tolerance, and no point satisfying
       // the strong Wolfe conditions has been found.
-      summary->error =
-          StringPrintf("Line search failed: Wolfe zoom bracket width: %.5e "
-                       "too small with descent_direction_max_norm: %.5e.",
-                       fabs(bracket_high.x - bracket_low.x),
-                       descent_direction_max_norm);
+      summary->error = StringPrintf(
+          "Line search failed: Wolfe zoom bracket width: %.5e "
+          "too small with descent_direction_max_norm: %.5e.",
+          fabs(bracket_high.x - bracket_low.x),
+          descent_direction_max_norm);
       LOG_IF(WARNING, !options().is_silent) << summary->error;
       return false;
     }
@@ -799,14 +790,13 @@
     const FunctionSample unused_previous;
     DCHECK(!unused_previous.value_is_valid);
     const double polynomial_minimization_start_time = WallTimeInSeconds();
-    const double step_size =
-        this->InterpolatingPolynomialMinimizingStepSize(
-            options().interpolation_type,
-            lower_bound_step,
-            unused_previous,
-            upper_bound_step,
-            lower_bound_step.x,
-            upper_bound_step.x);
+    const double step_size = this->InterpolatingPolynomialMinimizingStepSize(
+        options().interpolation_type,
+        lower_bound_step,
+        unused_previous,
+        upper_bound_step,
+        lower_bound_step.x,
+        upper_bound_step.x);
     summary->polynomial_minimization_time_in_seconds +=
         (WallTimeInSeconds() - polynomial_minimization_start_time);
     // No check on magnitude of step size being too small here as it is
@@ -826,12 +816,14 @@
     const bool kEvaluateGradient = true;
     function->Evaluate(step_size, kEvaluateGradient, solution);
     if (!solution->value_is_valid || !solution->gradient_is_valid) {
-      summary->error =
-          StringPrintf("Line search failed: Wolfe Zoom phase found "
-                       "step_size: %.5e, for which function is invalid, "
-                       "between low_step: %.5e and high_step: %.5e "
-                       "at which function is valid.",
-                       solution->x, bracket_low.x, bracket_high.x);
+      summary->error = StringPrintf(
+          "Line search failed: Wolfe Zoom phase found "
+          "step_size: %.5e, for which function is invalid, "
+          "between low_step: %.5e and high_step: %.5e "
+          "at which function is valid.",
+          solution->x,
+          bracket_low.x,
+          bracket_high.x);
       LOG_IF(WARNING, !options().is_silent) << summary->error;
       return false;
     }
@@ -842,10 +834,9 @@
             << ", bracket_high: " << bracket_high
             << ", minimizing solution: " << *solution;
 
-    if ((solution->value > (initial_position.value
-                            + options().sufficient_decrease
-                            * initial_position.gradient
-                            * solution->x)) ||
+    if ((solution->value > (initial_position.value +
+                            options().sufficient_decrease *
+                                initial_position.gradient * solution->x)) ||
         (solution->value >= bracket_low.value)) {
       // Armijo sufficient decrease not satisfied, or not better
       // than current lowest sample, use as new upper bound.
diff --git a/internal/ceres/line_search.h b/internal/ceres/line_search.h
index d59fd77..634c971 100644
--- a/internal/ceres/line_search.h
+++ b/internal/ceres/line_search.h
@@ -35,6 +35,7 @@
 
 #include <string>
 #include <vector>
+
 #include "ceres/function_sample.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
diff --git a/internal/ceres/line_search_direction.cc b/internal/ceres/line_search_direction.cc
index 1f9d205..74e9d91 100644
--- a/internal/ceres/line_search_direction.cc
+++ b/internal/ceres/line_search_direction.cc
@@ -29,9 +29,10 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/line_search_direction.h"
+
+#include "ceres/internal/eigen.h"
 #include "ceres/line_search_minimizer.h"
 #include "ceres/low_rank_inverse_hessian.h"
-#include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 
 namespace ceres {
@@ -52,9 +53,7 @@
  public:
   NonlinearConjugateGradient(const NonlinearConjugateGradientType type,
                              const double function_tolerance)
-      : type_(type),
-        function_tolerance_(function_tolerance) {
-  }
+      : type_(type), function_tolerance_(function_tolerance) {}
 
   bool NextDirection(const LineSearchMinimizer::State& previous,
                      const LineSearchMinimizer::State& current,
@@ -72,14 +71,14 @@
         break;
       case HESTENES_STIEFEL:
         gradient_change = current.gradient - previous.gradient;
-        beta =  (current.gradient.dot(gradient_change) /
-                 previous.search_direction.dot(gradient_change));
+        beta = (current.gradient.dot(gradient_change) /
+                previous.search_direction.dot(gradient_change));
         break;
       default:
         LOG(FATAL) << "Unknown nonlinear conjugate gradient type: " << type_;
     }
 
-    *search_direction =  -current.gradient + beta * previous.search_direction;
+    *search_direction = -current.gradient + beta * previous.search_direction;
     const double directional_derivative =
         current.gradient.dot(*search_direction);
     if (directional_derivative > -function_tolerance_) {
@@ -144,8 +143,7 @@
 
 class BFGS : public LineSearchDirection {
  public:
-  BFGS(const int num_parameters,
-       const bool use_approximate_eigenvalue_scaling)
+  BFGS(const int num_parameters, const bool use_approximate_eigenvalue_scaling)
       : num_parameters_(num_parameters),
         use_approximate_eigenvalue_scaling_(use_approximate_eigenvalue_scaling),
         initialized_(false),
@@ -212,8 +210,8 @@
     if (delta_x_dot_delta_gradient <=
         kBFGSSecantConditionHessianUpdateTolerance) {
       VLOG(2) << "Skipping BFGS Update, delta_x_dot_delta_gradient too "
-              << "small: " << delta_x_dot_delta_gradient << ", tolerance: "
-              << kBFGSSecantConditionHessianUpdateTolerance
+              << "small: " << delta_x_dot_delta_gradient
+              << ", tolerance: " << kBFGSSecantConditionHessianUpdateTolerance
               << " (Secant condition).";
     } else {
       // Update dense inverse Hessian approximation.
@@ -300,13 +298,13 @@
 
       // Calculate scalar: (1 + \rho_k * y_k' * H_k * y_k)
       const double delta_x_times_delta_x_transpose_scale_factor =
-          (1.0 + (rho_k * delta_gradient.transpose() *
-                  inverse_hessian_.selfadjointView<Eigen::Lower>() *
-                  delta_gradient));
+          (1.0 +
+           (rho_k * delta_gradient.transpose() *
+            inverse_hessian_.selfadjointView<Eigen::Lower>() * delta_gradient));
       // Calculate: B = (1 + \rho_k * y_k' * H_k * y_k) * s_k * s_k'
       Matrix B = Matrix::Zero(num_parameters_, num_parameters_);
-      B.selfadjointView<Eigen::Lower>().
-          rankUpdate(delta_x, delta_x_times_delta_x_transpose_scale_factor);
+      B.selfadjointView<Eigen::Lower>().rankUpdate(
+          delta_x, delta_x_times_delta_x_transpose_scale_factor);
 
       // Finally, update inverse Hessian approximation according to:
       // H_k = H_{k-1} + \rho_k * (B - (A + A')).  Note that (A + A') is
@@ -315,9 +313,8 @@
           rho_k * (B - A - A.transpose());
     }
 
-    *search_direction =
-        inverse_hessian_.selfadjointView<Eigen::Lower>() *
-        (-1.0 * current.gradient);
+    *search_direction = inverse_hessian_.selfadjointView<Eigen::Lower>() *
+                        (-1.0 * current.gradient);
 
     if (search_direction->dot(current.gradient) >= 0.0) {
       LOG(WARNING) << "Numerical failure in BFGS update: inverse Hessian "
@@ -339,16 +336,15 @@
   bool is_positive_definite_;
 };
 
-LineSearchDirection*
-LineSearchDirection::Create(const LineSearchDirection::Options& options) {
+LineSearchDirection* LineSearchDirection::Create(
+    const LineSearchDirection::Options& options) {
   if (options.type == STEEPEST_DESCENT) {
     return new SteepestDescent;
   }
 
   if (options.type == NONLINEAR_CONJUGATE_GRADIENT) {
     return new NonlinearConjugateGradient(
-        options.nonlinear_conjugate_gradient_type,
-        options.function_tolerance);
+        options.nonlinear_conjugate_gradient_type, options.function_tolerance);
   }
 
   if (options.type == ceres::LBFGS) {
diff --git a/internal/ceres/line_search_direction.h b/internal/ceres/line_search_direction.h
index 467578d..2fcf472 100644
--- a/internal/ceres/line_search_direction.h
+++ b/internal/ceres/line_search_direction.h
@@ -47,8 +47,7 @@
           nonlinear_conjugate_gradient_type(FLETCHER_REEVES),
           function_tolerance(1e-12),
           max_lbfgs_rank(20),
-          use_approximate_eigenvalue_bfgs_scaling(true) {
-    }
+          use_approximate_eigenvalue_bfgs_scaling(true) {}
 
     int num_parameters;
     LineSearchDirectionType type;
diff --git a/internal/ceres/line_search_minimizer.cc b/internal/ceres/line_search_minimizer.cc
index 931f56c..5fed73c 100644
--- a/internal/ceres/line_search_minimizer.cc
+++ b/internal/ceres/line_search_minimizer.cc
@@ -41,8 +41,8 @@
 #include "ceres/line_search_minimizer.h"
 
 #include <algorithm>
-#include <cstdlib>
 #include <cmath>
+#include <cstdlib>
 #include <memory>
 #include <string>
 #include <vector>
@@ -88,7 +88,7 @@
                                    Solver::Summary* summary) {
   const bool is_not_silent = !options.is_silent;
   double start_time = WallTimeInSeconds();
-  double iteration_start_time =  start_time;
+  double iteration_start_time = start_time;
 
   CHECK(options.evaluator != nullptr);
   Evaluator* evaluator = options.evaluator.get();
@@ -129,8 +129,9 @@
 
   if (!EvaluateGradientNorms(evaluator, x, &current_state, &summary->message)) {
     summary->termination_type = FAILURE;
-    summary->message = "Initial cost and jacobian evaluation failed. "
-        "More details: " + summary->message;
+    summary->message =
+        "Initial cost and jacobian evaluation failed. More details: " +
+        summary->message;
     LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
     return;
   }
@@ -141,10 +142,10 @@
   iteration_summary.gradient_norm = sqrt(current_state.gradient_squared_norm);
   iteration_summary.gradient_max_norm = current_state.gradient_max_norm;
   if (iteration_summary.gradient_max_norm <= options.gradient_tolerance) {
-    summary->message = StringPrintf("Gradient tolerance reached. "
-                                    "Gradient max norm: %e <= %e",
-                                    iteration_summary.gradient_max_norm,
-                                    options.gradient_tolerance);
+    summary->message =
+        StringPrintf("Gradient tolerance reached. Gradient max norm: %e <= %e",
+                     iteration_summary.gradient_max_norm,
+                     options.gradient_tolerance);
     summary->termination_type = CONVERGENCE;
     VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message;
     return;
@@ -153,8 +154,7 @@
   iteration_summary.iteration_time_in_seconds =
       WallTimeInSeconds() - iteration_start_time;
   iteration_summary.cumulative_time_in_seconds =
-      WallTimeInSeconds() - start_time
-      + summary->preprocessor_time_in_seconds;
+      WallTimeInSeconds() - start_time + summary->preprocessor_time_in_seconds;
   summary->iterations.push_back(iteration_summary);
 
   LineSearchDirection::Options line_search_direction_options;
@@ -189,10 +189,8 @@
   line_search_options.is_silent = options.is_silent;
   line_search_options.function = &line_search_function;
 
-  std::unique_ptr<LineSearch>
-      line_search(LineSearch::Create(options.line_search_type,
-                                     line_search_options,
-                                     &summary->message));
+  std::unique_ptr<LineSearch> line_search(LineSearch::Create(
+      options.line_search_type, line_search_options, &summary->message));
   if (line_search.get() == nullptr) {
     summary->termination_type = FAILURE;
     LOG_IF(ERROR, is_not_silent) << "Terminating: " << summary->message;
@@ -216,7 +214,7 @@
     }
 
     const double total_solver_time = iteration_start_time - start_time +
-        summary->preprocessor_time_in_seconds;
+                                     summary->preprocessor_time_in_seconds;
     if (total_solver_time >= options.max_solver_time_in_seconds) {
       summary->message = "Maximum solver time reached.";
       summary->termination_type = NO_CONVERGENCE;
@@ -234,21 +232,19 @@
       current_state.search_direction = -current_state.gradient;
     } else {
       line_search_status = line_search_direction->NextDirection(
-          previous_state,
-          current_state,
-          &current_state.search_direction);
+          previous_state, current_state, &current_state.search_direction);
     }
 
     if (!line_search_status &&
         num_line_search_direction_restarts >=
-        options.max_num_line_search_direction_restarts) {
+            options.max_num_line_search_direction_restarts) {
       // Line search direction failed to generate a new direction, and we
       // have already reached our specified maximum number of restarts,
       // terminate optimization.
-      summary->message =
-          StringPrintf("Line search direction failure: specified "
-                       "max_num_line_search_direction_restarts: %d reached.",
-                       options.max_num_line_search_direction_restarts);
+      summary->message = StringPrintf(
+          "Line search direction failure: specified "
+          "max_num_line_search_direction_restarts: %d reached.",
+          options.max_num_line_search_direction_restarts);
       summary->termination_type = FAILURE;
       LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
       break;
@@ -261,14 +257,12 @@
       ++num_line_search_direction_restarts;
       LOG_IF(WARNING, is_not_silent)
           << "Line search direction algorithm: "
-          << LineSearchDirectionTypeToString(
-              options.line_search_direction_type)
+          << LineSearchDirectionTypeToString(options.line_search_direction_type)
           << ", failed to produce a valid new direction at "
           << "iteration: " << iteration_summary.iteration
           << ". Restarting, number of restarts: "
           << num_line_search_direction_restarts << " / "
-          << options.max_num_line_search_direction_restarts
-          << " [max].";
+          << options.max_num_line_search_direction_restarts << " [max].";
       line_search_direction.reset(
           LineSearchDirection::Create(line_search_direction_options));
       current_state.search_direction = -current_state.gradient;
@@ -286,19 +280,21 @@
     // iteration.
     const double initial_step_size =
         (iteration_summary.iteration == 1 || !line_search_status)
-        ? std::min(1.0, 1.0 / current_state.gradient_max_norm)
-        : std::min(1.0, 2.0 * (current_state.cost - previous_state.cost) /
-                   current_state.directional_derivative);
+            ? std::min(1.0, 1.0 / current_state.gradient_max_norm)
+            : std::min(1.0,
+                       2.0 * (current_state.cost - previous_state.cost) /
+                           current_state.directional_derivative);
     // By definition, we should only ever go forwards along the specified search
     // direction in a line search, most likely cause for this being violated
     // would be a numerical failure in the line search direction calculation.
     if (initial_step_size < 0.0) {
-      summary->message =
-          StringPrintf("Numerical failure in line search, initial_step_size is "
-                       "negative: %.5e, directional_derivative: %.5e, "
-                       "(current_cost - previous_cost): %.5e",
-                       initial_step_size, current_state.directional_derivative,
-                       (current_state.cost - previous_state.cost));
+      summary->message = StringPrintf(
+          "Numerical failure in line search, initial_step_size is "
+          "negative: %.5e, directional_derivative: %.5e, "
+          "(current_cost - previous_cost): %.5e",
+          initial_step_size,
+          current_state.directional_derivative,
+          (current_state.cost - previous_state.cost));
       summary->termination_type = FAILURE;
       LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
       break;
@@ -309,13 +305,14 @@
                         current_state.directional_derivative,
                         &line_search_summary);
     if (!line_search_summary.success) {
-      summary->message =
-          StringPrintf("Numerical failure in line search, failed to find "
-                       "a valid step size, (did not run out of iterations) "
-                       "using initial_step_size: %.5e, initial_cost: %.5e, "
-                       "initial_gradient: %.5e.",
-                       initial_step_size, current_state.cost,
-                       current_state.directional_derivative);
+      summary->message = StringPrintf(
+          "Numerical failure in line search, failed to find "
+          "a valid step size, (did not run out of iterations) "
+          "using initial_step_size: %.5e, initial_cost: %.5e, "
+          "initial_gradient: %.5e.",
+          initial_step_size,
+          current_state.cost,
+          current_state.directional_derivative);
       LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
       summary->termination_type = FAILURE;
       break;
@@ -373,7 +370,7 @@
 
     iteration_summary.step_is_valid = true;
     iteration_summary.step_is_successful = true;
-    iteration_summary.step_size =  current_state.step_size;
+    iteration_summary.step_size = current_state.step_size;
     iteration_summary.line_search_function_evaluations =
         line_search_summary.num_function_evaluations;
     iteration_summary.line_search_gradient_evaluations =
@@ -383,8 +380,8 @@
     iteration_summary.iteration_time_in_seconds =
         WallTimeInSeconds() - iteration_start_time;
     iteration_summary.cumulative_time_in_seconds =
-        WallTimeInSeconds() - start_time
-        + summary->preprocessor_time_in_seconds;
+        WallTimeInSeconds() - start_time +
+        summary->preprocessor_time_in_seconds;
     summary->iterations.push_back(iteration_summary);
 
     // Iterations inside the line search algorithm are considered
@@ -393,7 +390,7 @@
     // minimizer. The number of line search steps is the total number
     // of inner line search iterations (or steps) across the entire
     // minimization.
-    summary->num_line_search_steps +=  line_search_summary.num_iterations;
+    summary->num_line_search_steps += line_search_summary.num_iterations;
     summary->line_search_cost_evaluation_time_in_seconds +=
         line_search_summary.cost_evaluation_time_in_seconds;
     summary->line_search_gradient_evaluation_time_in_seconds +=
@@ -404,25 +401,26 @@
         line_search_summary.total_time_in_seconds;
     ++summary->num_successful_steps;
 
-    const double step_size_tolerance = options.parameter_tolerance *
-                                       (x_norm + options.parameter_tolerance);
+    const double step_size_tolerance =
+        options.parameter_tolerance * (x_norm + options.parameter_tolerance);
     if (iteration_summary.step_norm <= step_size_tolerance) {
-      summary->message =
-          StringPrintf("Parameter tolerance reached. "
-                       "Relative step_norm: %e <= %e.",
-                       (iteration_summary.step_norm /
-                        (x_norm + options.parameter_tolerance)),
-                       options.parameter_tolerance);
+      summary->message = StringPrintf(
+          "Parameter tolerance reached. "
+          "Relative step_norm: %e <= %e.",
+          (iteration_summary.step_norm /
+           (x_norm + options.parameter_tolerance)),
+          options.parameter_tolerance);
       summary->termination_type = CONVERGENCE;
       VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message;
       return;
     }
 
     if (iteration_summary.gradient_max_norm <= options.gradient_tolerance) {
-      summary->message = StringPrintf("Gradient tolerance reached. "
-                                      "Gradient max norm: %e <= %e",
-                                      iteration_summary.gradient_max_norm,
-                                      options.gradient_tolerance);
+      summary->message = StringPrintf(
+          "Gradient tolerance reached. "
+          "Gradient max norm: %e <= %e",
+          iteration_summary.gradient_max_norm,
+          options.gradient_tolerance);
       summary->termination_type = CONVERGENCE;
       VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message;
       break;
diff --git a/internal/ceres/line_search_minimizer.h b/internal/ceres/line_search_minimizer.h
index 191128a..79e8dc9 100644
--- a/internal/ceres/line_search_minimizer.h
+++ b/internal/ceres/line_search_minimizer.h
@@ -31,10 +31,10 @@
 #ifndef CERES_INTERNAL_LINE_SEARCH_MINIMIZER_H_
 #define CERES_INTERNAL_LINE_SEARCH_MINIMIZER_H_
 
+#include "ceres/internal/eigen.h"
 #include "ceres/minimizer.h"
 #include "ceres/solver.h"
 #include "ceres/types.h"
-#include "ceres/internal/eigen.h"
 #include "glog/logging.h"
 
 namespace ceres {
@@ -46,15 +46,13 @@
 class LineSearchMinimizer : public Minimizer {
  public:
   struct State {
-    State(int num_parameters,
-          int num_effective_parameters)
+    State(int num_parameters, int num_effective_parameters)
         : cost(0.0),
           gradient(num_effective_parameters),
           gradient_squared_norm(0.0),
           search_direction(num_effective_parameters),
           directional_derivative(0.0),
-          step_size(0.0) {
-    }
+          step_size(0.0) {}
 
     double cost;
     Vector gradient;
diff --git a/internal/ceres/line_search_minimizer_test.cc b/internal/ceres/line_search_minimizer_test.cc
index 86623b0..2ef27b9 100644
--- a/internal/ceres/line_search_minimizer_test.cc
+++ b/internal/ceres/line_search_minimizer_test.cc
@@ -43,7 +43,6 @@
   bool Evaluate(const double* parameters,
                 double* cost,
                 double* gradient) const final {
-
     cost[0] = parameters[0] * parameters[0];
     if (gradient != NULL) {
       gradient[0] = 2.0 * parameters[0];
diff --git a/internal/ceres/line_search_preprocessor.cc b/internal/ceres/line_search_preprocessor.cc
index 5a21809..6a69425 100644
--- a/internal/ceres/line_search_preprocessor.cc
+++ b/internal/ceres/line_search_preprocessor.cc
@@ -32,6 +32,7 @@
 
 #include <numeric>
 #include <string>
+
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
 #include "ceres/evaluator.h"
@@ -62,16 +63,14 @@
   pp->evaluator_options.context = pp->problem->context();
   pp->evaluator_options.evaluation_callback =
       pp->reduced_program->mutable_evaluation_callback();
-  pp->evaluator.reset(Evaluator::Create(pp->evaluator_options,
-                                        pp->reduced_program.get(),
-                                        &pp->error));
+  pp->evaluator.reset(Evaluator::Create(
+      pp->evaluator_options, pp->reduced_program.get(), &pp->error));
   return (pp->evaluator.get() != NULL);
 }
 
 }  // namespace
 
-LineSearchPreprocessor::~LineSearchPreprocessor() {
-}
+LineSearchPreprocessor::~LineSearchPreprocessor() {}
 
 bool LineSearchPreprocessor::Preprocess(const Solver::Options& options,
                                         ProblemImpl* problem,
@@ -86,10 +85,8 @@
     return false;
   }
 
-  pp->reduced_program.reset(
-      program->CreateReducedProgram(&pp->removed_parameter_blocks,
-                                    &pp->fixed_cost,
-                                    &pp->error));
+  pp->reduced_program.reset(program->CreateReducedProgram(
+      &pp->removed_parameter_blocks, &pp->fixed_cost, &pp->error));
 
   if (pp->reduced_program.get() == NULL) {
     return false;
diff --git a/internal/ceres/line_search_preprocessor_test.cc b/internal/ceres/line_search_preprocessor_test.cc
index 301509c..68860c5 100644
--- a/internal/ceres/line_search_preprocessor_test.cc
+++ b/internal/ceres/line_search_preprocessor_test.cc
@@ -28,9 +28,10 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/line_search_preprocessor.h"
+
 #include <map>
 
-#include "ceres/line_search_preprocessor.h"
 #include "ceres/problem_impl.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/solver.h"
diff --git a/internal/ceres/linear_least_squares_problems.cc b/internal/ceres/linear_least_squares_problems.cc
index 7c523d3..299051c 100644
--- a/internal/ceres/linear_least_squares_problems.cc
+++ b/internal/ceres/linear_least_squares_problems.cc
@@ -101,7 +101,7 @@
 
   int counter = 0;
   for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j< 2; ++j) {
+    for (int j = 0; j < 2; ++j) {
       Ai[counter] = i;
       Aj[counter] = j;
       ++counter;
@@ -132,7 +132,6 @@
   return problem;
 }
 
-
 /*
       A = [1 0  | 2 0 0
            3 0  | 0 4 0
@@ -187,9 +186,8 @@
   int num_cols = 5;
 
   LinearLeastSquaresProblem* problem = new LinearLeastSquaresProblem;
-  TripletSparseMatrix* A = new TripletSparseMatrix(num_rows,
-                                                   num_cols,
-                                                   num_rows * num_cols);
+  TripletSparseMatrix* A =
+      new TripletSparseMatrix(num_rows, num_cols, num_rows * num_cols);
   problem->b.reset(new double[num_rows]);
   problem->D.reset(new double[num_cols]);
   problem->num_eliminate_blocks = 2;
@@ -404,7 +402,6 @@
   return problem;
 }
 
-
 /*
       A = [1 0
            3 0
@@ -620,8 +617,7 @@
   LOG(INFO) << "A^T: \n" << AA.transpose();
 
   if (D != NULL) {
-    LOG(INFO) << "A's appended diagonal:\n"
-              << ConstVectorRef(D, A->num_cols());
+    LOG(INFO) << "A's appended diagonal:\n" << ConstVectorRef(D, A->num_cols());
   }
 
   if (b != NULL) {
@@ -659,10 +655,8 @@
   string matlab_script;
   StringAppendF(&matlab_script,
                 "function lsqp = load_trust_region_problem()\n");
-  StringAppendF(&matlab_script,
-                "lsqp.num_rows = %d;\n", A->num_rows());
-  StringAppendF(&matlab_script,
-                "lsqp.num_cols = %d;\n", A->num_cols());
+  StringAppendF(&matlab_script, "lsqp.num_rows = %d;\n", A->num_rows());
+  StringAppendF(&matlab_script, "lsqp.num_cols = %d;\n", A->num_cols());
 
   {
     string filename = filename_base + "_A.txt";
@@ -670,8 +664,8 @@
     CHECK(fptr != nullptr);
     A->ToTextFile(fptr);
     fclose(fptr);
-    StringAppendF(&matlab_script,
-                  "tmp = load('%s', '-ascii');\n", filename.c_str());
+    StringAppendF(
+        &matlab_script, "tmp = load('%s', '-ascii');\n", filename.c_str());
     StringAppendF(
         &matlab_script,
         "lsqp.A = sparse(tmp(:, 1) + 1, tmp(:, 2) + 1, tmp(:, 3), %d, %d);\n",
@@ -679,26 +673,25 @@
         A->num_cols());
   }
 
-
   if (D != NULL) {
     string filename = filename_base + "_D.txt";
     WriteArrayToFileOrDie(filename, D, A->num_cols());
-    StringAppendF(&matlab_script,
-                  "lsqp.D = load('%s', '-ascii');\n", filename.c_str());
+    StringAppendF(
+        &matlab_script, "lsqp.D = load('%s', '-ascii');\n", filename.c_str());
   }
 
   if (b != NULL) {
     string filename = filename_base + "_b.txt";
     WriteArrayToFileOrDie(filename, b, A->num_rows());
-    StringAppendF(&matlab_script,
-                  "lsqp.b = load('%s', '-ascii');\n", filename.c_str());
+    StringAppendF(
+        &matlab_script, "lsqp.b = load('%s', '-ascii');\n", filename.c_str());
   }
 
   if (x != NULL) {
     string filename = filename_base + "_x.txt";
     WriteArrayToFileOrDie(filename, x, A->num_cols());
-    StringAppendF(&matlab_script,
-                  "lsqp.x = load('%s', '-ascii');\n", filename.c_str());
+    StringAppendF(
+        &matlab_script, "lsqp.x = load('%s', '-ascii');\n", filename.c_str());
   }
 
   string matlab_filename = filename_base + ".m";
@@ -716,12 +709,11 @@
                                    int num_eliminate_blocks) {
   switch (dump_format_type) {
     case CONSOLE:
-      return DumpLinearLeastSquaresProblemToConsole(A, D, b, x,
-                                                    num_eliminate_blocks);
+      return DumpLinearLeastSquaresProblemToConsole(
+          A, D, b, x, num_eliminate_blocks);
     case TEXTFILE:
-      return DumpLinearLeastSquaresProblemToTextFile(filename_base,
-                                                     A, D, b, x,
-                                                     num_eliminate_blocks);
+      return DumpLinearLeastSquaresProblemToTextFile(
+          filename_base, A, D, b, x, num_eliminate_blocks);
     default:
       LOG(FATAL) << "Unknown DumpFormatType " << dump_format_type;
   }
diff --git a/internal/ceres/linear_least_squares_problems.h b/internal/ceres/linear_least_squares_problems.h
index 5dfcd34..939c2b4 100644
--- a/internal/ceres/linear_least_squares_problems.h
+++ b/internal/ceres/linear_least_squares_problems.h
@@ -34,8 +34,9 @@
 #include <memory>
 #include <string>
 #include <vector>
-#include "ceres/sparse_matrix.h"
+
 #include "ceres/internal/port.h"
+#include "ceres/sparse_matrix.h"
 
 namespace ceres {
 namespace internal {
@@ -43,9 +44,7 @@
 // Structure defining a linear least squares problem and if possible
 // ground truth solutions. To be used by various LinearSolver tests.
 struct LinearLeastSquaresProblem {
-  LinearLeastSquaresProblem()
-      : num_eliminate_blocks(0) {
-  }
+  LinearLeastSquaresProblem() : num_eliminate_blocks(0) {}
 
   std::unique_ptr<SparseMatrix> A;
   std::unique_ptr<double[]> b;
diff --git a/internal/ceres/linear_operator.cc b/internal/ceres/linear_operator.cc
index 9d291bd..548c724 100644
--- a/internal/ceres/linear_operator.cc
+++ b/internal/ceres/linear_operator.cc
@@ -33,8 +33,7 @@
 namespace ceres {
 namespace internal {
 
-LinearOperator::~LinearOperator() {
-}
+LinearOperator::~LinearOperator() {}
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/linear_solver.cc b/internal/ceres/linear_solver.cc
index 107af6a..6cae248 100644
--- a/internal/ceres/linear_solver.cc
+++ b/internal/ceres/linear_solver.cc
@@ -33,9 +33,9 @@
 #include "ceres/cgnr_solver.h"
 #include "ceres/dense_normal_cholesky_solver.h"
 #include "ceres/dense_qr_solver.h"
+#include "ceres/dynamic_sparse_normal_cholesky_solver.h"
 #include "ceres/iterative_schur_complement_solver.h"
 #include "ceres/schur_complement_solver.h"
-#include "ceres/dynamic_sparse_normal_cholesky_solver.h"
 #include "ceres/sparse_normal_cholesky_solver.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
@@ -43,8 +43,7 @@
 namespace ceres {
 namespace internal {
 
-LinearSolver::~LinearSolver() {
-}
+LinearSolver::~LinearSolver() {}
 
 LinearSolverType LinearSolver::LinearSolverForZeroEBlocks(
     LinearSolverType linear_solver_type) {
@@ -112,8 +111,7 @@
       return new DenseNormalCholeskySolver(options);
 
     default:
-      LOG(FATAL) << "Unknown linear solver type :"
-                 << options.type;
+      LOG(FATAL) << "Unknown linear solver type :" << options.type;
       return NULL;  // MSVC doesn't understand that LOG(FATAL) never returns.
   }
 }
diff --git a/internal/ceres/linear_solver.h b/internal/ceres/linear_solver.h
index cb624b3..47684e7 100644
--- a/internal/ceres/linear_solver.h
+++ b/internal/ceres/linear_solver.h
@@ -38,6 +38,7 @@
 #include <map>
 #include <string>
 #include <vector>
+
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
@@ -74,11 +75,11 @@
 // algebra library should use before computing a sparse factorization
 // (usually Cholesky).
 enum OrderingType {
-  NATURAL, // Do not re-order the matrix. This is useful when the
-           // matrix has been ordered using a fill-reducing ordering
-           // already.
-  AMD      // Use the Approximate Minimum Degree algorithm to re-order
-           // the matrix.
+  NATURAL,  // Do not re-order the matrix. This is useful when the
+            // matrix has been ordered using a fill-reducing ordering
+            // already.
+  AMD       // Use the Approximate Minimum Degree algorithm to re-order
+            // the matrix.
 };
 
 class LinearOperator;
@@ -215,7 +216,6 @@
     // used a preconditioner.
     LinearOperator* preconditioner = nullptr;
 
-
     // The following tolerance related options only makes sense for
     // iterative solvers. Direct solvers ignore them.
 
@@ -329,10 +329,12 @@
 
 // Linear solvers that depend on acccess to the low level structure of
 // a SparseMatrix.
+// clang-format off
 typedef TypedLinearSolver<BlockSparseMatrix>         BlockSparseMatrixSolver;          // NOLINT
 typedef TypedLinearSolver<CompressedRowSparseMatrix> CompressedRowSparseMatrixSolver;  // NOLINT
 typedef TypedLinearSolver<DenseSparseMatrix>         DenseSparseMatrixSolver;          // NOLINT
 typedef TypedLinearSolver<TripletSparseMatrix>       TripletSparseMatrixSolver;        // NOLINT
+// clang-format on
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/loss_function.cc b/internal/ceres/loss_function.cc
index 2c21a73..353f29a 100644
--- a/internal/ceres/loss_function.cc
+++ b/internal/ceres/loss_function.cc
@@ -52,7 +52,7 @@
     const double r = sqrt(s);
     rho[0] = 2.0 * a_ * r - b_;
     rho[1] = std::max(std::numeric_limits<double>::min(), a_ / r);
-    rho[2] = - rho[1] / (2.0 * s);
+    rho[2] = -rho[1] / (2.0 * s);
   } else {
     // Inlier region.
     rho[0] = s;
@@ -67,7 +67,7 @@
   // 'sum' and 'tmp' are always positive, assuming that 's' is.
   rho[0] = 2.0 * b_ * (tmp - 1.0);
   rho[1] = std::max(std::numeric_limits<double>::min(), 1.0 / tmp);
-  rho[2] = - (c_ * rho[1]) / (2.0 * sum);
+  rho[2] = -(c_ * rho[1]) / (2.0 * sum);
 }
 
 void CauchyLoss::Evaluate(double s, double rho[3]) const {
@@ -76,7 +76,7 @@
   // 'sum' and 'inv' are always positive, assuming that 's' is.
   rho[0] = b_ * log(sum);
   rho[1] = std::max(std::numeric_limits<double>::min(), inv);
-  rho[2] = - c_ * (inv * inv);
+  rho[2] = -c_ * (inv * inv);
 }
 
 void ArctanLoss::Evaluate(double s, double rho[3]) const {
@@ -89,9 +89,7 @@
 }
 
 TolerantLoss::TolerantLoss(double a, double b)
-    : a_(a),
-      b_(b),
-      c_(b * log(1.0 + exp(-a / b))) {
+    : a_(a), b_(b), c_(b * log(1.0 + exp(-a / b))) {
   CHECK_GE(a, 0.0);
   CHECK_GT(b, 0.0);
 }
@@ -133,12 +131,11 @@
   }
 }
 
-ComposedLoss::ComposedLoss(const LossFunction* f, Ownership ownership_f,
-                           const LossFunction* g, Ownership ownership_g)
-    : f_(f),
-      g_(g),
-      ownership_f_(ownership_f),
-      ownership_g_(ownership_g) {
+ComposedLoss::ComposedLoss(const LossFunction* f,
+                           Ownership ownership_f,
+                           const LossFunction* g,
+                           Ownership ownership_g)
+    : f_(f), g_(g), ownership_f_(ownership_f), ownership_g_(ownership_g) {
   CHECK(f_ != nullptr);
   CHECK(g_ != nullptr);
 }
diff --git a/internal/ceres/loss_function_test.cc b/internal/ceres/loss_function_test.cc
index 6302dbe..638c0c9 100644
--- a/internal/ceres/loss_function_test.cc
+++ b/internal/ceres/loss_function_test.cc
@@ -66,7 +66,7 @@
   ASSERT_NEAR(fd_1, rho[1], 1e-6);
 
   // Second derivative.
-  const double fd_2 = (fwd[0] - 2*rho[0] + bwd[0]) / (kH * kH);
+  const double fd_2 = (fwd[0] - 2 * rho[0] + bwd[0]) / (kH * kH);
   ASSERT_NEAR(fd_2, rho[2], 1e-6);
 }
 }  // namespace
@@ -219,15 +219,16 @@
     AssertLossFunctionIsValid(scaled_loss, 1.792);
   }
   {
-    ScaledLoss scaled_loss(
-        new TolerantLoss(1.3, 0.1), 10, TAKE_OWNERSHIP);
+    ScaledLoss scaled_loss(new TolerantLoss(1.3, 0.1), 10, TAKE_OWNERSHIP);
     AssertLossFunctionIsValid(scaled_loss, 1.792);
   }
   {
-    ScaledLoss scaled_loss(
-        new ComposedLoss(
-            new HuberLoss(0.8), TAKE_OWNERSHIP,
-            new TolerantLoss(1.3, 0.5), TAKE_OWNERSHIP), 10, TAKE_OWNERSHIP);
+    ScaledLoss scaled_loss(new ComposedLoss(new HuberLoss(0.8),
+                                            TAKE_OWNERSHIP,
+                                            new TolerantLoss(1.3, 0.5),
+                                            TAKE_OWNERSHIP),
+                           10,
+                           TAKE_OWNERSHIP);
     AssertLossFunctionIsValid(scaled_loss, 1.792);
   }
 }
@@ -235,8 +236,7 @@
 TEST(LossFunction, LossFunctionWrapper) {
   // Initialization
   HuberLoss loss_function1(1.0);
-  LossFunctionWrapper loss_function_wrapper(new HuberLoss(1.0),
-                                            TAKE_OWNERSHIP);
+  LossFunctionWrapper loss_function_wrapper(new HuberLoss(1.0), TAKE_OWNERSHIP);
 
   double s = 0.862;
   double rho_gold[3];
@@ -281,7 +281,6 @@
   for (int i = 0; i < 3; ++i) {
     EXPECT_NEAR(rho[i], rho_gold[i], 1e-12);
   }
-
 }
 
 }  // namespace internal
diff --git a/internal/ceres/low_rank_inverse_hessian.cc b/internal/ceres/low_rank_inverse_hessian.cc
index f3953c4..c73e5db 100644
--- a/internal/ceres/low_rank_inverse_hessian.cc
+++ b/internal/ceres/low_rank_inverse_hessian.cc
@@ -28,10 +28,11 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/low_rank_inverse_hessian.h"
+
 #include <list>
 
 #include "ceres/internal/eigen.h"
-#include "ceres/low_rank_inverse_hessian.h"
 #include "glog/logging.h"
 
 namespace ceres {
@@ -84,8 +85,7 @@
       approximate_eigenvalue_scale_(1.0),
       delta_x_history_(num_parameters, max_num_corrections),
       delta_gradient_history_(num_parameters, max_num_corrections),
-      delta_x_dot_delta_gradient_(max_num_corrections) {
-}
+      delta_x_dot_delta_gradient_(max_num_corrections) {}
 
 bool LowRankInverseHessian::Update(const Vector& delta_x,
                                    const Vector& delta_gradient) {
@@ -93,13 +93,12 @@
   if (delta_x_dot_delta_gradient <=
       kLBFGSSecantConditionHessianUpdateTolerance) {
     VLOG(2) << "Skipping L-BFGS Update, delta_x_dot_delta_gradient too "
-            << "small: " << delta_x_dot_delta_gradient << ", tolerance: "
-            << kLBFGSSecantConditionHessianUpdateTolerance
+            << "small: " << delta_x_dot_delta_gradient
+            << ", tolerance: " << kLBFGSSecantConditionHessianUpdateTolerance
             << " (Secant condition).";
     return false;
   }
 
-
   int next = indices_.size();
   // Once the size of the list reaches max_num_corrections_, simulate
   // a circular buffer by removing the first element of the list and
@@ -132,7 +131,7 @@
        it != indices_.rend();
        ++it) {
     const double alpha_i = delta_x_history_.col(*it).dot(search_direction) /
-        delta_x_dot_delta_gradient_(*it);
+                           delta_x_dot_delta_gradient_(*it);
     search_direction -= alpha_i * delta_gradient_history_.col(*it);
     alpha(*it) = alpha_i;
   }
@@ -177,7 +176,7 @@
 
   for (const int i : indices_) {
     const double beta = delta_gradient_history_.col(i).dot(search_direction) /
-        delta_x_dot_delta_gradient_(i);
+                        delta_x_dot_delta_gradient_(i);
     search_direction += delta_x_history_.col(i) * (alpha(i) - beta);
   }
 }
diff --git a/internal/ceres/map_util.h b/internal/ceres/map_util.h
index f55aee3..6e310f8 100644
--- a/internal/ceres/map_util.h
+++ b/internal/ceres/map_util.h
@@ -34,6 +34,7 @@
 #define CERES_INTERNAL_MAP_UTIL_H_
 
 #include <utility>
+
 #include "ceres/internal/port.h"
 #include "glog/logging.h"
 
@@ -55,9 +56,9 @@
 // This version assumes the key is printable, and includes it in the fatal log
 // message.
 template <class Collection>
-const typename Collection::value_type::second_type&
-FindOrDie(const Collection& collection,
-          const typename Collection::value_type::first_type& key) {
+const typename Collection::value_type::second_type& FindOrDie(
+    const Collection& collection,
+    const typename Collection::value_type::first_type& key) {
   typename Collection::const_iterator it = collection.find(key);
   CHECK(it != collection.end()) << "Map key not found: " << key;
   return it->second;
@@ -67,10 +68,10 @@
 // If the key is present in the map then the value associated with that
 // key is returned, otherwise the value passed as a default is returned.
 template <class Collection>
-const typename Collection::value_type::second_type
-FindWithDefault(const Collection& collection,
-                const typename Collection::value_type::first_type& key,
-                const typename Collection::value_type::second_type& value) {
+const typename Collection::value_type::second_type FindWithDefault(
+    const Collection& collection,
+    const typename Collection::value_type::first_type& key,
+    const typename Collection::value_type::second_type& value) {
   typename Collection::const_iterator it = collection.find(key);
   if (it == collection.end()) {
     return value;
@@ -84,7 +85,7 @@
 // took place, false indicates the key was already present.
 template <class Collection>
 bool InsertIfNotPresent(
-    Collection * const collection,
+    Collection* const collection,
     const typename Collection::value_type::first_type& key,
     const typename Collection::value_type::second_type& value) {
   std::pair<typename Collection::iterator, bool> ret =
@@ -96,9 +97,9 @@
 // Same as above but the returned pointer is not const and can be used to change
 // the stored value.
 template <class Collection>
-typename Collection::value_type::second_type*
-FindOrNull(Collection& collection,  // NOLINT
-           const typename Collection::value_type::first_type& key) {
+typename Collection::value_type::second_type* FindOrNull(
+    Collection& collection,  // NOLINT
+    const typename Collection::value_type::first_type& key) {
   typename Collection::iterator it = collection.find(key);
   if (it == collection.end()) {
     return 0;
@@ -116,13 +117,13 @@
 
 // Inserts a new key/value into a map or hash_map.
 // Dies if the key is already present.
-template<class Collection>
+template <class Collection>
 void InsertOrDie(Collection* const collection,
                  const typename Collection::value_type::first_type& key,
                  const typename Collection::value_type::second_type& data) {
   typedef typename Collection::value_type value_type;
   CHECK(collection->insert(value_type(key, data)).second)
-    << "duplicate key: " << key;
+      << "duplicate key: " << key;
 }
 
 }  // namespace ceres
diff --git a/internal/ceres/miniglog/glog/logging.cc b/internal/ceres/miniglog/glog/logging.cc
index 372ecb0..0863f61 100644
--- a/internal/ceres/miniglog/glog/logging.cc
+++ b/internal/ceres/miniglog/glog/logging.cc
@@ -34,6 +34,6 @@
 
 // This is the set of log sinks. This must be in a separate library to ensure
 // that there is only one instance of this across the entire program.
-std::set<google::LogSink *> log_sinks_global;
+std::set<google::LogSink*> log_sinks_global;
 
-}  // namespace ceres
+}  // namespace google
diff --git a/internal/ceres/miniglog/glog/logging.h b/internal/ceres/miniglog/glog/logging.h
index 0fdf382..b442d08 100644
--- a/internal/ceres/miniglog/glog/logging.h
+++ b/internal/ceres/miniglog/glog/logging.h
@@ -93,7 +93,7 @@
 #define CERCES_INTERNAL_MINIGLOG_GLOG_LOGGING_H_
 
 #ifdef ANDROID
-#  include <android/log.h>
+#include <android/log.h>
 #endif  // ANDROID
 
 #include <algorithm>
@@ -106,24 +106,28 @@
 #include <vector>
 
 // For appropriate definition of CERES_EXPORT macro.
-#include "ceres/internal/port.h"
 #include "ceres/internal/disable_warnings.h"
+#include "ceres/internal/port.h"
 
 // Log severity level constants.
+// clang-format off
 const int FATAL   = -3;
 const int ERROR   = -2;
 const int WARNING = -1;
 const int INFO    =  0;
+// clang-format on
 
 // ------------------------- Glog compatibility ------------------------------
 
 namespace google {
 
 typedef int LogSeverity;
+// clang-format off
 const int INFO    = ::INFO;
 const int WARNING = ::WARNING;
 const int ERROR   = ::ERROR;
 const int FATAL   = ::FATAL;
+// clang-format on
 
 // Sink class used for integration with mock and test functions. If sinks are
 // added, all log output is also sent to each sink through the send function.
@@ -143,20 +147,18 @@
 };
 
 // Global set of log sinks. The actual object is defined in logging.cc.
-extern CERES_EXPORT std::set<LogSink *> log_sinks_global;
+extern CERES_EXPORT std::set<LogSink*> log_sinks_global;
 
-inline void InitGoogleLogging(char *argv) {
+inline void InitGoogleLogging(char* argv) {
   // Do nothing; this is ignored.
 }
 
 // Note: the Log sink functions are not thread safe.
-inline void AddLogSink(LogSink *sink) {
+inline void AddLogSink(LogSink* sink) {
   // TODO(settinger): Add locks for thread safety.
   log_sinks_global.insert(sink);
 }
-inline void RemoveLogSink(LogSink *sink) {
-  log_sinks_global.erase(sink);
-}
+inline void RemoveLogSink(LogSink* sink) { log_sinks_global.erase(sink); }
 
 }  // namespace google
 
@@ -170,8 +172,8 @@
 // use of the log macros LG, LOG, or VLOG.
 class CERES_EXPORT MessageLogger {
  public:
-  MessageLogger(const char *file, int line, const char *tag, int severity)
-    : file_(file), line_(line), tag_(tag), severity_(severity) {
+  MessageLogger(const char* file, int line, const char* tag, int severity)
+      : file_(file), line_(line), tag_(tag), severity_(severity) {
     // Pre-pend the stream with the file and line number.
     StripBasename(std::string(file), &filename_only_);
     stream_ << filename_only_ << ":" << line << " ";
@@ -193,8 +195,8 @@
 
     // Bound the logging level.
     const int kMaxVerboseLevel = 2;
-    int android_level_index = std::min(std::max(FATAL, severity_),
-                                       kMaxVerboseLevel) - FATAL;
+    int android_level_index =
+        std::min(std::max(FATAL, severity_), kMaxVerboseLevel) - FATAL;
     int android_log_level = android_log_levels[android_level_index];
 
     // Output the log string the Android log at the appropriate level.
@@ -202,9 +204,7 @@
 
     // Indicate termination if needed.
     if (severity_ == FATAL) {
-      __android_log_write(ANDROID_LOG_FATAL,
-                          tag_.c_str(),
-                          "terminating.\n");
+      __android_log_write(ANDROID_LOG_FATAL, tag_.c_str(), "terminating.\n");
     }
 #else
     // If not building on Android, log all output to std::cerr.
@@ -222,12 +222,12 @@
   }
 
   // Return the stream associated with the logger object.
-  std::stringstream &stream() { return stream_; }
+  std::stringstream& stream() { return stream_; }
 
  private:
   void LogToSinks(int severity) {
     time_t rawtime;
-    time (&rawtime);
+    time(&rawtime);
 
     struct tm timeinfo;
 #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
@@ -241,24 +241,31 @@
     std::set<google::LogSink*>::iterator iter;
     // Send the log message to all sinks.
     for (iter = google::log_sinks_global.begin();
-         iter != google::log_sinks_global.end(); ++iter) {
-      (*iter)->send(severity, file_.c_str(), filename_only_.c_str(), line_,
-                    &timeinfo, stream_.str().c_str(), stream_.str().size());
+         iter != google::log_sinks_global.end();
+         ++iter) {
+      (*iter)->send(severity,
+                    file_.c_str(),
+                    filename_only_.c_str(),
+                    line_,
+                    &timeinfo,
+                    stream_.str().c_str(),
+                    stream_.str().size());
     }
   }
 
   void WaitForSinks() {
     // TODO(settinger): Add locks for thread safety.
-    std::set<google::LogSink *>::iterator iter;
+    std::set<google::LogSink*>::iterator iter;
 
     // Call WaitTillSent() for all sinks.
     for (iter = google::log_sinks_global.begin();
-         iter != google::log_sinks_global.end(); ++iter) {
+         iter != google::log_sinks_global.end();
+         ++iter) {
       (*iter)->WaitTillSent();
     }
   }
 
-  void StripBasename(const std::string &full_path, std::string *filename) {
+  void StripBasename(const std::string& full_path, std::string* filename) {
     // TODO(settinger): Add support for OSs with different path separators.
     const char kSeparator = '/';
     size_t pos = full_path.rfind(kSeparator);
@@ -284,16 +291,18 @@
 // is not used" and "statement has no effect".
 class CERES_EXPORT LoggerVoidify {
  public:
-  LoggerVoidify() { }
+  LoggerVoidify() {}
   // This has to be an operator with a precedence lower than << but
   // higher than ?:
-  void operator&(const std::ostream &s) { }
+  void operator&(const std::ostream& s) {}
 };
 
 // Log only if condition is met.  Otherwise evaluates to void.
+// clang-format off
 #define LOG_IF(severity, condition) \
     !(condition) ? (void) 0 : LoggerVoidify() & \
       MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()
+// clang-format on
 
 // Log only if condition is NOT met.  Otherwise evaluates to void.
 #define LOG_IF_FALSE(severity, condition) LOG_IF(severity, !(condition))
@@ -301,6 +310,7 @@
 // LG is a convenient shortcut for LOG(INFO). Its use is in new
 // google3 code is discouraged and the following shortcut exists for
 // backward compatibility with existing code.
+// clang-format off
 #ifdef MAX_LOG_LEVEL
 #  define LOG(n)  LOG_IF(n, n <= MAX_LOG_LEVEL)
 #  define VLOG(n) LOG_IF(n, n <= MAX_LOG_LEVEL)
@@ -326,37 +336,39 @@
 #  define DLOG(severity) true ? (void) 0 : LoggerVoidify() & \
       MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()
 #endif
-
+// clang-format on
 
 // Log a message and terminate.
-template<class T>
-void LogMessageFatal(const char *file, int line, const T &message) {
-  MessageLogger((char *)__FILE__, __LINE__, "native", FATAL).stream()
-      << message;
+template <class T>
+void LogMessageFatal(const char* file, int line, const T& message) {
+  MessageLogger((char*)__FILE__, __LINE__, "native", FATAL).stream() << message;
 }
 
 // ---------------------------- CHECK macros ---------------------------------
 
 // Check for a given boolean condition.
-#define CHECK(condition) LOG_IF_FALSE(FATAL, condition) \
-        << "Check failed: " #condition " "
+#define CHECK(condition) \
+  LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
 
 #ifndef NDEBUG
 // Debug only version of CHECK
-#  define DCHECK(condition) LOG_IF_FALSE(FATAL, condition) \
-          << "Check failed: " #condition " "
+#define DCHECK(condition) \
+  LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
 #else
 // Optimized version - generates no code.
-#  define DCHECK(condition) if (false) LOG_IF_FALSE(FATAL, condition) \
-          << "Check failed: " #condition " "
+#define DCHECK(condition) \
+  if (false) LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
 #endif  // NDEBUG
 
 // ------------------------- CHECK_OP macros ---------------------------------
 
 // Generic binary operator check macro. This should not be directly invoked,
 // instead use the binary comparison macros defined below.
-#define CHECK_OP(val1, val2, op) LOG_IF_FALSE(FATAL, ((val1) op (val2))) \
-  << "Check failed: " #val1 " " #op " " #val2 " "
+#define CHECK_OP(val1, val2, op)        \
+  LOG_IF_FALSE(FATAL, ((val1)op(val2))) \
+      << "Check failed: " #val1 " " #op " " #val2 " "
+
+// clang-format off
 
 // Check_op macro definitions
 #define CHECK_EQ(val1, val2) CHECK_OP(val1, val2, ==)
@@ -384,12 +396,14 @@
 #  define DCHECK_GT(val1, val2) if (false) CHECK_OP(val1, val2, >)
 #endif  // NDEBUG
 
+// clang-format on
+
 // ---------------------------CHECK_NOTNULL macros ---------------------------
 
 // Helpers for CHECK_NOTNULL(). Two are necessary to support both raw pointers
 // and smart pointers.
 template <typename T>
-T& CheckNotNullCommon(const char *file, int line, const char *names, T& t) {
+T& CheckNotNullCommon(const char* file, int line, const char* names, T& t) {
   if (t == NULL) {
     LogMessageFatal(file, line, std::string(names));
   }
@@ -397,12 +411,12 @@
 }
 
 template <typename T>
-T* CheckNotNull(const char *file, int line, const char *names, T* t) {
+T* CheckNotNull(const char* file, int line, const char* names, T* t) {
   return CheckNotNullCommon(file, line, names, t);
 }
 
 template <typename T>
-T& CheckNotNull(const char *file, int line, const char *names, T& t) {
+T& CheckNotNull(const char* file, int line, const char* names, T& t) {
   return CheckNotNullCommon(file, line, names, t);
 }
 
@@ -416,7 +430,8 @@
   CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))
 #else
 // Optimized version - generates no code.
-#define DCHECK_NOTNULL(val) if (false)\
+#define DCHECK_NOTNULL(val) \
+  if (false)                \
   CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))
 #endif  // NDEBUG
 
diff --git a/internal/ceres/minimizer.cc b/internal/ceres/minimizer.cc
index f596033..4943a75 100644
--- a/internal/ceres/minimizer.cc
+++ b/internal/ceres/minimizer.cc
@@ -28,8 +28,9 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-#include "ceres/line_search_minimizer.h"
 #include "ceres/minimizer.h"
+
+#include "ceres/line_search_minimizer.h"
 #include "ceres/trust_region_minimizer.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
@@ -50,7 +51,6 @@
   return NULL;
 }
 
-
 Minimizer::~Minimizer() {}
 
 bool Minimizer::RunCallbacks(const Minimizer::Options& options,
diff --git a/internal/ceres/minimizer.h b/internal/ceres/minimizer.h
index afdd60d..69416b3 100644
--- a/internal/ceres/minimizer.h
+++ b/internal/ceres/minimizer.h
@@ -34,6 +34,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+
 #include "ceres/internal/port.h"
 #include "ceres/iteration_callback.h"
 #include "ceres/solver.h"
@@ -54,13 +55,9 @@
   // see solver.h for detailed information about the meaning and
   // default values of each of these parameters.
   struct Options {
-    Options() {
-      Init(Solver::Options());
-    }
+    Options() { Init(Solver::Options()); }
 
-    explicit Options(const Solver::Options& options) {
-      Init(options);
-    }
+    explicit Options(const Solver::Options& options) { Init(options); }
 
     void Init(const Solver::Options& options) {
       num_threads = options.num_threads;
@@ -92,8 +89,7 @@
       max_lbfgs_rank = options.max_lbfgs_rank;
       use_approximate_eigenvalue_bfgs_scaling =
           options.use_approximate_eigenvalue_bfgs_scaling;
-      line_search_interpolation_type =
-          options.line_search_interpolation_type;
+      line_search_interpolation_type = options.line_search_interpolation_type;
       min_line_search_step_size = options.min_line_search_step_size;
       line_search_sufficient_function_decrease =
           options.line_search_sufficient_function_decrease;
@@ -107,8 +103,7 @@
           options.max_num_line_search_direction_restarts;
       line_search_sufficient_curvature_decrease =
           options.line_search_sufficient_curvature_decrease;
-      max_line_search_step_expansion =
-          options.max_line_search_step_expansion;
+      max_line_search_step_expansion = options.max_line_search_step_expansion;
       inner_iteration_tolerance = options.inner_iteration_tolerance;
       is_silent = (options.logging_type == SILENT);
       is_constrained = false;
diff --git a/internal/ceres/minimizer_test.cc b/internal/ceres/minimizer_test.cc
index b0a2d96..3de4abe 100644
--- a/internal/ceres/minimizer_test.cc
+++ b/internal/ceres/minimizer_test.cc
@@ -28,10 +28,11 @@
 //
 // Author: keir@google.com (Keir Mierle)
 
-#include "gtest/gtest.h"
-#include "ceres/iteration_callback.h"
 #include "ceres/minimizer.h"
+
+#include "ceres/iteration_callback.h"
 #include "ceres/solver.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
diff --git a/internal/ceres/normal_prior.cc b/internal/ceres/normal_prior.cc
index a3d5d8e..4a62132 100644
--- a/internal/ceres/normal_prior.cc
+++ b/internal/ceres/normal_prior.cc
@@ -32,14 +32,14 @@
 
 #include <cstddef>
 #include <vector>
+
 #include "ceres/internal/eigen.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
 
 namespace ceres {
 
-NormalPrior::NormalPrior(const Matrix& A, const Vector& b)
-    : A_(A), b_(b) {
+NormalPrior::NormalPrior(const Matrix& A, const Vector& b) : A_(A), b_(b) {
   CHECK_GT(b_.rows(), 0);
   CHECK_GT(A_.rows(), 0);
   CHECK_EQ(b_.rows(), A.cols());
diff --git a/internal/ceres/normal_prior_test.cc b/internal/ceres/normal_prior_test.cc
index 9abbf7f..518c18e 100644
--- a/internal/ceres/normal_prior_test.cc
+++ b/internal/ceres/normal_prior_test.cc
@@ -32,9 +32,9 @@
 
 #include <cstddef>
 
-#include "gtest/gtest.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/random.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -42,8 +42,7 @@
 namespace {
 
 void RandomVector(Vector* v) {
-  for (int r = 0; r < v->rows(); ++r)
-    (*v)[r] = 2 * RandDouble() - 1;
+  for (int r = 0; r < v->rows(); ++r) (*v)[r] = 2 * RandDouble() - 1;
 }
 
 void RandomMatrix(Matrix* m) {
@@ -67,11 +66,10 @@
       Matrix A(num_rows, num_cols);
       RandomMatrix(&A);
 
-      double * x = new double[num_cols];
-      for (int i = 0; i < num_cols; ++i)
-        x[i] = 2 * RandDouble() - 1;
+      double* x = new double[num_cols];
+      for (int i = 0; i < num_cols; ++i) x[i] = 2 * RandDouble() - 1;
 
-      double * jacobian = new double[num_rows * num_cols];
+      double* jacobian = new double[num_rows * num_cols];
       Vector residuals(num_rows);
 
       NormalPrior prior(A, b);
@@ -87,8 +85,8 @@
       double jacobian_diff_norm = (J - A).norm();
       EXPECT_NEAR(jacobian_diff_norm, 0.0, 1e-10);
 
-      delete []x;
-      delete []jacobian;
+      delete[] x;
+      delete[] jacobian;
     }
   }
 }
@@ -104,9 +102,8 @@
       Matrix A(num_rows, num_cols);
       RandomMatrix(&A);
 
-      double * x = new double[num_cols];
-      for (int i = 0; i < num_cols; ++i)
-        x[i] = 2 * RandDouble() - 1;
+      double* x = new double[num_cols];
+      for (int i = 0; i < num_cols; ++i) x[i] = 2 * RandDouble() - 1;
 
       double* jacobians[1];
       jacobians[0] = NULL;
@@ -127,8 +124,7 @@
           (residuals - A * (VectorRef(x, num_cols) - b)).squaredNorm();
       EXPECT_NEAR(residual_diff_norm, 0, 1e-10);
 
-
-      delete []x;
+      delete[] x;
     }
   }
 }
diff --git a/internal/ceres/numeric_diff_cost_function_test.cc b/internal/ceres/numeric_diff_cost_function_test.cc
index 20cf1b2..a5f7a15 100644
--- a/internal/ceres/numeric_diff_cost_function_test.cc
+++ b/internal/ceres/numeric_diff_cost_function_test.cc
@@ -50,39 +50,36 @@
 
 TEST(NumericDiffCostFunction, EasyCaseFunctorCentralDifferences) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<EasyFunctor,
-                                  CENTRAL,
-                                  3,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new EasyFunctor));
+  cost_function.reset(new NumericDiffCostFunction<EasyFunctor,
+                                                  CENTRAL,
+                                                  3,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(new EasyFunctor));
   EasyFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
 }
 
 TEST(NumericDiffCostFunction, EasyCaseFunctorForwardDifferences) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<EasyFunctor,
-                                  FORWARD,
-                                  3,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new EasyFunctor));
+  cost_function.reset(new NumericDiffCostFunction<EasyFunctor,
+                                                  FORWARD,
+                                                  3,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(new EasyFunctor));
   EasyFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
 }
 
 TEST(NumericDiffCostFunction, EasyCaseFunctorRidders) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<EasyFunctor,
-                                  RIDDERS,
-                                  3,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new EasyFunctor));
+  cost_function.reset(new NumericDiffCostFunction<EasyFunctor,
+                                                  RIDDERS,
+                                                  3,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(new EasyFunctor));
   EasyFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
 }
@@ -92,10 +89,10 @@
   cost_function.reset(
       new NumericDiffCostFunction<EasyCostFunction,
                                   CENTRAL,
-                                  3,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new EasyCostFunction, TAKE_OWNERSHIP));
+                                  3,  // number of residuals
+                                  5,  // size of x1
+                                  5   // size of x2
+                                  >(new EasyCostFunction, TAKE_OWNERSHIP));
   EasyFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
 }
@@ -105,10 +102,10 @@
   cost_function.reset(
       new NumericDiffCostFunction<EasyCostFunction,
                                   FORWARD,
-                                  3,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new EasyCostFunction, TAKE_OWNERSHIP));
+                                  3,  // number of residuals
+                                  5,  // size of x1
+                                  5   // size of x2
+                                  >(new EasyCostFunction, TAKE_OWNERSHIP));
   EasyFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
 }
@@ -118,44 +115,39 @@
   cost_function.reset(
       new NumericDiffCostFunction<EasyCostFunction,
                                   RIDDERS,
-                                  3,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new EasyCostFunction, TAKE_OWNERSHIP));
+                                  3,  // number of residuals
+                                  5,  // size of x1
+                                  5   // size of x2
+                                  >(new EasyCostFunction, TAKE_OWNERSHIP));
   EasyFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
 }
 
-TEST(NumericDiffCostFunction,
-     TranscendentalCaseFunctorCentralDifferences) {
+TEST(NumericDiffCostFunction, TranscendentalCaseFunctorCentralDifferences) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<TranscendentalFunctor,
-                                  CENTRAL,
-                                  2,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new TranscendentalFunctor));
+  cost_function.reset(new NumericDiffCostFunction<TranscendentalFunctor,
+                                                  CENTRAL,
+                                                  2,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(new TranscendentalFunctor));
   TranscendentalFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
 }
 
-TEST(NumericDiffCostFunction,
-     TranscendentalCaseFunctorForwardDifferences) {
+TEST(NumericDiffCostFunction, TranscendentalCaseFunctorForwardDifferences) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<TranscendentalFunctor,
-                                  FORWARD,
-                                  2,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new TranscendentalFunctor));
+  cost_function.reset(new NumericDiffCostFunction<TranscendentalFunctor,
+                                                  FORWARD,
+                                                  2,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(new TranscendentalFunctor));
   TranscendentalFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
 }
 
-TEST(NumericDiffCostFunction,
-     TranscendentalCaseFunctorRidders) {
+TEST(NumericDiffCostFunction, TranscendentalCaseFunctorRidders) {
   NumericDiffOptions options;
 
   // Using a smaller initial step size to overcome oscillatory function
@@ -163,13 +155,13 @@
   options.ridders_relative_initial_step_size = 1e-3;
 
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<TranscendentalFunctor,
-                                  RIDDERS,
-                                  2,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new TranscendentalFunctor, TAKE_OWNERSHIP, 2, options));
+  cost_function.reset(new NumericDiffCostFunction<TranscendentalFunctor,
+                                                  RIDDERS,
+                                                  2,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(
+      new TranscendentalFunctor, TAKE_OWNERSHIP, 2, options));
   TranscendentalFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
 }
@@ -177,13 +169,13 @@
 TEST(NumericDiffCostFunction,
      TranscendentalCaseCostFunctionCentralDifferences) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<TranscendentalCostFunction,
-                                  CENTRAL,
-                                  2,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new TranscendentalCostFunction, TAKE_OWNERSHIP));
+  cost_function.reset(new NumericDiffCostFunction<TranscendentalCostFunction,
+                                                  CENTRAL,
+                                                  2,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(
+      new TranscendentalCostFunction, TAKE_OWNERSHIP));
   TranscendentalFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
 }
@@ -191,19 +183,18 @@
 TEST(NumericDiffCostFunction,
      TranscendentalCaseCostFunctionForwardDifferences) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<TranscendentalCostFunction,
-                                  FORWARD,
-                                  2,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new TranscendentalCostFunction, TAKE_OWNERSHIP));
+  cost_function.reset(new NumericDiffCostFunction<TranscendentalCostFunction,
+                                                  FORWARD,
+                                                  2,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(
+      new TranscendentalCostFunction, TAKE_OWNERSHIP));
   TranscendentalFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
 }
 
-TEST(NumericDiffCostFunction,
-     TranscendentalCaseCostFunctionRidders) {
+TEST(NumericDiffCostFunction, TranscendentalCaseCostFunctionRidders) {
   NumericDiffOptions options;
 
   // Using a smaller initial step size to overcome oscillatory function
@@ -211,18 +202,18 @@
   options.ridders_relative_initial_step_size = 1e-3;
 
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<TranscendentalCostFunction,
-                                  RIDDERS,
-                                  2,  /* number of residuals */
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-          new TranscendentalCostFunction, TAKE_OWNERSHIP, 2, options));
+  cost_function.reset(new NumericDiffCostFunction<TranscendentalCostFunction,
+                                                  RIDDERS,
+                                                  2,  // number of residuals
+                                                  5,  // size of x1
+                                                  5   // size of x2
+                                                  >(
+      new TranscendentalCostFunction, TAKE_OWNERSHIP, 2, options));
   TranscendentalFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
 }
 
-template<int num_rows, int num_cols>
+template <int num_rows, int num_cols>
 class SizeTestingCostFunction : public SizedCostFunction<num_rows, num_cols> {
  public:
   bool Evaluate(double const* const* parameters,
@@ -241,20 +232,20 @@
 TEST(NumericDiffCostFunction, EigenRowMajorColMajorTest) {
   std::unique_ptr<CostFunction> cost_function;
   cost_function.reset(
-      new NumericDiffCostFunction<SizeTestingCostFunction<1,1>,  CENTRAL, 1, 1>(
-          new SizeTestingCostFunction<1,1>, ceres::TAKE_OWNERSHIP));
+      new NumericDiffCostFunction<SizeTestingCostFunction<1, 1>, CENTRAL, 1, 1>(
+          new SizeTestingCostFunction<1, 1>, ceres::TAKE_OWNERSHIP));
 
   cost_function.reset(
-      new NumericDiffCostFunction<SizeTestingCostFunction<2,1>,  CENTRAL, 2, 1>(
-          new SizeTestingCostFunction<2,1>, ceres::TAKE_OWNERSHIP));
+      new NumericDiffCostFunction<SizeTestingCostFunction<2, 1>, CENTRAL, 2, 1>(
+          new SizeTestingCostFunction<2, 1>, ceres::TAKE_OWNERSHIP));
 
   cost_function.reset(
-      new NumericDiffCostFunction<SizeTestingCostFunction<1,2>,  CENTRAL, 1, 2>(
-          new SizeTestingCostFunction<1,2>, ceres::TAKE_OWNERSHIP));
+      new NumericDiffCostFunction<SizeTestingCostFunction<1, 2>, CENTRAL, 1, 2>(
+          new SizeTestingCostFunction<1, 2>, ceres::TAKE_OWNERSHIP));
 
   cost_function.reset(
-      new NumericDiffCostFunction<SizeTestingCostFunction<2,2>,  CENTRAL, 2, 2>(
-          new SizeTestingCostFunction<2,2>, ceres::TAKE_OWNERSHIP));
+      new NumericDiffCostFunction<SizeTestingCostFunction<2, 2>, CENTRAL, 2, 2>(
+          new SizeTestingCostFunction<2, 2>, ceres::TAKE_OWNERSHIP));
 
   cost_function.reset(
       new NumericDiffCostFunction<EasyFunctor, CENTRAL, ceres::DYNAMIC, 1, 1>(
@@ -288,21 +279,20 @@
       new NumericDiffCostFunction<EasyFunctor,
                                   CENTRAL,
                                   ceres::DYNAMIC,
-                                  5,  /* size of x1 */
-                                  5   /* size of x2 */>(
-                                      new EasyFunctor, TAKE_OWNERSHIP, 3));
+                                  5,  // size of x1
+                                  5   // size of x2
+                                  >(new EasyFunctor, TAKE_OWNERSHIP, 3));
   EasyFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
 }
 
 TEST(NumericDiffCostFunction, ExponentialFunctorRidders) {
   std::unique_ptr<CostFunction> cost_function;
-  cost_function.reset(
-      new NumericDiffCostFunction<ExponentialFunctor,
-                                  RIDDERS,
-                                  1,  /* number of residuals */
-                                  1   /* size of x1 */>(
-             new ExponentialFunctor));
+  cost_function.reset(new NumericDiffCostFunction<ExponentialFunctor,
+                                                  RIDDERS,
+                                                  1,  // number of residuals
+                                                  1   // size of x1
+                                                  >(new ExponentialFunctor));
   ExponentialFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
 }
@@ -312,9 +302,9 @@
   cost_function.reset(
       new NumericDiffCostFunction<ExponentialCostFunction,
                                   RIDDERS,
-                                  1,  /* number of residuals */
-                                  1   /* size of x1 */>(
-             new ExponentialCostFunction));
+                                  1,  // number of residuals
+                                  1   // size of x1
+                                  >(new ExponentialCostFunction));
   ExponentialFunctor functor;
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
 }
@@ -326,14 +316,16 @@
   // presence of random noise.
   options.ridders_relative_initial_step_size = 10.0;
 
-  cost_function.reset(
-      new NumericDiffCostFunction<RandomizedFunctor,
-                                  RIDDERS,
-                                  1,  /* number of residuals */
-                                  1   /* size of x1 */>(
-             new RandomizedFunctor(kNoiseFactor, kRandomSeed), TAKE_OWNERSHIP,
-             1, options));
-  RandomizedFunctor functor (kNoiseFactor, kRandomSeed);
+  cost_function.reset(new NumericDiffCostFunction<RandomizedFunctor,
+                                                  RIDDERS,
+                                                  1,  // number of residuals
+                                                  1   // size of x1
+                                                  >(
+      new RandomizedFunctor(kNoiseFactor, kRandomSeed),
+      TAKE_OWNERSHIP,
+      1,
+      options));
+  RandomizedFunctor functor(kNoiseFactor, kRandomSeed);
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
 }
 
@@ -344,14 +336,16 @@
   // presence of random noise.
   options.ridders_relative_initial_step_size = 10.0;
 
-  cost_function.reset(
-      new NumericDiffCostFunction<RandomizedCostFunction,
-                                  RIDDERS,
-                                  1,  /* number of residuals */
-                                  1   /* size of x1 */>(
-             new RandomizedCostFunction(kNoiseFactor, kRandomSeed),
-             TAKE_OWNERSHIP, 1, options));
-  RandomizedFunctor functor (kNoiseFactor, kRandomSeed);
+  cost_function.reset(new NumericDiffCostFunction<RandomizedCostFunction,
+                                                  RIDDERS,
+                                                  1,  // number of residuals
+                                                  1   // size of x1
+                                                  >(
+      new RandomizedCostFunction(kNoiseFactor, kRandomSeed),
+      TAKE_OWNERSHIP,
+      1,
+      options));
+  RandomizedFunctor functor(kNoiseFactor, kRandomSeed);
   functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
 }
 
diff --git a/internal/ceres/numeric_diff_test_utils.cc b/internal/ceres/numeric_diff_test_utils.cc
index ab1b5f8..d833bbb 100644
--- a/internal/ceres/numeric_diff_test_utils.cc
+++ b/internal/ceres/numeric_diff_test_utils.cc
@@ -33,12 +33,12 @@
 
 #include <algorithm>
 #include <cmath>
+
 #include "ceres/cost_function.h"
 #include "ceres/test_util.h"
 #include "ceres/types.h"
 #include "gtest/gtest.h"
 
-
 namespace ceres {
 namespace internal {
 
@@ -55,23 +55,22 @@
 }
 
 void EasyFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
-    const CostFunction& cost_function,
-    NumericDiffMethodType method) const {
-  // The x1[0] is made deliberately small to test the performance near
-  // zero.
+    const CostFunction& cost_function, NumericDiffMethodType method) const {
+  // The x1[0] is made deliberately small to test the performance near zero.
+  // clang-format off
   double x1[] = { 1e-64, 2.0, 3.0, 4.0, 5.0 };
   double x2[] = { 9.0, 9.0, 5.0, 5.0, 1.0 };
   double *parameters[] = { &x1[0], &x2[0] };
+  // clang-format on
 
   double dydx1[15];  // 3 x 5, row major.
   double dydx2[15];  // 3 x 5, row major.
-  double *jacobians[2] = { &dydx1[0], &dydx2[0] };
+  double* jacobians[2] = {&dydx1[0], &dydx2[0]};
 
-  double residuals[3] = {-1e-100, -2e-100, -3e-100 };
+  double residuals[3] = {-1e-100, -2e-100, -3e-100};
 
-  ASSERT_TRUE(cost_function.Evaluate(&parameters[0],
-                                     &residuals[0],
-                                     &jacobians[0]));
+  ASSERT_TRUE(
+      cost_function.Evaluate(&parameters[0], &residuals[0], &jacobians[0]));
 
   double expected_residuals[3];
   EasyFunctor functor;
@@ -97,12 +96,14 @@
   }
 
   for (int i = 0; i < 5; ++i) {
+    // clang-format off
     ExpectClose(x2[i],                    dydx1[5 * 0 + i], tolerance);  // y1
     ExpectClose(x1[i],                    dydx2[5 * 0 + i], tolerance);
     ExpectClose(2 * x2[i] * residuals[0], dydx1[5 * 1 + i], tolerance);  // y2
     ExpectClose(2 * x1[i] * residuals[0], dydx2[5 * 1 + i], tolerance);
     ExpectClose(0.0,                      dydx1[5 * 2 + i], tolerance);  // y3
     ExpectClose(2 * x2[i],                dydx2[5 * 2 + i], tolerance);
+    // clang-format on
   }
 }
 
@@ -119,14 +120,13 @@
 }
 
 void TranscendentalFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
-    const CostFunction& cost_function,
-    NumericDiffMethodType method) const {
-
+    const CostFunction& cost_function, NumericDiffMethodType method) const {
   struct TestParameterBlocks {
     double x1[5];
     double x2[5];
   };
 
+  // clang-format off
   std::vector<TestParameterBlocks> kTests =  {
     { { 1.0, 2.0, 3.0, 4.0, 5.0 },  // No zeros.
       { 9.0, 9.0, 5.0, 5.0, 1.0 },
@@ -147,21 +147,21 @@
       { 0.0, 0.0, 0.0, 0.0, 0.0 },
     },
   };
+  // clang-format on
 
   for (int k = 0; k < kTests.size(); ++k) {
-    double *x1 = &(kTests[k].x1[0]);
-    double *x2 = &(kTests[k].x2[0]);
-    double *parameters[] = { x1, x2 };
+    double* x1 = &(kTests[k].x1[0]);
+    double* x2 = &(kTests[k].x2[0]);
+    double* parameters[] = {x1, x2};
 
     double dydx1[10];
     double dydx2[10];
-    double *jacobians[2] = { &dydx1[0], &dydx2[0] };
+    double* jacobians[2] = {&dydx1[0], &dydx2[0]};
 
     double residuals[2];
 
-    ASSERT_TRUE(cost_function.Evaluate(&parameters[0],
-                                       &residuals[0],
-                                       &jacobians[0]));
+    ASSERT_TRUE(
+        cost_function.Evaluate(&parameters[0], &residuals[0], &jacobians[0]));
     double x1x2 = 0;
     for (int i = 0; i < 5; ++i) {
       x1x2 += x1[i] * x2[i];
@@ -184,39 +184,37 @@
     }
 
     for (int i = 0; i < 5; ++i) {
+      // clang-format off
       ExpectClose( x2[i] * cos(x1x2),              dydx1[5 * 0 + i], tolerance);
       ExpectClose( x1[i] * cos(x1x2),              dydx2[5 * 0 + i], tolerance);
       ExpectClose(-x2[i] * exp(-x1x2 / 10.) / 10., dydx1[5 * 1 + i], tolerance);
       ExpectClose(-x1[i] * exp(-x1x2 / 10.) / 10., dydx2[5 * 1 + i], tolerance);
+      // clang-format on
     }
   }
 }
 
-bool ExponentialFunctor::operator()(const double* x1,
-                                    double* residuals) const {
+bool ExponentialFunctor::operator()(const double* x1, double* residuals) const {
   residuals[0] = exp(x1[0]);
   return true;
 }
 
-
 void ExponentialFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
     const CostFunction& cost_function) const {
   // Evaluating the functor at specific points for testing.
-  std::vector<double> kTests = { 1.0, 2.0, 3.0, 4.0, 5.0 };
+  std::vector<double> kTests = {1.0, 2.0, 3.0, 4.0, 5.0};
 
   // Minimal tolerance w.r.t. the cost function and the tests.
   const double kTolerance = 2e-14;
 
   for (int k = 0; k < kTests.size(); ++k) {
-    double *parameters[] = { &kTests[k] };
+    double* parameters[] = {&kTests[k]};
     double dydx;
-    double *jacobians[1] = { &dydx };
+    double* jacobians[1] = {&dydx};
     double residual;
 
-    ASSERT_TRUE(cost_function.Evaluate(&parameters[0],
-                                       &residual,
-                                       &jacobians[0]));
-
+    ASSERT_TRUE(
+        cost_function.Evaluate(&parameters[0], &residual, &jacobians[0]));
 
     double expected_result = exp(kTests[k]);
 
@@ -228,10 +226,9 @@
   }
 }
 
-bool RandomizedFunctor::operator()(const double* x1,
-                                   double* residuals) const {
-  double random_value = static_cast<double>(rand()) /
-      static_cast<double>(RAND_MAX);
+bool RandomizedFunctor::operator()(const double* x1, double* residuals) const {
+  double random_value =
+      static_cast<double>(rand()) / static_cast<double>(RAND_MAX);
 
   // Normalize noise to [-factor, factor].
   random_value *= 2.0;
@@ -244,7 +241,7 @@
 
 void RandomizedFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
     const CostFunction& cost_function) const {
-  std::vector<double> kTests = { 0.0, 1.0, 3.0, 4.0, 50.0 };
+  std::vector<double> kTests = {0.0, 1.0, 3.0, 4.0, 50.0};
 
   const double kTolerance = 2e-4;
 
@@ -252,14 +249,13 @@
   srand(random_seed_);
 
   for (int k = 0; k < kTests.size(); ++k) {
-    double *parameters[] = { &kTests[k] };
+    double* parameters[] = {&kTests[k]};
     double dydx;
-    double *jacobians[1] = { &dydx };
+    double* jacobians[1] = {&dydx};
     double residual;
 
-    ASSERT_TRUE(cost_function.Evaluate(&parameters[0],
-                                       &residual,
-                                       &jacobians[0]));
+    ASSERT_TRUE(
+        cost_function.Evaluate(&parameters[0], &residual, &jacobians[0]));
 
     // Expect residual to be close to x^2 w.r.t. noise factor.
     ExpectClose(residual, kTests[k] * kTests[k], noise_factor_);
diff --git a/internal/ceres/numeric_diff_test_utils.h b/internal/ceres/numeric_diff_test_utils.h
index 33497d9..462553c 100644
--- a/internal/ceres/numeric_diff_test_utils.h
+++ b/internal/ceres/numeric_diff_test_utils.h
@@ -51,8 +51,7 @@
  public:
   bool operator()(const double* x1, const double* x2, double* residuals) const;
   void ExpectCostFunctionEvaluationIsNearlyCorrect(
-      const CostFunction& cost_function,
-      NumericDiffMethodType method) const;
+      const CostFunction& cost_function, NumericDiffMethodType method) const;
 };
 
 class EasyCostFunction : public SizedCostFunction<3, 5, 5> {
@@ -76,8 +75,7 @@
  public:
   bool operator()(const double* x1, const double* x2, double* residuals) const;
   void ExpectCostFunctionEvaluationIsNearlyCorrect(
-      const CostFunction& cost_function,
-      NumericDiffMethodType method) const;
+      const CostFunction& cost_function, NumericDiffMethodType method) const;
 };
 
 class TranscendentalCostFunction : public SizedCostFunction<2, 5, 5> {
@@ -87,6 +85,7 @@
                 double** /* not used */) const final {
     return functor_(parameters[0], parameters[1], residuals);
   }
+
  private:
   TranscendentalFunctor functor_;
 };
@@ -117,8 +116,7 @@
 class RandomizedFunctor {
  public:
   RandomizedFunctor(double noise_factor, unsigned int random_seed)
-      : noise_factor_(noise_factor), random_seed_(random_seed) {
-  }
+      : noise_factor_(noise_factor), random_seed_(random_seed) {}
 
   bool operator()(const double* x1, double* residuals) const;
   void ExpectCostFunctionEvaluationIsNearlyCorrect(
@@ -132,8 +130,7 @@
 class RandomizedCostFunction : public SizedCostFunction<1, 1> {
  public:
   RandomizedCostFunction(double noise_factor, unsigned int random_seed)
-      : functor_(noise_factor, random_seed) {
-  }
+      : functor_(noise_factor, random_seed) {}
 
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -145,7 +142,6 @@
   RandomizedFunctor functor_;
 };
 
-
 }  // namespace internal
 }  // namespace ceres
 
diff --git a/internal/ceres/ordered_groups_test.cc b/internal/ceres/ordered_groups_test.cc
index 8cf4324..d613a41 100644
--- a/internal/ceres/ordered_groups_test.cc
+++ b/internal/ceres/ordered_groups_test.cc
@@ -32,6 +32,7 @@
 
 #include <cstddef>
 #include <vector>
+
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/pair_hash.h b/internal/ceres/pair_hash.h
index 80453ba..abbedcc 100644
--- a/internal/ceres/pair_hash.h
+++ b/internal/ceres/pair_hash.h
@@ -33,10 +33,11 @@
 #ifndef CERES_INTERNAL_PAIR_HASH_H_
 #define CERES_INTERNAL_PAIR_HASH_H_
 
-#include "ceres/internal/port.h"
 #include <cstdint>
 #include <utility>
 
+#include "ceres/internal/port.h"
+
 namespace ceres {
 namespace internal {
 
@@ -53,6 +54,8 @@
 // in 18 cycles if you're lucky. On x86 architectures, this requires 45
 // instructions in 27 cycles, if you're lucky.
 //
+// clang-format off
+//
 // 32bit version
 inline void hash_mix(uint32_t& a, uint32_t& b, uint32_t& c) {
   a -= b; a -= c; a ^= (c>>13);
@@ -78,6 +81,7 @@
   b -= c; b -= a; b ^= (a<<49);
   c -= a; c -= b; c ^= (b>>11);
 }
+// clang-format on
 
 inline uint32_t Hash32NumWithSeed(uint32_t num, uint32_t c) {
   // The golden ratio; an arbitrary value.
diff --git a/internal/ceres/parallel_for_cxx.cc b/internal/ceres/parallel_for_cxx.cc
index 8e358f5..4da40c0 100644
--- a/internal/ceres/parallel_for_cxx.cc
+++ b/internal/ceres/parallel_for_cxx.cc
@@ -33,14 +33,13 @@
 
 #ifdef CERES_USE_CXX_THREADS
 
-#include "ceres/parallel_for.h"
-
 #include <cmath>
 #include <condition_variable>
 #include <memory>
 #include <mutex>
 
 #include "ceres/concurrent_queue.h"
+#include "ceres/parallel_for.h"
 #include "ceres/scoped_thread_token.h"
 #include "ceres/thread_token_provider.h"
 #include "glog/logging.h"
@@ -117,9 +116,7 @@
 
 }  // namespace
 
-int MaxNumThreadsAvailable() {
-  return ThreadPool::MaxNumThreadsAvailable();
-}
+int MaxNumThreadsAvailable() { return ThreadPool::MaxNumThreadsAvailable(); }
 
 // See ParallelFor (below) for more details.
 void ParallelFor(ContextImpl* context,
@@ -141,8 +138,10 @@
     return;
   }
 
-  ParallelFor(context, start, end, num_threads,
-              [&function](int /*thread_id*/, int i) { function(i); });
+  ParallelFor(
+      context, start, end, num_threads, [&function](int /*thread_id*/, int i) {
+        function(i);
+      });
 }
 
 // This implementation uses a fixed size max worker pool with a shared task
@@ -213,8 +212,7 @@
     const int thread_id = scoped_thread_token.token();
 
     // Perform each task.
-    for (int j = shared_state->start + i;
-         j < shared_state->end;
+    for (int j = shared_state->start + i; j < shared_state->end;
          j += shared_state->num_work_items) {
       function(thread_id, j);
     }
@@ -244,4 +242,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX_THREADS
+#endif  // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/parallel_for_nothreads.cc b/internal/ceres/parallel_for_nothreads.cc
index e8f450a..d036569 100644
--- a/internal/ceres/parallel_for_nothreads.cc
+++ b/internal/ceres/parallel_for_nothreads.cc
@@ -72,7 +72,7 @@
   }
 }
 
-}
-}
+}  // namespace internal
+}  // namespace ceres
 
 #endif  // CERES_NO_THREADS
diff --git a/internal/ceres/parallel_for_openmp.cc b/internal/ceres/parallel_for_openmp.cc
index 8afe3b1..eb9d905 100644
--- a/internal/ceres/parallel_for_openmp.cc
+++ b/internal/ceres/parallel_for_openmp.cc
@@ -34,7 +34,6 @@
 #if defined(CERES_USE_OPENMP)
 
 #include "ceres/parallel_for.h"
-
 #include "ceres/scoped_thread_token.h"
 #include "ceres/thread_token_provider.h"
 #include "glog/logging.h"
@@ -43,9 +42,7 @@
 namespace ceres {
 namespace internal {
 
-int MaxNumThreadsAvailable() {
-  return omp_get_max_threads();
-}
+int MaxNumThreadsAvailable() { return omp_get_max_threads(); }
 
 void ParallelFor(ContextImpl* context,
                  int start,
diff --git a/internal/ceres/parallel_for_test.cc b/internal/ceres/parallel_for_test.cc
index 04e5783..434f993 100644
--- a/internal/ceres/parallel_for_test.cc
+++ b/internal/ceres/parallel_for_test.cc
@@ -29,7 +29,9 @@
 // Author: vitus@google.com (Michael Vitus)
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
 
 #include "ceres/parallel_for.h"
 
@@ -64,8 +66,9 @@
 
   for (int num_threads = 1; num_threads <= 8; ++num_threads) {
     std::vector<int> values(size, 0);
-    ParallelFor(&context, 0, size, num_threads,
-                [&values](int i) { values[i] = std::sqrt(i); });
+    ParallelFor(&context, 0, size, num_threads, [&values](int i) {
+      values[i] = std::sqrt(i);
+    });
     EXPECT_THAT(values, ElementsAreArray(expected_results));
   }
 }
@@ -84,8 +87,10 @@
 
   for (int num_threads = 1; num_threads <= 8; ++num_threads) {
     std::vector<int> values(size, 0);
-    ParallelFor(&context, 0, size, num_threads,
-                [&values](int thread_id, int i) { values[i] = std::sqrt(i); });
+    ParallelFor(
+        &context, 0, size, num_threads, [&values](int thread_id, int i) {
+          values[i] = std::sqrt(i);
+        });
     EXPECT_THAT(values, ElementsAreArray(expected_results));
   }
 }
@@ -146,7 +151,10 @@
   std::mutex mutex;
   std::condition_variable condition;
   int count = 0;
-  ParallelFor(&context, 0, 2, 2,
+  ParallelFor(&context,
+              0,
+              2,
+              2,
               [&x, &mutex, &condition, &count](int thread_id, int i) {
                 std::unique_lock<std::mutex> lock(mutex);
                 x[i] = thread_id;
@@ -155,7 +163,7 @@
                 condition.wait(lock, [&]() { return count == 2; });
               });
 
-  EXPECT_THAT(x, UnorderedElementsAreArray({0,1}));
+  EXPECT_THAT(x, UnorderedElementsAreArray({0, 1}));
 }
 #endif  // CERES_NO_THREADS
 
diff --git a/internal/ceres/parallel_utils_test.cc b/internal/ceres/parallel_utils_test.cc
index f997d25..53870bb 100644
--- a/internal/ceres/parallel_utils_test.cc
+++ b/internal/ceres/parallel_utils_test.cc
@@ -29,7 +29,10 @@
 // Author: wjr@google.com (William Rucklidge)
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
+
 #include "ceres/parallel_utils.h"
 
 #include "glog/logging.h"
diff --git a/internal/ceres/parameter_block_ordering.cc b/internal/ceres/parameter_block_ordering.cc
index ef521c0..9899c24 100644
--- a/internal/ceres/parameter_block_ordering.cc
+++ b/internal/ceres/parameter_block_ordering.cc
@@ -50,11 +50,11 @@
 using std::vector;
 
 int ComputeStableSchurOrdering(const Program& program,
-                         vector<ParameterBlock*>* ordering) {
+                               vector<ParameterBlock*>* ordering) {
   CHECK(ordering != nullptr);
   ordering->clear();
   EventLogger event_logger("ComputeStableSchurOrdering");
-  std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+  std::unique_ptr<Graph<ParameterBlock*>> graph(CreateHessianGraph(program));
   event_logger.AddEvent("CreateHessianGraph");
 
   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
@@ -86,7 +86,7 @@
   CHECK(ordering != nullptr);
   ordering->clear();
 
-  std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+  std::unique_ptr<Graph<ParameterBlock*>> graph(CreateHessianGraph(program));
   int independent_set_size = IndependentSetOrdering(*graph, ordering);
   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
 
@@ -106,7 +106,7 @@
   CHECK(ordering != nullptr);
   ordering->Clear();
   const vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
-  std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+  std::unique_ptr<Graph<ParameterBlock*>> graph(CreateHessianGraph(program));
 
   int num_covered = 0;
   int round = 0;
diff --git a/internal/ceres/parameter_block_ordering.h b/internal/ceres/parameter_block_ordering.h
index f996929..7b58afd 100644
--- a/internal/ceres/parameter_block_ordering.h
+++ b/internal/ceres/parameter_block_ordering.h
@@ -32,8 +32,9 @@
 #define CERES_INTERNAL_PARAMETER_BLOCK_ORDERING_H_
 
 #include <vector>
-#include "ceres/ordered_groups.h"
+
 #include "ceres/graph.h"
+#include "ceres/ordered_groups.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -56,13 +57,13 @@
 //             complement of the independent set,
 //             fixed blocks]
 int ComputeSchurOrdering(const Program& program,
-                         std::vector<ParameterBlock* >* ordering);
+                         std::vector<ParameterBlock*>* ordering);
 
 // Same as above, except that ties while computing the independent set
 // ordering are resolved in favour of the order in which the parameter
 // blocks occur in the program.
 int ComputeStableSchurOrdering(const Program& program,
-                               std::vector<ParameterBlock* >* ordering);
+                               std::vector<ParameterBlock*>* ordering);
 
 // Use an approximate independent set ordering to decompose the
 // parameter blocks of a problem in a sequence of independent
diff --git a/internal/ceres/parameter_block_ordering_test.cc b/internal/ceres/parameter_block_ordering_test.cc
index 24dfdc9..1078893 100644
--- a/internal/ceres/parameter_block_ordering_test.cc
+++ b/internal/ceres/parameter_block_ordering_test.cc
@@ -61,7 +61,7 @@
 };
 
 class SchurOrderingTest : public ::testing::Test {
- protected :
+ protected:
   void SetUp() final {
     // The explicit calls to AddParameterBlock are necessary because
     // the below tests depend on the specific numbering of the
@@ -75,8 +75,8 @@
     problem_.AddResidualBlock(new DummyCostFunction<6, 5, 4>, NULL, z_, y_);
     problem_.AddResidualBlock(new DummyCostFunction<3, 3, 5>, NULL, x_, z_);
     problem_.AddResidualBlock(new DummyCostFunction<7, 5, 3>, NULL, z_, x_);
-    problem_.AddResidualBlock(new DummyCostFunction<1, 5, 3, 6>, NULL,
-                              z_, x_, w_);
+    problem_.AddResidualBlock(
+        new DummyCostFunction<1, 5, 3, 6>, NULL, z_, x_, w_);
   }
 
   ProblemImpl problem_;
diff --git a/internal/ceres/parameter_dims_test.cc b/internal/ceres/parameter_dims_test.cc
index c832260..ee3be8f 100644
--- a/internal/ceres/parameter_dims_test.cc
+++ b/internal/ceres/parameter_dims_test.cc
@@ -25,6 +25,7 @@
 #include "ceres/internal/parameter_dims.h"
 
 #include <gtest/gtest.h>
+
 #include <type_traits>
 #include <utility>
 
@@ -35,15 +36,15 @@
 static_assert(IsValidParameterDimensionSequence(std::integer_sequence<int>()) ==
                   true,
               "Unit test of is valid parameter dimension sequence failed.");
-static_assert(
-    IsValidParameterDimensionSequence(std::integer_sequence<int, 2, 1>()) == true,
-    "Unit test of is valid parameter dimension sequence failed.");
-static_assert(
-    IsValidParameterDimensionSequence(std::integer_sequence<int, 0, 1>()) == false,
-    "Unit test of is valid parameter dimension sequence failed.");
-static_assert(
-    IsValidParameterDimensionSequence(std::integer_sequence<int, 3, 0>()) == false,
-    "Unit test of is valid parameter dimension sequence failed.");
+static_assert(IsValidParameterDimensionSequence(
+                  std::integer_sequence<int, 2, 1>()) == true,
+              "Unit test of is valid parameter dimension sequence failed.");
+static_assert(IsValidParameterDimensionSequence(
+                  std::integer_sequence<int, 0, 1>()) == false,
+              "Unit test of is valid parameter dimension sequence failed.");
+static_assert(IsValidParameterDimensionSequence(
+                  std::integer_sequence<int, 3, 0>()) == false,
+              "Unit test of is valid parameter dimension sequence failed.");
 
 // Static parameter dims unit test
 static_assert(
diff --git a/internal/ceres/partitioned_matrix_view.h b/internal/ceres/partitioned_matrix_view.h
index 3853ea1..b8ac3b2 100644
--- a/internal/ceres/partitioned_matrix_view.h
+++ b/internal/ceres/partitioned_matrix_view.h
@@ -98,12 +98,14 @@
   virtual void UpdateBlockDiagonalFtF(
       BlockSparseMatrix* block_diagonal) const = 0;
 
+  // clang-format off
   virtual int num_col_blocks_e() const = 0;
   virtual int num_col_blocks_f() const = 0;
   virtual int num_cols_e()       const = 0;
   virtual int num_cols_f()       const = 0;
   virtual int num_rows()         const = 0;
   virtual int num_cols()         const = 0;
+  // clang-format on
 
   static PartitionedMatrixViewBase* Create(const LinearSolver::Options& options,
                                            const BlockSparseMatrix& matrix);
@@ -111,7 +113,7 @@
 
 template <int kRowBlockSize = Eigen::Dynamic,
           int kEBlockSize = Eigen::Dynamic,
-          int kFBlockSize = Eigen::Dynamic >
+          int kFBlockSize = Eigen::Dynamic>
 class PartitionedMatrixView : public PartitionedMatrixViewBase {
  public:
   // matrix = [E F], where the matrix E contains the first
@@ -127,12 +129,14 @@
   BlockSparseMatrix* CreateBlockDiagonalFtF() const final;
   void UpdateBlockDiagonalEtE(BlockSparseMatrix* block_diagonal) const final;
   void UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const final;
+  // clang-format off
   int num_col_blocks_e() const final { return num_col_blocks_e_;  }
   int num_col_blocks_f() const final { return num_col_blocks_f_;  }
   int num_cols_e()       const final { return num_cols_e_;        }
   int num_cols_f()       const final { return num_cols_f_;        }
   int num_rows()         const final { return matrix_.num_rows(); }
   int num_cols()         const final { return matrix_.num_cols(); }
+  // clang-format on
 
  private:
   BlockSparseMatrix* CreateBlockDiagonalMatrixLayout(int start_col_block,
diff --git a/internal/ceres/partitioned_matrix_view_impl.h b/internal/ceres/partitioned_matrix_view_impl.h
index f3f548c..0b6a57f 100644
--- a/internal/ceres/partitioned_matrix_view_impl.h
+++ b/internal/ceres/partitioned_matrix_view_impl.h
@@ -28,14 +28,14 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
-#include "ceres/partitioned_matrix_view.h"
-
 #include <algorithm>
 #include <cstring>
 #include <vector>
+
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/internal/eigen.h"
+#include "ceres/partitioned_matrix_view.h"
 #include "ceres/small_blas.h"
 #include "glog/logging.h"
 
@@ -44,11 +44,8 @@
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
 PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-PartitionedMatrixView(
-    const BlockSparseMatrix& matrix,
-    int num_col_blocks_e)
-    : matrix_(matrix),
-      num_col_blocks_e_(num_col_blocks_e) {
+    PartitionedMatrixView(const BlockSparseMatrix& matrix, int num_col_blocks_e)
+    : matrix_(matrix), num_col_blocks_e_(num_col_blocks_e) {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
   CHECK(bs != nullptr);
 
@@ -85,8 +82,7 @@
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
 PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-~PartitionedMatrixView() {
-}
+    ~PartitionedMatrixView() {}
 
 // The next four methods don't seem to be particularly cache
 // friendly. This is an artifact of how the BlockStructure of the
@@ -94,9 +90,8 @@
 // multithreading as well as improved data layout.
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-RightMultiplyE(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    RightMultiplyE(const double* x, double* y) const {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
 
   // Iterate over the first num_row_blocks_e_ row blocks, and multiply
@@ -109,17 +104,18 @@
     const int col_block_id = cell.block_id;
     const int col_block_pos = bs->cols[col_block_id].position;
     const int col_block_size = bs->cols[col_block_id].size;
+    // clang-format off
     MatrixVectorMultiply<kRowBlockSize, kEBlockSize, 1>(
         values + cell.position, row_block_size, col_block_size,
         x + col_block_pos,
         y + row_block_pos);
+    // clang-format on
   }
 }
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-RightMultiplyF(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    RightMultiplyF(const double* x, double* y) const {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
 
   // Iterate over row blocks, and if the row block is in E, then
@@ -136,10 +132,12 @@
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
       const int col_block_size = bs->cols[col_block_id].size;
+      // clang-format off
       MatrixVectorMultiply<kRowBlockSize, kFBlockSize, 1>(
           values + cells[c].position, row_block_size, col_block_size,
           x + col_block_pos - num_cols_e_,
           y + row_block_pos);
+      // clang-format on
     }
   }
 
@@ -151,18 +149,19 @@
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
       const int col_block_size = bs->cols[col_block_id].size;
+      // clang-format off
       MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
           values + cells[c].position, row_block_size, col_block_size,
           x + col_block_pos - num_cols_e_,
           y + row_block_pos);
+      // clang-format on
     }
   }
 }
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-LeftMultiplyE(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    LeftMultiplyE(const double* x, double* y) const {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
 
   // Iterate over the first num_row_blocks_e_ row blocks, and multiply
@@ -175,17 +174,18 @@
     const int col_block_id = cell.block_id;
     const int col_block_pos = bs->cols[col_block_id].position;
     const int col_block_size = bs->cols[col_block_id].size;
+    // clang-format off
     MatrixTransposeVectorMultiply<kRowBlockSize, kEBlockSize, 1>(
         values + cell.position, row_block_size, col_block_size,
         x + row_block_pos,
         y + col_block_pos);
+    // clang-format on
   }
 }
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-LeftMultiplyF(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    LeftMultiplyF(const double* x, double* y) const {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
 
   // Iterate over row blocks, and if the row block is in E, then
@@ -202,10 +202,12 @@
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
       const int col_block_size = bs->cols[col_block_id].size;
+      // clang-format off
       MatrixTransposeVectorMultiply<kRowBlockSize, kFBlockSize, 1>(
         values + cells[c].position, row_block_size, col_block_size,
         x + row_block_pos,
         y + col_block_pos - num_cols_e_);
+      // clang-format on
     }
   }
 
@@ -217,10 +219,12 @@
       const int col_block_id = cells[c].block_id;
       const int col_block_pos = bs->cols[col_block_id].position;
       const int col_block_size = bs->cols[col_block_id].size;
+      // clang-format off
       MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
         values + cells[c].position, row_block_size, col_block_size,
         x + row_block_pos,
         y + col_block_pos - num_cols_e_);
+      // clang-format on
     }
   }
 }
@@ -233,7 +237,8 @@
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
 BlockSparseMatrix*
 PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-CreateBlockDiagonalMatrixLayout(int start_col_block, int end_col_block) const {
+    CreateBlockDiagonalMatrixLayout(int start_col_block,
+                                    int end_col_block) const {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
   CompressedRowBlockStructure* block_diagonal_structure =
       new CompressedRowBlockStructure;
@@ -269,9 +274,10 @@
 }
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-BlockSparseMatrix*
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-CreateBlockDiagonalEtE() const {
+BlockSparseMatrix* PartitionedMatrixView<kRowBlockSize,
+                                         kEBlockSize,
+                                         kFBlockSize>::CreateBlockDiagonalEtE()
+    const {
   BlockSparseMatrix* block_diagonal =
       CreateBlockDiagonalMatrixLayout(0, num_col_blocks_e_);
   UpdateBlockDiagonalEtE(block_diagonal);
@@ -279,12 +285,12 @@
 }
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-BlockSparseMatrix*
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-CreateBlockDiagonalFtF() const {
-  BlockSparseMatrix* block_diagonal =
-      CreateBlockDiagonalMatrixLayout(
-          num_col_blocks_e_, num_col_blocks_e_ + num_col_blocks_f_);
+BlockSparseMatrix* PartitionedMatrixView<kRowBlockSize,
+                                         kEBlockSize,
+                                         kFBlockSize>::CreateBlockDiagonalFtF()
+    const {
+  BlockSparseMatrix* block_diagonal = CreateBlockDiagonalMatrixLayout(
+      num_col_blocks_e_, num_col_blocks_e_ + num_col_blocks_f_);
   UpdateBlockDiagonalFtF(block_diagonal);
   return block_diagonal;
 }
@@ -295,17 +301,15 @@
 //    block_diagonal = block_diagonal(E'E)
 //
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-UpdateBlockDiagonalEtE(
-    BlockSparseMatrix* block_diagonal) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    UpdateBlockDiagonalEtE(BlockSparseMatrix* block_diagonal) const {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
   const CompressedRowBlockStructure* block_diagonal_structure =
       block_diagonal->block_structure();
 
   block_diagonal->SetZero();
   const double* values = matrix_.values();
-  for (int r = 0; r < num_row_blocks_e_ ; ++r) {
+  for (int r = 0; r < num_row_blocks_e_; ++r) {
     const Cell& cell = bs->rows[r].cells[0];
     const int row_block_size = bs->rows[r].block.size;
     const int block_id = cell.block_id;
@@ -313,12 +317,14 @@
     const int cell_position =
         block_diagonal_structure->rows[block_id].cells[0].position;
 
+    // clang-format off
     MatrixTransposeMatrixMultiply
         <kRowBlockSize, kEBlockSize, kRowBlockSize, kEBlockSize, 1>(
             values + cell.position, row_block_size, col_block_size,
             values + cell.position, row_block_size, col_block_size,
             block_diagonal->mutable_values() + cell_position,
             0, 0, col_block_size, col_block_size);
+    // clang-format on
   }
 }
 
@@ -328,9 +334,8 @@
 //   block_diagonal = block_diagonal(F'F)
 //
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const {
   const CompressedRowBlockStructure* bs = matrix_.block_structure();
   const CompressedRowBlockStructure* block_diagonal_structure =
       block_diagonal->block_structure();
@@ -347,12 +352,14 @@
       const int cell_position =
           block_diagonal_structure->rows[diagonal_block_id].cells[0].position;
 
+      // clang-format off
       MatrixTransposeMatrixMultiply
           <kRowBlockSize, kFBlockSize, kRowBlockSize, kFBlockSize, 1>(
               values + cells[c].position, row_block_size, col_block_size,
               values + cells[c].position, row_block_size, col_block_size,
               block_diagonal->mutable_values() + cell_position,
               0, 0, col_block_size, col_block_size);
+      // clang-format on
     }
   }
 
@@ -366,12 +373,14 @@
       const int cell_position =
           block_diagonal_structure->rows[diagonal_block_id].cells[0].position;
 
+      // clang-format off
       MatrixTransposeMatrixMultiply
           <Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, 1>(
               values + cells[c].position, row_block_size, col_block_size,
               values + cells[c].position, row_block_size, col_block_size,
               block_diagonal->mutable_values() + cell_position,
               0, 0, col_block_size, col_block_size);
+      // clang-format on
     }
   }
 }
diff --git a/internal/ceres/partitioned_matrix_view_test.cc b/internal/ceres/partitioned_matrix_view_test.cc
index 827cfb7..b66d0b8 100644
--- a/internal/ceres/partitioned_matrix_view_test.cc
+++ b/internal/ceres/partitioned_matrix_view_test.cc
@@ -32,6 +32,7 @@
 
 #include <memory>
 #include <vector>
+
 #include "ceres/block_structure.h"
 #include "ceres/casts.h"
 #include "ceres/internal/eigen.h"
@@ -47,7 +48,7 @@
 const double kEpsilon = 1e-14;
 
 class PartitionedMatrixViewTest : public ::testing::Test {
- protected :
+ protected:
   void SetUp() final {
     srand(5);
     std::unique_ptr<LinearLeastSquaresProblem> problem(
@@ -61,8 +62,7 @@
     LinearSolver::Options options;
     options.elimination_groups.push_back(num_eliminate_blocks_);
     pmv_.reset(PartitionedMatrixViewBase::Create(
-                   options,
-                   *down_cast<BlockSparseMatrix*>(A_.get())));
+        options, *down_cast<BlockSparseMatrix*>(A_.get())));
   }
 
   int num_rows_;
@@ -143,9 +143,9 @@
 }
 
 TEST_F(PartitionedMatrixViewTest, BlockDiagonalEtE) {
-  std::unique_ptr<BlockSparseMatrix>
-      block_diagonal_ee(pmv_->CreateBlockDiagonalEtE());
-  const CompressedRowBlockStructure* bs  = block_diagonal_ee->block_structure();
+  std::unique_ptr<BlockSparseMatrix> block_diagonal_ee(
+      pmv_->CreateBlockDiagonalEtE());
+  const CompressedRowBlockStructure* bs = block_diagonal_ee->block_structure();
 
   EXPECT_EQ(block_diagonal_ee->num_rows(), 2);
   EXPECT_EQ(block_diagonal_ee->num_cols(), 2);
@@ -157,9 +157,9 @@
 }
 
 TEST_F(PartitionedMatrixViewTest, BlockDiagonalFtF) {
-  std::unique_ptr<BlockSparseMatrix>
-      block_diagonal_ff(pmv_->CreateBlockDiagonalFtF());
-  const CompressedRowBlockStructure* bs  = block_diagonal_ff->block_structure();
+  std::unique_ptr<BlockSparseMatrix> block_diagonal_ff(
+      pmv_->CreateBlockDiagonalFtF());
+  const CompressedRowBlockStructure* bs = block_diagonal_ff->block_structure();
 
   EXPECT_EQ(block_diagonal_ff->num_rows(), 3);
   EXPECT_EQ(block_diagonal_ff->num_cols(), 3);
diff --git a/internal/ceres/polynomial.h b/internal/ceres/polynomial.h
index 3e09bae..40e4150 100644
--- a/internal/ceres/polynomial.h
+++ b/internal/ceres/polynomial.h
@@ -33,6 +33,7 @@
 #define CERES_INTERNAL_POLYNOMIAL_SOLVER_H_
 
 #include <vector>
+
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
 
diff --git a/internal/ceres/polynomial_test.cc b/internal/ceres/polynomial_test.cc
index 00c8534..0ff73ea 100644
--- a/internal/ceres/polynomial_test.cc
+++ b/internal/ceres/polynomial_test.cc
@@ -31,13 +31,14 @@
 
 #include "ceres/polynomial.h"
 
-#include <limits>
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
-#include <algorithm>
-#include "gtest/gtest.h"
+#include <limits>
+
 #include "ceres/function_sample.h"
 #include "ceres/test_util.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -74,7 +75,7 @@
   // Multiply poly by x^2 - 2real + abs(real,imag)^2
   poly2.head(poly.size()) += poly;
   poly2.segment(1, poly.size()) -= 2 * real * poly;
-  poly2.tail(poly.size()) += (real*real + imag*imag) * poly;
+  poly2.tail(poly.size()) += (real * real + imag * imag) * poly;
   return poly2;
 }
 
@@ -90,7 +91,7 @@
 // If use_real is false, NULL is passed as the real argument to
 // FindPolynomialRoots. If use_imaginary is false, NULL is passed as the
 // imaginary argument to FindPolynomialRoots.
-template<int N>
+template <int N>
 void RunPolynomialTestRealRoots(const double (&real_roots)[N],
                                 bool use_real,
                                 bool use_imaginary,
@@ -142,32 +143,32 @@
 }
 
 TEST(Polynomial, LinearPolynomialWithPositiveRootWorks) {
-  const double roots[1] = { 42.42 };
+  const double roots[1] = {42.42};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
 }
 
 TEST(Polynomial, LinearPolynomialWithNegativeRootWorks) {
-  const double roots[1] = { -42.42 };
+  const double roots[1] = {-42.42};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
 }
 
 TEST(Polynomial, QuadraticPolynomialWithPositiveRootsWorks) {
-  const double roots[2] = { 1.0, 42.42 };
+  const double roots[2] = {1.0, 42.42};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
 }
 
 TEST(Polynomial, QuadraticPolynomialWithOneNegativeRootWorks) {
-  const double roots[2] = { -42.42, 1.0 };
+  const double roots[2] = {-42.42, 1.0};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
 }
 
 TEST(Polynomial, QuadraticPolynomialWithTwoNegativeRootsWorks) {
-  const double roots[2] = { -42.42, -1.0 };
+  const double roots[2] = {-42.42, -1.0};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
 }
 
 TEST(Polynomial, QuadraticPolynomialWithCloseRootsWorks) {
-  const double roots[2] = { 42.42, 42.43 };
+  const double roots[2] = {42.42, 42.43};
   RunPolynomialTestRealRoots(roots, true, false, kEpsilonLoose);
 }
 
@@ -190,37 +191,37 @@
 }
 
 TEST(Polynomial, QuarticPolynomialWorks) {
-  const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+  const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
 }
 
 TEST(Polynomial, QuarticPolynomialWithTwoClustersOfCloseRootsWorks) {
-  const double roots[4] = { 1.23e-1, 2.46e-1, 1.23e+5, 2.46e+5 };
+  const double roots[4] = {1.23e-1, 2.46e-1, 1.23e+5, 2.46e+5};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilonLoose);
 }
 
 TEST(Polynomial, QuarticPolynomialWithTwoZeroRootsWorks) {
-  const double roots[4] = { -42.42, 0.0, 0.0, 42.42 };
+  const double roots[4] = {-42.42, 0.0, 0.0, 42.42};
   RunPolynomialTestRealRoots(roots, true, true, 2 * kEpsilonLoose);
 }
 
 TEST(Polynomial, QuarticMonomialWorks) {
-  const double roots[4] = { 0.0, 0.0, 0.0, 0.0 };
+  const double roots[4] = {0.0, 0.0, 0.0, 0.0};
   RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
 }
 
 TEST(Polynomial, NullPointerAsImaginaryPartWorks) {
-  const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+  const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
   RunPolynomialTestRealRoots(roots, true, false, kEpsilon);
 }
 
 TEST(Polynomial, NullPointerAsRealPartWorks) {
-  const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+  const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
   RunPolynomialTestRealRoots(roots, false, true, kEpsilon);
 }
 
 TEST(Polynomial, BothOutputArgumentsNullWorks) {
-  const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+  const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
   RunPolynomialTestRealRoots(roots, false, false, kEpsilon);
 }
 
@@ -279,7 +280,6 @@
   EXPECT_EQ(optimal_value, 2.0);
 }
 
-
 TEST(Polynomial, MinimizeQuadraticPolynomial) {
   // p(x) = x^2 - 3 x + 2
   // min_x = 3/2
@@ -294,8 +294,8 @@
   double min_x = -2.0;
   double max_x = 2.0;
   MinimizePolynomial(polynomial, min_x, max_x, &optimal_x, &optimal_value);
-  EXPECT_EQ(optimal_x, 3.0/2.0);
-  EXPECT_EQ(optimal_value, -1.0/4.0);
+  EXPECT_EQ(optimal_x, 3.0 / 2.0);
+  EXPECT_EQ(optimal_value, -1.0 / 4.0);
 
   min_x = -2.0;
   max_x = 1.0;
@@ -402,7 +402,6 @@
   EXPECT_NEAR((true_polynomial - polynomial).norm(), 0.0, 1e-14);
 }
 
-
 TEST(Polynomial, CubicInterpolatingPolynomialFromValues) {
   // p(x) = x^3 + 2x^2 + 3x + 2
   Vector true_polynomial(4);
diff --git a/internal/ceres/preconditioner.cc b/internal/ceres/preconditioner.cc
index f98374e..69ba04d 100644
--- a/internal/ceres/preconditioner.cc
+++ b/internal/ceres/preconditioner.cc
@@ -29,13 +29,13 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include "ceres/preconditioner.h"
+
 #include "glog/logging.h"
 
 namespace ceres {
 namespace internal {
 
-Preconditioner::~Preconditioner() {
-}
+Preconditioner::~Preconditioner() {}
 
 PreconditionerType Preconditioner::PreconditionerForZeroEBlocks(
     PreconditionerType preconditioner_type) {
@@ -53,8 +53,7 @@
   CHECK(matrix != nullptr);
 }
 
-SparseMatrixPreconditionerWrapper::~SparseMatrixPreconditionerWrapper() {
-}
+SparseMatrixPreconditionerWrapper::~SparseMatrixPreconditionerWrapper() {}
 
 bool SparseMatrixPreconditionerWrapper::UpdateImpl(const SparseMatrix& A,
                                                    const double* D) {
@@ -66,7 +65,7 @@
   matrix_->RightMultiply(x, y);
 }
 
-int  SparseMatrixPreconditionerWrapper::num_rows() const {
+int SparseMatrixPreconditionerWrapper::num_rows() const {
   return matrix_->num_rows();
 }
 
diff --git a/internal/ceres/preconditioner.h b/internal/ceres/preconditioner.h
index 3e46ed8..b10364b 100644
--- a/internal/ceres/preconditioner.h
+++ b/internal/ceres/preconditioner.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_PRECONDITIONER_H_
 
 #include <vector>
+
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/context_impl.h"
@@ -50,7 +51,8 @@
   struct Options {
     PreconditionerType type = JACOBI;
     VisibilityClusteringType visibility_clustering_type = CANONICAL_VIEWS;
-    SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type = SUITE_SPARSE;
+    SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type =
+        SUITE_SPARSE;
 
     // When using the subset preconditioner, all row blocks starting
     // from this row block are used to construct the preconditioner.
@@ -137,9 +139,7 @@
   }
 
   int num_rows() const override = 0;
-  int num_cols() const override {
-    return num_rows();
-  }
+  int num_cols() const override { return num_rows(); }
 };
 
 // This templated subclass of Preconditioner serves as a base class for
@@ -159,9 +159,11 @@
 
 // Preconditioners that depend on access to the low level structure
 // of a SparseMatrix.
-typedef TypedPreconditioner<SparseMatrix>              SparseMatrixPreconditioner;               // NOLINT
-typedef TypedPreconditioner<BlockSparseMatrix>         BlockSparseMatrixPreconditioner;          // NOLINT
-typedef TypedPreconditioner<CompressedRowSparseMatrix> CompressedRowSparseMatrixPreconditioner;  // NOLINT
+// clang-format off
+typedef TypedPreconditioner<SparseMatrix>              SparseMatrixPreconditioner;
+typedef TypedPreconditioner<BlockSparseMatrix>         BlockSparseMatrixPreconditioner;
+typedef TypedPreconditioner<CompressedRowSparseMatrix> CompressedRowSparseMatrixPreconditioner;
+// clang-format on
 
 // Wrap a SparseMatrix object as a preconditioner.
 class SparseMatrixPreconditionerWrapper : public SparseMatrixPreconditioner {
diff --git a/internal/ceres/preprocessor.cc b/internal/ceres/preprocessor.cc
index 0221914..6a67d38 100644
--- a/internal/ceres/preprocessor.cc
+++ b/internal/ceres/preprocessor.cc
@@ -28,11 +28,12 @@
 //
 // Author: sameragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/preprocessor.h"
+
 #include "ceres/callbacks.h"
 #include "ceres/gradient_checking_cost_function.h"
 #include "ceres/line_search_preprocessor.h"
 #include "ceres/parallel_for.h"
-#include "ceres/preprocessor.h"
 #include "ceres/problem_impl.h"
 #include "ceres/solver.h"
 #include "ceres/trust_region_preprocessor.h"
@@ -53,17 +54,15 @@
   return NULL;
 }
 
-Preprocessor::~Preprocessor() {
-}
+Preprocessor::~Preprocessor() {}
 
 void ChangeNumThreadsIfNeeded(Solver::Options* options) {
   const int num_threads_available = MaxNumThreadsAvailable();
   if (options->num_threads > num_threads_available) {
-    LOG(WARNING)
-        << "Specified options.num_threads: " << options->num_threads
-        << " exceeds maximum available from the threading model Ceres "
-        << "was compiled with: " << num_threads_available
-        << ".  Bounding to maximum number available.";
+    LOG(WARNING) << "Specified options.num_threads: " << options->num_threads
+                 << " exceeds maximum available from the threading model Ceres "
+                 << "was compiled with: " << num_threads_available
+                 << ".  Bounding to maximum number available.";
     options->num_threads = num_threads_available;
   }
 }
@@ -83,16 +82,15 @@
   minimizer_options.evaluator = pp->evaluator;
 
   if (options.logging_type != SILENT) {
-    pp->logging_callback.reset(
-        new LoggingCallback(options.minimizer_type,
-                            options.minimizer_progress_to_stdout));
+    pp->logging_callback.reset(new LoggingCallback(
+        options.minimizer_type, options.minimizer_progress_to_stdout));
     minimizer_options.callbacks.insert(minimizer_options.callbacks.begin(),
                                        pp->logging_callback.get());
   }
 
   if (options.update_state_every_iteration) {
     pp->state_updating_callback.reset(
-      new StateUpdatingCallback(program, reduced_parameters));
+        new StateUpdatingCallback(program, reduced_parameters));
     // This must get pushed to the front of the callbacks so that it
     // is run before any of the user callbacks.
     minimizer_options.callbacks.insert(minimizer_options.callbacks.begin(),
diff --git a/internal/ceres/preprocessor.h b/internal/ceres/preprocessor.h
index 99bd6c0..e69c790 100644
--- a/internal/ceres/preprocessor.h
+++ b/internal/ceres/preprocessor.h
@@ -80,9 +80,7 @@
 // A PreprocessedProblem is the result of running the Preprocessor on
 // a Problem and Solver::Options object.
 struct PreprocessedProblem {
-  PreprocessedProblem()
-      : fixed_cost(0.0) {
-  }
+  PreprocessedProblem() : fixed_cost(0.0) {}
 
   std::string error;
   Solver::Options options;
diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index 9805891..5129b9a 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc
@@ -48,8 +48,8 @@
 #include "ceres/sized_cost_function.h"
 #include "ceres/sparse_matrix.h"
 #include "ceres/types.h"
-#include "gtest/gtest.h"
 #include "gmock/gmock.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -80,7 +80,7 @@
 };
 
 // Trivial cost function that accepts two arguments.
-class BinaryCostFunction: public CostFunction {
+class BinaryCostFunction : public CostFunction {
  public:
   BinaryCostFunction(int num_residuals,
                      int32_t parameter_block1_size,
@@ -101,7 +101,7 @@
 };
 
 // Trivial cost function that accepts three arguments.
-class TernaryCostFunction: public CostFunction {
+class TernaryCostFunction : public CostFunction {
  public:
   TernaryCostFunction(int num_residuals,
                       int32_t parameter_block1_size,
@@ -123,7 +123,6 @@
   }
 };
 
-
 TEST(Problem, MoveConstructor) {
   Problem src;
   double x;
@@ -172,23 +171,23 @@
 
   Problem problem;
   problem.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
-                                new UnaryCostFunction(
-                                    2, 4 /* 4 != 3 */), NULL, x),
-                            "different block sizes");
+  EXPECT_DEATH_IF_SUPPORTED(
+      problem.AddResidualBlock(
+          new UnaryCostFunction(2, 4 /* 4 != 3 */), NULL, x),
+      "different block sizes");
 }
 
 TEST(Problem, AddResidualWithDuplicateParametersDies) {
   double x[3], z[5];
 
   Problem problem;
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
-                                new BinaryCostFunction(2, 3, 3), NULL, x, x),
-                            "Duplicate parameter blocks");
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
-                                new TernaryCostFunction(1, 5, 3, 5),
-                                NULL, z, x, z),
-                            "Duplicate parameter blocks");
+  EXPECT_DEATH_IF_SUPPORTED(
+      problem.AddResidualBlock(new BinaryCostFunction(2, 3, 3), NULL, x, x),
+      "Duplicate parameter blocks");
+  EXPECT_DEATH_IF_SUPPORTED(
+      problem.AddResidualBlock(
+          new TernaryCostFunction(1, 5, 3, 5), NULL, z, x, z),
+      "Duplicate parameter blocks");
 }
 
 TEST(Problem, AddResidualWithIncorrectSizesOfParameterBlockDies) {
@@ -201,9 +200,9 @@
 
   // The cost function expects the size of the second parameter, z, to be 4
   // instead of 5 as declared above. This is fatal.
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
-      new BinaryCostFunction(2, 3, 4), NULL, x, z),
-               "different block sizes");
+  EXPECT_DEATH_IF_SUPPORTED(
+      problem.AddResidualBlock(new BinaryCostFunction(2, 3, 4), NULL, x, z),
+      "different block sizes");
 }
 
 TEST(Problem, AddResidualAddsDuplicatedParametersOnlyOnce) {
@@ -230,7 +229,7 @@
                             "different block sizes");
 }
 
-static double *IntToPtr(int i) {
+static double* IntToPtr(int i) {
   return reinterpret_cast<double*>(sizeof(double) * i);  // NOLINT
 }
 
@@ -246,16 +245,16 @@
   // ones marked with o==o and aliasing ones marked with o--o.
 
   Problem problem;
-  problem.AddParameterBlock(IntToPtr(5),  5);  // x
+  problem.AddParameterBlock(IntToPtr(5), 5);   // x
   problem.AddParameterBlock(IntToPtr(13), 3);  // y
 
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 4), 2),
+  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(4), 2),
                             "Aliasing detected");
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 4), 3),
+  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(4), 3),
                             "Aliasing detected");
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 4), 9),
+  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(4), 9),
                             "Aliasing detected");
-  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 8), 3),
+  EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(8), 3),
                             "Aliasing detected");
   EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(12), 2),
                             "Aliasing detected");
@@ -263,7 +262,7 @@
                             "Aliasing detected");
 
   // These ones should work.
-  problem.AddParameterBlock(IntToPtr( 2), 3);
+  problem.AddParameterBlock(IntToPtr(2), 3);
   problem.AddParameterBlock(IntToPtr(10), 3);
   problem.AddParameterBlock(IntToPtr(16), 2);
 
@@ -306,17 +305,20 @@
   EXPECT_EQ(7, problem.NumParameters());
 
   problem.AddParameterBlock(z, 5);
-  EXPECT_EQ(3,  problem.NumParameterBlocks());
+  EXPECT_EQ(3, problem.NumParameterBlocks());
   EXPECT_EQ(12, problem.NumParameters());
 
   // Add a parameter that has a local parameterization.
-  w[0] = 1.0; w[1] = 0.0; w[2] = 0.0; w[3] = 0.0;
+  w[0] = 1.0;
+  w[1] = 0.0;
+  w[2] = 0.0;
+  w[3] = 0.0;
   problem.AddParameterBlock(w, 4, new QuaternionParameterization);
-  EXPECT_EQ(4,  problem.NumParameterBlocks());
+  EXPECT_EQ(4, problem.NumParameterBlocks());
   EXPECT_EQ(16, problem.NumParameters());
 
   problem.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
-  problem.AddResidualBlock(new BinaryCostFunction(6, 5, 4) , NULL, z, y);
+  problem.AddResidualBlock(new BinaryCostFunction(6, 5, 4), NULL, z, y);
   problem.AddResidualBlock(new BinaryCostFunction(3, 3, 5), NULL, x, z);
   problem.AddResidualBlock(new BinaryCostFunction(7, 5, 3), NULL, z, x);
   problem.AddResidualBlock(new TernaryCostFunction(1, 5, 3, 4), NULL, z, x, y);
@@ -328,12 +330,10 @@
 
 class DestructorCountingCostFunction : public SizedCostFunction<3, 4, 5> {
  public:
-  explicit DestructorCountingCostFunction(int *num_destructions)
+  explicit DestructorCountingCostFunction(int* num_destructions)
       : num_destructions_(num_destructions) {}
 
-  virtual ~DestructorCountingCostFunction() {
-    *num_destructions_ += 1;
-  }
+  virtual ~DestructorCountingCostFunction() { *num_destructions_ += 1; }
 
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -463,8 +463,7 @@
   // The next block of functions until the end are only for testing the
   // residual block removals.
   void ExpectParameterBlockContainsResidualBlock(
-      double* values,
-      ResidualBlock* residual_block) {
+      double* values, ResidualBlock* residual_block) {
     ParameterBlock* parameter_block =
         FindOrDie(problem->parameter_map(), values);
     EXPECT_TRUE(ContainsKey(*(parameter_block->mutable_residual_blocks()),
@@ -478,12 +477,9 @@
   }
 
   // Degenerate case.
-  void ExpectParameterBlockContains(double* values) {
-    ExpectSize(values, 0);
-  }
+  void ExpectParameterBlockContains(double* values) { ExpectSize(values, 0); }
 
-  void ExpectParameterBlockContains(double* values,
-                                    ResidualBlock* r1) {
+  void ExpectParameterBlockContains(double* values, ResidualBlock* r1) {
     ExpectSize(values, 1);
     ExpectParameterBlockContainsResidualBlock(values, r1);
   }
@@ -598,8 +594,8 @@
   Problem problem;
   problem.AddParameterBlock(x, 3);
 
-  EXPECT_DEATH_IF_SUPPORTED(
-      problem.RemoveParameterBlock(y), "Parameter block not found:");
+  EXPECT_DEATH_IF_SUPPORTED(problem.RemoveParameterBlock(y),
+                            "Parameter block not found:");
 }
 
 TEST(Problem, GetParameterization) {
@@ -610,7 +606,7 @@
   problem.AddParameterBlock(x, 3);
   problem.AddParameterBlock(y, 2);
 
-  LocalParameterization* parameterization =  new IdentityParameterization(3);
+  LocalParameterization* parameterization = new IdentityParameterization(3);
   problem.SetParameterization(x, parameterization);
   EXPECT_EQ(problem.GetParameterization(x), parameterization);
   EXPECT_TRUE(problem.GetParameterization(y) == NULL);
@@ -626,8 +622,7 @@
   vector<int> constant_parameters;
   constant_parameters.push_back(0);
   problem.SetParameterization(
-      x,
-      new SubsetParameterization(3, constant_parameters));
+      x, new SubsetParameterization(3, constant_parameters));
   EXPECT_EQ(problem.ParameterBlockSize(x), 3);
   EXPECT_EQ(problem.ParameterBlockLocalSize(x), 2);
   EXPECT_EQ(problem.ParameterBlockLocalSize(y), 4);
@@ -714,6 +709,8 @@
   EXPECT_EQ(z, GetParameterBlock(1)->user_state());
   EXPECT_EQ(w, GetParameterBlock(2)->user_state());
 
+  // clang-format off
+
   // Add all combinations of cost functions.
   CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
   CostFunction* cost_yz  = new BinaryCostFunction (1, 4, 5);
@@ -764,6 +761,8 @@
   problem->RemoveParameterBlock(y);
   EXPECT_EQ(0, problem->NumParameterBlocks());
   EXPECT_EQ(0, NumResidualBlocks());
+
+  // clang-format on
 }
 
 TEST_P(DynamicProblem, RemoveResidualBlock) {
@@ -771,6 +770,8 @@
   problem->AddParameterBlock(z, 5);
   problem->AddParameterBlock(w, 3);
 
+  // clang-format off
+
   // Add all combinations of cost functions.
   CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
   CostFunction* cost_yz  = new BinaryCostFunction (1, 4, 5);
@@ -885,6 +886,8 @@
     ExpectParameterBlockContains(z);
     ExpectParameterBlockContains(w);
   }
+
+  // clang-format on
 }
 
 TEST_P(DynamicProblem, RemoveInvalidResidualBlockDies) {
@@ -892,6 +895,8 @@
   problem->AddParameterBlock(z, 5);
   problem->AddParameterBlock(w, 3);
 
+  // clang-format off
+
   // Add all combinations of cost functions.
   CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
   CostFunction* cost_yz  = new BinaryCostFunction (1, 4, 5);
@@ -909,6 +914,8 @@
   ResidualBlock* r_z   = problem->AddResidualBlock(cost_z,   NULL, z);
   ResidualBlock* r_w   = problem->AddResidualBlock(cost_w,   NULL, w);
 
+  // clang-format on
+
   // Remove r_yzw.
   problem->RemoveResidualBlock(r_yzw);
   ASSERT_EQ(3, problem->NumParameterBlocks());
@@ -938,7 +945,7 @@
 }
 
 // Check that a null-terminated array, a, has the same elements as b.
-template<typename T>
+template <typename T>
 void ExpectVectorContainsUnordered(const T* a, const vector<T>& b) {
   // Compute the size of a.
   int size = 0;
@@ -963,8 +970,8 @@
 }
 
 static void ExpectProblemHasResidualBlocks(
-    const ProblemImpl &problem,
-    const ResidualBlockId *expected_residual_blocks) {
+    const ProblemImpl& problem,
+    const ResidualBlockId* expected_residual_blocks) {
   vector<ResidualBlockId> residual_blocks;
   problem.GetResidualBlocks(&residual_blocks);
   ExpectVectorContainsUnordered(expected_residual_blocks, residual_blocks);
@@ -975,6 +982,8 @@
   problem->AddParameterBlock(z, 5);
   problem->AddParameterBlock(w, 3);
 
+  // clang-format off
+
   // Add all combinations of cost functions.
   CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
   CostFunction* cost_yz  = new BinaryCostFunction (1, 4, 5);
@@ -1070,6 +1079,8 @@
         get_parameter_blocks_cases[i].expected_parameter_blocks,
         parameter_blocks);
   }
+
+  // clang-format on
 }
 
 INSTANTIATE_TEST_SUITE_P(OptionsInstantiation,
@@ -1108,8 +1119,8 @@
     for (int j = 0; j < kNumParameterBlocks; ++j) {
       if (jacobians[j] != NULL) {
         MatrixRef(jacobians[j], kNumResiduals, kNumResiduals) =
-            (-2.0 * (j + 1.0) *
-             ConstVectorRef(parameters[j], kNumResiduals)).asDiagonal();
+            (-2.0 * (j + 1.0) * ConstVectorRef(parameters[j], kNumResiduals))
+                .asDiagonal();
       }
     }
 
@@ -1142,31 +1153,20 @@
     parameter_blocks_.push_back(parameters_ + 2);
     parameter_blocks_.push_back(parameters_ + 4);
 
-
     CostFunction* cost_function = new QuadraticCostFunction<2, 2>;
 
     // f(x, y)
-    residual_blocks_.push_back(
-        problem_.AddResidualBlock(cost_function,
-                                  NULL,
-                                  parameters_,
-                                  parameters_ + 2));
+    residual_blocks_.push_back(problem_.AddResidualBlock(
+        cost_function, NULL, parameters_, parameters_ + 2));
     // g(y, z)
-    residual_blocks_.push_back(
-        problem_.AddResidualBlock(cost_function,
-                                  NULL, parameters_ + 2,
-                                  parameters_ + 4));
+    residual_blocks_.push_back(problem_.AddResidualBlock(
+        cost_function, NULL, parameters_ + 2, parameters_ + 4));
     // h(z, x)
-    residual_blocks_.push_back(
-        problem_.AddResidualBlock(cost_function,
-                                  NULL,
-                                  parameters_ + 4,
-                                  parameters_));
+    residual_blocks_.push_back(problem_.AddResidualBlock(
+        cost_function, NULL, parameters_ + 4, parameters_));
   }
 
-  void TearDown() {
-    EXPECT_TRUE(problem_.program().IsValid());
-  }
+  void TearDown() { EXPECT_TRUE(problem_.program().IsValid()); }
 
   void EvaluateAndCompare(const Problem::EvaluateOptions& options,
                           const int expected_num_rows,
@@ -1225,8 +1225,8 @@
                          expected.num_cols,
                          expected.cost,
                          (i & 1) ? expected.residuals : NULL,
-                         (i & 2) ? expected.gradient  : NULL,
-                         (i & 4) ? expected.jacobian  : NULL);
+                         (i & 2) ? expected.gradient : NULL,
+                         (i & 4) ? expected.jacobian : NULL);
     }
   }
 
@@ -1236,8 +1236,8 @@
   vector<ResidualBlockId> residual_blocks_;
 };
 
-
 TEST_F(ProblemEvaluateTest, MultipleParameterAndResidualBlocks) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     6, 6,
@@ -1263,11 +1263,13 @@
                      0.0, -8.0,   0.0,   0.0,   0.0, -12.0
     }
   };
+  // clang-format on
 
   CheckAllEvaluationCombinations(Problem::EvaluateOptions(), expected);
 }
 
 TEST_F(ProblemEvaluateTest, ParameterAndResidualBlocksPassedInOptions) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     6, 6,
@@ -1293,6 +1295,7 @@
                      0.0, -8.0,   0.0,   0.0,   0.0, -12.0
     }
   };
+  // clang-format on
 
   Problem::EvaluateOptions evaluate_options;
   evaluate_options.parameter_blocks = parameter_blocks_;
@@ -1301,6 +1304,7 @@
 }
 
 TEST_F(ProblemEvaluateTest, ReorderedResidualBlocks) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     6, 6,
@@ -1326,6 +1330,7 @@
                      0.0,  0.0,   0.0,  -8.0,   0.0, -24.0
     }
   };
+  // clang-format on
 
   Problem::EvaluateOptions evaluate_options;
   evaluate_options.parameter_blocks = parameter_blocks_;
@@ -1338,7 +1343,9 @@
   CheckAllEvaluationCombinations(evaluate_options, expected);
 }
 
-TEST_F(ProblemEvaluateTest, ReorderedResidualBlocksAndReorderedParameterBlocks) {
+TEST_F(ProblemEvaluateTest,
+       ReorderedResidualBlocksAndReorderedParameterBlocks) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     6, 6,
@@ -1364,6 +1371,7 @@
                       0.0, -24.0,   0.0,  -8.0,   0.0,   0.0
     }
   };
+  // clang-format on
 
   Problem::EvaluateOptions evaluate_options;
   // z, y, x
@@ -1380,6 +1388,7 @@
 }
 
 TEST_F(ProblemEvaluateTest, ConstantParameterBlock) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     6, 6,
@@ -1407,12 +1416,14 @@
                      0.0, -8.0,   0.0,   0.0,   0.0, -12.0
     }
   };
+  // clang-format on
 
   problem_.SetParameterBlockConstant(parameters_ + 2);
   CheckAllEvaluationCombinations(Problem::EvaluateOptions(), expected);
 }
 
 TEST_F(ProblemEvaluateTest, ExcludedAResidualBlock) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     4, 6,
@@ -1435,6 +1446,7 @@
                      0.0, -8.0,   0.0,   0.0,   0.0, -12.0
     }
   };
+  // clang-format on
 
   Problem::EvaluateOptions evaluate_options;
   evaluate_options.residual_blocks.push_back(residual_blocks_[0]);
@@ -1444,6 +1456,7 @@
 }
 
 TEST_F(ProblemEvaluateTest, ExcludedParameterBlock) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     6, 4,
@@ -1470,6 +1483,7 @@
                      0.0, -8.0,   0.0, -12.0
     }
   };
+  // clang-format on
 
   Problem::EvaluateOptions evaluate_options;
   // x, z
@@ -1480,6 +1494,7 @@
 }
 
 TEST_F(ProblemEvaluateTest, ExcludedParameterBlockAndExcludedResidualBlock) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     4, 4,
@@ -1503,6 +1518,7 @@
                      0.0,  0.0,   0.0, -24.0,
     }
   };
+  // clang-format on
 
   Problem::EvaluateOptions evaluate_options;
   // x, z
@@ -1515,6 +1531,7 @@
 }
 
 TEST_F(ProblemEvaluateTest, LocalParameterization) {
+  // clang-format off
   ExpectedEvaluation expected = {
     // Rows/columns
     6, 5,
@@ -1540,12 +1557,12 @@
                      0.0, -8.0,   0.0,   0.0, -12.0
     }
   };
+  // clang-format on
 
   vector<int> constant_parameters;
   constant_parameters.push_back(0);
-  problem_.SetParameterization(parameters_ + 2,
-                               new SubsetParameterization(2,
-                                                          constant_parameters));
+  problem_.SetParameterization(
+      parameters_ + 2, new SubsetParameterization(2, constant_parameters));
 
   CheckAllEvaluationCombinations(Problem::EvaluateOptions(), expected);
 }
diff --git a/internal/ceres/program.h b/internal/ceres/program.h
index 7971299..c4935e3 100644
--- a/internal/ceres/program.h
+++ b/internal/ceres/program.h
@@ -36,8 +36,8 @@
 #include <string>
 #include <vector>
 
-#include "ceres/internal/port.h"
 #include "ceres/evaluation_callback.h"
+#include "ceres/internal/port.h"
 
 namespace ceres {
 namespace internal {
diff --git a/internal/ceres/program_evaluator.h b/internal/ceres/program_evaluator.h
index 97ee590..36c9c64 100644
--- a/internal/ceres/program_evaluator.h
+++ b/internal/ceres/program_evaluator.h
@@ -80,7 +80,9 @@
 #define CERES_INTERNAL_PROGRAM_EVALUATOR_H_
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
 
 #include <atomic>
 #include <map>
diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index be6ad87..1d9f49c 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -99,7 +99,8 @@
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
   string message;
-  std::unique_ptr<Program> reduced_program(problem.program().CreateReducedProgram(
+  std::unique_ptr<Program> reduced_program(
+      problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
 
   EXPECT_EQ(reduced_program->NumParameterBlocks(), 3);
@@ -130,7 +131,6 @@
   EXPECT_EQ(fixed_cost, 9.0);
 }
 
-
 TEST(Program, RemoveFixedBlocksNoResidualBlocks) {
   ProblemImpl problem;
   double x;
@@ -215,17 +215,13 @@
   problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
   problem.SetParameterBlockConstant(&x);
 
-  ResidualBlock *expected_removed_block =
+  ResidualBlock* expected_removed_block =
       problem.program().residual_blocks()[0];
   std::unique_ptr<double[]> scratch(
       new double[expected_removed_block->NumScratchDoublesForEvaluate()]);
   double expected_fixed_cost;
-  expected_removed_block->Evaluate(true,
-                                   &expected_fixed_cost,
-                                   nullptr,
-                                   nullptr,
-                                   scratch.get());
-
+  expected_removed_block->Evaluate(
+      true, &expected_fixed_cost, nullptr, nullptr, scratch.get());
 
   vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
@@ -323,9 +319,7 @@
   EXPECT_EQ((expected_dense_jacobian - actual_dense_jacobian).norm(), 0.0);
 }
 
-INSTANTIATE_TEST_SUITE_P(AllColumns,
-                         BlockJacobianTest,
-                         ::testing::Range(0, 7));
+INSTANTIATE_TEST_SUITE_P(AllColumns, BlockJacobianTest, ::testing::Range(0, 7));
 
 template <int kNumResiduals, int kNumParameterBlocks>
 class NumParameterBlocksCostFunction : public CostFunction {
@@ -337,8 +331,7 @@
     }
   }
 
-  virtual ~NumParameterBlocksCostFunction() {
-  }
+  virtual ~NumParameterBlocksCostFunction() {}
 
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -403,8 +396,8 @@
   problem.AddResidualBlock(new MockCostFunctionBase<1, 2>(), nullptr, x);
   string error;
   EXPECT_FALSE(problem.program().ParameterBlocksAreFinite(&error));
-  EXPECT_NE(error.find("has at least one invalid value"),
-            string::npos) << error;
+  EXPECT_NE(error.find("has at least one invalid value"), string::npos)
+      << error;
 }
 
 TEST(Program, InfeasibleParameterBlock) {
diff --git a/internal/ceres/random.h b/internal/ceres/random.h
index 87d9d77..6b280f9 100644
--- a/internal/ceres/random.h
+++ b/internal/ceres/random.h
@@ -34,13 +34,12 @@
 
 #include <cmath>
 #include <cstdlib>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
 
-inline void SetRandomState(int state) {
-  srand(state);
-}
+inline void SetRandomState(int state) { srand(state); }
 
 inline int Uniform(int n) {
   if (n) {
@@ -63,7 +62,7 @@
     x1 = 2.0 * RandDouble() - 1.0;
     x2 = 2.0 * RandDouble() - 1.0;
     w = x1 * x1 + x2 * x2;
-  } while ( w >= 1.0 || w == 0.0 );
+  } while (w >= 1.0 || w == 0.0);
 
   w = sqrt((-2.0 * log(w)) / w);
   return x1 * w;
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index aa6032a..5d80236 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -35,6 +35,7 @@
 #include <numeric>
 #include <vector>
 
+#include "Eigen/SparseCore"
 #include "ceres/cxsparse.h"
 #include "ceres/internal/port.h"
 #include "ceres/ordered_groups.h"
@@ -47,7 +48,6 @@
 #include "ceres/suitesparse.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "Eigen/SparseCore"
 
 #ifdef CERES_USE_EIGEN_SPARSE
 #include "Eigen/OrderingMethods"
@@ -78,8 +78,8 @@
       CHECK_NE(parameter_block->index(), -1)
           << "Did you forget to call Program::SetParameterOffsetsAndIndex()? "
           << "This is a Ceres bug; please contact the developers!";
-      min_parameter_block_position = std::min(parameter_block->index(),
-                                              min_parameter_block_position);
+      min_parameter_block_position =
+          std::min(parameter_block->index(), min_parameter_block_position);
     }
   }
   return min_parameter_block_position;
@@ -117,9 +117,8 @@
              << "Please report this error to the developers.";
 #else
   SuiteSparse ss;
-  cholmod_sparse* block_jacobian_transpose =
-      ss.CreateSparseMatrix(
-          const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
+  cholmod_sparse* block_jacobian_transpose = ss.CreateSparseMatrix(
+      const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
 
   // No CAMD or the user did not supply a useful ordering, then just
   // use regular AMD.
@@ -129,18 +128,16 @@
   } else {
     vector<int> constraints;
     for (int i = 0; i < parameter_blocks.size(); ++i) {
-      constraints.push_back(
-          parameter_block_ordering.GroupId(
-              parameter_blocks[i]->mutable_user_state()));
+      constraints.push_back(parameter_block_ordering.GroupId(
+          parameter_blocks[i]->mutable_user_state()));
     }
 
     // Renumber the entries of constraints to be contiguous integers
     // as CAMD requires that the group ids be in the range [0,
     // parameter_blocks.size() - 1].
     MapValuesToContiguousRange(constraints.size(), &constraints[0]);
-    ss.ConstrainedApproximateMinimumDegreeOrdering(block_jacobian_transpose,
-                                                   &constraints[0],
-                                                   ordering);
+    ss.ConstrainedApproximateMinimumDegreeOrdering(
+        block_jacobian_transpose, &constraints[0], ordering);
   }
 
   VLOG(2) << "Block ordering stats: "
@@ -153,20 +150,18 @@
 }
 
 void OrderingForSparseNormalCholeskyUsingCXSparse(
-    const TripletSparseMatrix& tsm_block_jacobian_transpose,
-    int* ordering) {
+    const TripletSparseMatrix& tsm_block_jacobian_transpose, int* ordering) {
 #ifdef CERES_NO_CXSPARSE
   LOG(FATAL) << "Congratulations, you found a Ceres bug! "
              << "Please report this error to the developers.";
-#else  // CERES_NO_CXSPARSE
+#else
   // CXSparse works with J'J instead of J'. So compute the block
   // sparsity for J'J and compute an approximate minimum degree
   // ordering.
   CXSparse cxsparse;
   cs_di* block_jacobian_transpose;
-  block_jacobian_transpose =
-      cxsparse.CreateSparseMatrix(
-            const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
+  block_jacobian_transpose = cxsparse.CreateSparseMatrix(
+      const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
   cs_di* block_jacobian = cxsparse.TransposeMatrix(block_jacobian_transpose);
   cs_di* block_hessian =
       cxsparse.MatrixMatrixMultiply(block_jacobian_transpose, block_jacobian);
@@ -178,16 +173,13 @@
 #endif  // CERES_NO_CXSPARSE
 }
 
-
 void OrderingForSparseNormalCholeskyUsingEigenSparse(
-    const TripletSparseMatrix& tsm_block_jacobian_transpose,
-    int* ordering) {
+    const TripletSparseMatrix& tsm_block_jacobian_transpose, int* ordering) {
 #ifndef CERES_USE_EIGEN_SPARSE
-  LOG(FATAL) <<
-      "SPARSE_NORMAL_CHOLESKY cannot be used with EIGEN_SPARSE "
-      "because Ceres was not built with support for "
-      "Eigen's SimplicialLDLT decomposition. "
-      "This requires enabling building with -DEIGENSPARSE=ON.";
+  LOG(FATAL) << "SPARSE_NORMAL_CHOLESKY cannot be used with EIGEN_SPARSE "
+                "because Ceres was not built with support for "
+                "Eigen's SimplicialLDLT decomposition. "
+                "This requires enabling building with -DEIGENSPARSE=ON.";
 #else
 
   // This conversion from a TripletSparseMatrix to a Eigen::Triplet
@@ -218,13 +210,14 @@
                    const ParameterBlockOrdering& ordering,
                    Program* program,
                    string* error) {
-  const int num_parameter_blocks =  program->NumParameterBlocks();
+  const int num_parameter_blocks = program->NumParameterBlocks();
   if (ordering.NumElements() != num_parameter_blocks) {
-    *error = StringPrintf("User specified ordering does not have the same "
-                          "number of parameters as the problem. The problem"
-                          "has %d blocks while the ordering has %d blocks.",
-                          num_parameter_blocks,
-                          ordering.NumElements());
+    *error = StringPrintf(
+        "User specified ordering does not have the same "
+        "number of parameters as the problem. The problem"
+        "has %d blocks while the ordering has %d blocks.",
+        num_parameter_blocks,
+        ordering.NumElements());
     return false;
   }
 
@@ -238,10 +231,11 @@
     for (double* parameter_block_ptr : group) {
       auto it = parameter_map.find(parameter_block_ptr);
       if (it == parameter_map.end()) {
-        *error = StringPrintf("User specified ordering contains a pointer "
-                              "to a double that is not a parameter block in "
-                              "the problem. The invalid double is in group: %d",
-                              p.first);
+        *error = StringPrintf(
+            "User specified ordering contains a pointer "
+            "to a double that is not a parameter block in "
+            "the problem. The invalid double is in group: %d",
+            p.first);
         return false;
       }
       parameter_blocks->push_back(it->second);
@@ -265,8 +259,8 @@
   vector<int> min_position_per_residual(residual_blocks->size());
   for (int i = 0; i < residual_blocks->size(); ++i) {
     ResidualBlock* residual_block = (*residual_blocks)[i];
-    int position = MinParameterBlock(residual_block,
-                                     size_of_first_elimination_group);
+    int position =
+        MinParameterBlock(residual_block, size_of_first_elimination_group);
     min_position_per_residual[i] = position;
     DCHECK_LE(position, size_of_first_elimination_group);
     residual_blocks_per_e_block[position]++;
@@ -284,8 +278,8 @@
       << "to the developers.";
 
   CHECK(find(residual_blocks_per_e_block.begin(),
-             residual_blocks_per_e_block.end() - 1, 0) !=
-        residual_blocks_per_e_block.end())
+             residual_blocks_per_e_block.end() - 1,
+             0) != residual_blocks_per_e_block.end())
       << "Congratulations, you found a Ceres bug! Please report this error "
       << "to the developers.";
 
@@ -334,8 +328,7 @@
 // Pre-order the columns corresponding to the schur complement if
 // possible.
 static void MaybeReorderSchurComplementColumnsUsingSuiteSparse(
-    const ParameterBlockOrdering& parameter_block_ordering,
-    Program* program) {
+    const ParameterBlockOrdering& parameter_block_ordering, Program* program) {
 #ifndef CERES_NO_SUITESPARSE
   SuiteSparse ss;
   if (!SuiteSparse::IsConstrainedApproximateMinimumDegreeOrderingAvailable()) {
@@ -347,9 +340,8 @@
       *(program->mutable_parameter_blocks());
 
   for (int i = 0; i < parameter_blocks.size(); ++i) {
-    constraints.push_back(
-        parameter_block_ordering.GroupId(
-            parameter_blocks[i]->mutable_user_state()));
+    constraints.push_back(parameter_block_ordering.GroupId(
+        parameter_blocks[i]->mutable_user_state()));
   }
 
   // Renumber the entries of constraints to be contiguous integers as
@@ -365,9 +357,8 @@
       ss.CreateSparseMatrix(tsm_block_jacobian_transpose.get());
 
   vector<int> ordering(parameter_blocks.size(), 0);
-  ss.ConstrainedApproximateMinimumDegreeOrdering(block_jacobian_transpose,
-                                                 &constraints[0],
-                                                 &ordering[0]);
+  ss.ConstrainedApproximateMinimumDegreeOrdering(
+      block_jacobian_transpose, &constraints[0], &ordering[0]);
   ss.Free(block_jacobian_transpose);
 
   const vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
@@ -396,10 +387,7 @@
   // Vertically partition the jacobian in parameter blocks of type E
   // and F.
   const SparseMatrix E =
-      block_jacobian.block(0,
-                           0,
-                           num_rows,
-                           size_of_first_elimination_group);
+      block_jacobian.block(0, 0, num_rows, size_of_first_elimination_group);
   const SparseMatrix F =
       block_jacobian.block(0,
                            size_of_first_elimination_group,
@@ -482,22 +470,17 @@
 
     // Verify that the first elimination group is an independent set.
     const set<double*>& first_elimination_group =
-        parameter_block_ordering
-        ->group_to_elements()
-        .begin()
-        ->second;
+        parameter_block_ordering->group_to_elements().begin()->second;
     if (!program->IsParameterBlockSetIndependent(first_elimination_group)) {
-      *error =
-          StringPrintf("The first elimination group in the parameter block "
-                       "ordering of size %zd is not an independent set",
-                       first_elimination_group.size());
+      *error = StringPrintf(
+          "The first elimination group in the parameter block "
+          "ordering of size %zd is not an independent set",
+          first_elimination_group.size());
       return false;
     }
 
-    if (!ApplyOrdering(parameter_map,
-                       *parameter_block_ordering,
-                       program,
-                       error)) {
+    if (!ApplyOrdering(
+            parameter_map, *parameter_block_ordering, program, error)) {
       return false;
     }
   }
@@ -510,13 +493,10 @@
   if (linear_solver_type == SPARSE_SCHUR) {
     if (sparse_linear_algebra_library_type == SUITE_SPARSE) {
       MaybeReorderSchurComplementColumnsUsingSuiteSparse(
-          *parameter_block_ordering,
-          program);
+          *parameter_block_ordering, program);
     } else if (sparse_linear_algebra_library_type == EIGEN_SPARSE) {
       MaybeReorderSchurComplementColumnsUsingEigen(
-          size_of_first_elimination_group,
-          parameter_map,
-          program);
+          size_of_first_elimination_group, parameter_map, program);
     }
   }
 
@@ -556,9 +536,8 @@
         parameter_block_ordering,
         &ordering[0]);
   } else if (sparse_linear_algebra_library_type == CX_SPARSE) {
-    OrderingForSparseNormalCholeskyUsingCXSparse(
-        *tsm_block_jacobian_transpose,
-        &ordering[0]);
+    OrderingForSparseNormalCholeskyUsingCXSparse(*tsm_block_jacobian_transpose,
+                                                 &ordering[0]);
   } else if (sparse_linear_algebra_library_type == ACCELERATE_SPARSE) {
     // Accelerate does not provide a function to perform reordering without
     // performing a full symbolic factorisation.  As such, we have nothing
@@ -570,8 +549,7 @@
 
   } else if (sparse_linear_algebra_library_type == EIGEN_SPARSE) {
     OrderingForSparseNormalCholeskyUsingEigenSparse(
-        *tsm_block_jacobian_transpose,
-        &ordering[0]);
+        *tsm_block_jacobian_transpose, &ordering[0]);
   }
 
   // Apply ordering.
@@ -588,11 +566,11 @@
     const std::unordered_set<ResidualBlockId>& bottom_residual_blocks,
     Program* program) {
   auto residual_blocks = program->mutable_residual_blocks();
-  auto it = std::partition(
-      residual_blocks->begin(), residual_blocks->end(),
-      [&bottom_residual_blocks](ResidualBlock* r) {
-        return bottom_residual_blocks.count(r) == 0;
-      });
+  auto it = std::partition(residual_blocks->begin(),
+                           residual_blocks->end(),
+                           [&bottom_residual_blocks](ResidualBlock* r) {
+                             return bottom_residual_blocks.count(r) == 0;
+                           });
   return it - residual_blocks->begin();
 }
 
diff --git a/internal/ceres/reorder_program.h b/internal/ceres/reorder_program.h
index 88cbee3..e32079c 100644
--- a/internal/ceres/reorder_program.h
+++ b/internal/ceres/reorder_program.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_REORDER_PROGRAM_H_
 
 #include <string>
+
 #include "ceres/internal/port.h"
 #include "ceres/parameter_block_ordering.h"
 #include "ceres/problem_impl.h"
diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index 2cfc123..83c867a 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/reorder_program.h"
 
 #include <random>
+
 #include "ceres/parameter_block.h"
 #include "ceres/problem_impl.h"
 #include "ceres/program.h"
@@ -107,9 +108,7 @@
 
   std::string message;
   EXPECT_TRUE(LexicographicallyOrderResidualBlocks(
-                  2,
-                  problem.mutable_program(),
-                  &message));
+      2, problem.mutable_program(), &message));
   EXPECT_EQ(residual_blocks.size(), expected_residual_blocks.size());
   for (int i = 0; i < expected_residual_blocks.size(); ++i) {
     EXPECT_EQ(residual_blocks[i], expected_residual_blocks[i]);
@@ -132,10 +131,8 @@
 
   Program program(problem.program());
   std::string message;
-  EXPECT_FALSE(ApplyOrdering(problem.parameter_map(),
-                             linear_solver_ordering,
-                             &program,
-                             &message));
+  EXPECT_FALSE(ApplyOrdering(
+      problem.parameter_map(), linear_solver_ordering, &program, &message));
 }
 
 TEST(_, ApplyOrderingNormal) {
@@ -156,10 +153,8 @@
   Program* program = problem.mutable_program();
   std::string message;
 
-  EXPECT_TRUE(ApplyOrdering(problem.parameter_map(),
-                            linear_solver_ordering,
-                            program,
-                            &message));
+  EXPECT_TRUE(ApplyOrdering(
+      problem.parameter_map(), linear_solver_ordering, program, &message));
   const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
 
   EXPECT_EQ(parameter_blocks.size(), 3);
@@ -169,8 +164,8 @@
 }
 
 #ifndef CERES_NO_SUITESPARSE
-class ReorderProgramFoSparseCholeskyUsingSuiteSparseTest :
-      public ::testing::Test {
+class ReorderProgramFoSparseCholeskyUsingSuiteSparseTest
+    : public ::testing::Test {
  protected:
   void SetUp() {
     problem_.AddResidualBlock(new UnaryCostFunction(), nullptr, &x_);
@@ -188,12 +183,11 @@
         program->parameter_blocks();
 
     std::string error;
-    EXPECT_TRUE(ReorderProgramForSparseCholesky(
-                    ceres::SUITE_SPARSE,
-                    linear_solver_ordering,
-                    0, /* use all rows */
-                    program,
-                    &error));
+    EXPECT_TRUE(ReorderProgramForSparseCholesky(ceres::SUITE_SPARSE,
+                                                linear_solver_ordering,
+                                                0, /* use all rows */
+                                                program,
+                                                &error));
     const vector<ParameterBlock*>& ordered_parameter_blocks =
         program->parameter_blocks();
     EXPECT_EQ(ordered_parameter_blocks.size(),
@@ -219,8 +213,7 @@
   ComputeAndValidateOrdering(linear_solver_ordering);
 }
 
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest,
-       ContiguousGroups) {
+TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest, ContiguousGroups) {
   ParameterBlockOrdering linear_solver_ordering;
   linear_solver_ordering.AddElementToGroup(&x_, 0);
   linear_solver_ordering.AddElementToGroup(&y_, 1);
@@ -229,8 +222,7 @@
   ComputeAndValidateOrdering(linear_solver_ordering);
 }
 
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest,
-       GroupsWithGaps) {
+TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest, GroupsWithGaps) {
   ParameterBlockOrdering linear_solver_ordering;
   linear_solver_ordering.AddElementToGroup(&x_, 0);
   linear_solver_ordering.AddElementToGroup(&y_, 2);
diff --git a/internal/ceres/residual_block.cc b/internal/ceres/residual_block.cc
index 0bf30bc..067c9ef 100644
--- a/internal/ceres/residual_block.cc
+++ b/internal/ceres/residual_block.cc
@@ -34,6 +34,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <vector>
+
 #include "ceres/corrector.h"
 #include "ceres/cost_function.h"
 #include "ceres/internal/eigen.h"
@@ -50,8 +51,10 @@
 namespace internal {
 
 ResidualBlock::ResidualBlock(
-    const CostFunction* cost_function, const LossFunction* loss_function,
-    const std::vector<ParameterBlock*>& parameter_blocks, int index)
+    const CostFunction* cost_function,
+    const LossFunction* loss_function,
+    const std::vector<ParameterBlock*>& parameter_blocks,
+    int index)
     : cost_function_(cost_function),
       loss_function_(loss_function),
       parameter_blocks_(
@@ -111,22 +114,18 @@
     return false;
   }
 
-  if (!IsEvaluationValid(*this,
-                         parameters.data(),
-                         cost,
-                         residuals,
-                         eval_jacobians)) {
+  if (!IsEvaluationValid(
+          *this, parameters.data(), cost, residuals, eval_jacobians)) {
+    // clang-format off
     std::string message =
         "\n\n"
         "Error in evaluating the ResidualBlock.\n\n"
         "There are two possible reasons. Either the CostFunction did not evaluate and fill all    \n"  // NOLINT
         "residual and jacobians that were requested or there was a non-finite value (nan/infinite)\n"  // NOLINT
         "generated during the or jacobian computation. \n\n" +
-        EvaluationToString(*this,
-                           parameters.data(),
-                           cost,
-                           residuals,
-                           eval_jacobians);
+        EvaluationToString(
+            *this, parameters.data(), cost, residuals, eval_jacobians);
+    // clang-format on
     LOG(WARNING) << message;
     return false;
   }
@@ -149,7 +148,11 @@
               parameter_block->LocalParameterizationJacobian(),
               parameter_block->Size(),
               parameter_block->LocalSize(),
-              jacobians[i], 0, 0,  num_residuals, parameter_block->LocalSize());
+              jacobians[i],
+              0,
+              0,
+              num_residuals,
+              parameter_block->LocalSize());
         }
       }
     }
diff --git a/internal/ceres/residual_block.h b/internal/ceres/residual_block.h
index a2e4425..3d75339 100644
--- a/internal/ceres/residual_block.h
+++ b/internal/ceres/residual_block.h
@@ -105,7 +105,6 @@
                 double** jacobians,
                 double* scratch) const;
 
-
   const CostFunction* cost_function() const { return cost_function_; }
   const LossFunction* loss_function() const { return loss_function_; }
 
diff --git a/internal/ceres/residual_block_test.cc b/internal/ceres/residual_block_test.cc
index 482e7ce..3c05f48 100644
--- a/internal/ceres/residual_block_test.cc
+++ b/internal/ceres/residual_block_test.cc
@@ -31,11 +31,12 @@
 #include "ceres/residual_block.h"
 
 #include <cstdint>
-#include "gtest/gtest.h"
-#include "ceres/parameter_block.h"
-#include "ceres/sized_cost_function.h"
+
 #include "ceres/internal/eigen.h"
 #include "ceres/local_parameterization.h"
+#include "ceres/parameter_block.h"
+#include "ceres/sized_cost_function.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -43,7 +44,7 @@
 using std::vector;
 
 // Trivial cost function that accepts three arguments.
-class TernaryCostFunction: public CostFunction {
+class TernaryCostFunction : public CostFunction {
  public:
   TernaryCostFunction(int num_residuals,
                       int32_t parameter_block1_size,
@@ -64,9 +65,8 @@
     if (jacobians) {
       for (int k = 0; k < 3; ++k) {
         if (jacobians[k] != NULL) {
-          MatrixRef jacobian(jacobians[k],
-                             num_residuals(),
-                             parameter_block_sizes()[k]);
+          MatrixRef jacobian(
+              jacobians[k], num_residuals(), parameter_block_sizes()[k]);
           jacobian.setConstant(k);
         }
       }
@@ -109,12 +109,12 @@
   // Verify cost-only evaluation.
   double cost;
   residual_block.Evaluate(true, &cost, NULL, NULL, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
 
   // Verify cost and residual evaluation.
   double residuals[3];
   residual_block.Evaluate(true, &cost, residuals, NULL, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
   EXPECT_EQ(0.0, residuals[0]);
   EXPECT_EQ(1.0, residuals[1]);
   EXPECT_EQ(2.0, residuals[2]);
@@ -131,14 +131,11 @@
   jacobian_ry.setConstant(-1.0);
   jacobian_rz.setConstant(-1.0);
 
-  double *jacobian_ptrs[3] = {
-    jacobian_rx.data(),
-    jacobian_ry.data(),
-    jacobian_rz.data()
-  };
+  double* jacobian_ptrs[3] = {
+      jacobian_rx.data(), jacobian_ry.data(), jacobian_rz.data()};
 
   residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
   EXPECT_EQ(0.0, residuals[0]);
   EXPECT_EQ(1.0, residuals[1]);
   EXPECT_EQ(2.0, residuals[2]);
@@ -157,18 +154,20 @@
   jacobian_ptrs[1] = NULL;  // Don't compute the jacobian for y.
 
   residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
   EXPECT_EQ(0.0, residuals[0]);
   EXPECT_EQ(1.0, residuals[1]);
   EXPECT_EQ(2.0, residuals[2]);
 
+  // clang-format off
   EXPECT_TRUE((jacobian_rx.array() ==  0.0).all()) << "\n" << jacobian_rx;
   EXPECT_TRUE((jacobian_ry.array() == -1.0).all()) << "\n" << jacobian_ry;
   EXPECT_TRUE((jacobian_rz.array() ==  2.0).all()) << "\n" << jacobian_rz;
+  // clang-format on
 }
 
 // Trivial cost function that accepts three arguments.
-class LocallyParameterizedCostFunction: public SizedCostFunction<3, 2, 3, 4> {
+class LocallyParameterizedCostFunction : public SizedCostFunction<3, 2, 3, 4> {
  public:
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -189,9 +188,8 @@
         //   0 1 2 3 4 ...
         //
         if (jacobians[k] != NULL) {
-          MatrixRef jacobian(jacobians[k],
-                             num_residuals(),
-                             parameter_block_sizes()[k]);
+          MatrixRef jacobian(
+              jacobians[k], num_residuals(), parameter_block_sizes()[k]);
           for (int j = 0; j < k + 2; ++j) {
             jacobian.col(j).setConstant(j);
           }
@@ -243,17 +241,17 @@
   EXPECT_EQ(parameters[0], residual_block.parameter_blocks()[0]);
   EXPECT_EQ(parameters[1], residual_block.parameter_blocks()[1]);
   EXPECT_EQ(parameters[2], residual_block.parameter_blocks()[2]);
-  EXPECT_EQ(3*(2 + 4) + 3, residual_block.NumScratchDoublesForEvaluate());
+  EXPECT_EQ(3 * (2 + 4) + 3, residual_block.NumScratchDoublesForEvaluate());
 
   // Verify cost-only evaluation.
   double cost;
   residual_block.Evaluate(true, &cost, NULL, NULL, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
 
   // Verify cost and residual evaluation.
   double residuals[3];
   residual_block.Evaluate(true, &cost, residuals, NULL, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
   EXPECT_EQ(0.0, residuals[0]);
   EXPECT_EQ(1.0, residuals[1]);
   EXPECT_EQ(2.0, residuals[2]);
@@ -270,18 +268,17 @@
   jacobian_ry.setConstant(-1.0);
   jacobian_rz.setConstant(-1.0);
 
-  double *jacobian_ptrs[3] = {
-    jacobian_rx.data(),
-    jacobian_ry.data(),
-    jacobian_rz.data()
-  };
+  double* jacobian_ptrs[3] = {
+      jacobian_rx.data(), jacobian_ry.data(), jacobian_rz.data()};
 
   residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
   EXPECT_EQ(0.0, residuals[0]);
   EXPECT_EQ(1.0, residuals[1]);
   EXPECT_EQ(2.0, residuals[2]);
 
+  // clang-format off
+
   Matrix expected_jacobian_rx(3, 1);
   expected_jacobian_rx << 1.0, 1.0, 1.0;
 
@@ -305,6 +302,8 @@
       << "\nExpected:\n " << expected_jacobian_rz
       << "\nActual:\n"   << jacobian_rz;
 
+  // clang-format on
+
   // Verify cost, residual, and partial jacobian evaluation.
   cost = 0.0;
   VectorRef(residuals, 3).setConstant(0.0);
@@ -315,7 +314,7 @@
   jacobian_ptrs[1] = NULL;  // Don't compute the jacobian for y.
 
   residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
-  EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+  EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
   EXPECT_EQ(0.0, residuals[0]);
   EXPECT_EQ(1.0, residuals[1]);
   EXPECT_EQ(2.0, residuals[2]);
diff --git a/internal/ceres/residual_block_utils.cc b/internal/ceres/residual_block_utils.cc
index 35e928b..d5b3fa1 100644
--- a/internal/ceres/residual_block_utils.cc
+++ b/internal/ceres/residual_block_utils.cc
@@ -33,6 +33,7 @@
 #include <cmath>
 #include <cstddef>
 #include <limits>
+
 #include "ceres/array_utils.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/port.h"
@@ -75,6 +76,7 @@
   const int num_residuals = block.NumResiduals();
   string result = "";
 
+  // clang-format off
   StringAppendF(&result,
                 "Residual Block size: %d parameter blocks x %d residuals\n\n",
                 num_parameter_blocks, num_residuals);
@@ -85,6 +87,7 @@
       "of the Jacobian/residual array was requested but was not written to by user code, it is \n"  // NOLINT
       "indicated by 'Uninitialized'. This is an error. Residuals or Jacobian values evaluating \n"  // NOLINT
       "to Inf or NaN is also an error.  \n\n"; // NOLINT
+  // clang-format on
 
   string space = "Residuals:     ";
   result += space;
@@ -102,8 +105,8 @@
       for (int k = 0; k < num_residuals; ++k) {
         AppendArrayToString(1,
                             (jacobians != NULL && jacobians[i] != NULL)
-                            ? jacobians[i] + k * parameter_block_size + j
-                            : NULL,
+                                ? jacobians[i] + k * parameter_block_size + j
+                                : NULL,
                             &result);
       }
       StringAppendF(&result, "\n");
diff --git a/internal/ceres/residual_block_utils.h b/internal/ceres/residual_block_utils.h
index 627337f..41ae81a 100644
--- a/internal/ceres/residual_block_utils.h
+++ b/internal/ceres/residual_block_utils.h
@@ -44,6 +44,7 @@
 #define CERES_INTERNAL_RESIDUAL_BLOCK_UTILS_H_
 
 #include <string>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
diff --git a/internal/ceres/residual_block_utils_test.cc b/internal/ceres/residual_block_utils_test.cc
index 6ad3729..331f5ab 100644
--- a/internal/ceres/residual_block_utils_test.cc
+++ b/internal/ceres/residual_block_utils_test.cc
@@ -28,15 +28,17 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/residual_block_utils.h"
+
 #include <cmath>
 #include <limits>
 #include <memory>
-#include "gtest/gtest.h"
+
+#include "ceres/cost_function.h"
 #include "ceres/parameter_block.h"
 #include "ceres/residual_block.h"
-#include "ceres/residual_block_utils.h"
-#include "ceres/cost_function.h"
 #include "ceres/sized_cost_function.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -49,10 +51,7 @@
   std::vector<ParameterBlock*> parameter_blocks;
   parameter_blocks.push_back(&parameter_block);
 
-  ResidualBlock residual_block(&cost_function,
-                               NULL,
-                               parameter_blocks,
-                               -1);
+  ResidualBlock residual_block(&cost_function, NULL, parameter_blocks, -1);
 
   std::unique_ptr<double[]> scratch(
       new double[residual_block.NumScratchDoublesForEvaluate()]);
@@ -60,18 +59,16 @@
   double cost;
   double residuals;
   double jacobian;
-  double* jacobians[] = { &jacobian };
+  double* jacobians[] = {&jacobian};
 
-  EXPECT_EQ(residual_block.Evaluate(true,
-                                    &cost,
-                                    &residuals,
-                                    jacobians,
-                                    scratch.get()), is_good);
+  EXPECT_EQ(residual_block.Evaluate(
+                true, &cost, &residuals, jacobians, scratch.get()),
+            is_good);
 }
 
 // A CostFunction that behaves normaly, i.e., it computes numerically
 // valid residuals and jacobians.
-class GoodCostFunction: public SizedCostFunction<1, 1> {
+class GoodCostFunction : public SizedCostFunction<1, 1> {
  public:
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -86,7 +83,7 @@
 
 // The following four CostFunctions simulate the different ways in
 // which user code can cause ResidualBlock::Evaluate to fail.
-class NoResidualUpdateCostFunction: public SizedCostFunction<1, 1> {
+class NoResidualUpdateCostFunction : public SizedCostFunction<1, 1> {
  public:
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -100,7 +97,7 @@
   }
 };
 
-class NoJacobianUpdateCostFunction: public SizedCostFunction<1, 1> {
+class NoJacobianUpdateCostFunction : public SizedCostFunction<1, 1> {
  public:
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -114,7 +111,7 @@
   }
 };
 
-class BadResidualCostFunction: public SizedCostFunction<1, 1> {
+class BadResidualCostFunction : public SizedCostFunction<1, 1> {
  public:
   bool Evaluate(double const* const* parameters,
                 double* residuals,
@@ -127,7 +124,7 @@
   }
 };
 
-class BadJacobianCostFunction: public SizedCostFunction<1, 1> {
+class BadJacobianCostFunction : public SizedCostFunction<1, 1> {
  public:
   bool Evaluate(double const* const* parameters,
                 double* residuals,
diff --git a/internal/ceres/rotation_test.cc b/internal/ceres/rotation_test.cc
index 6a06632..fc39b31 100644
--- a/internal/ceres/rotation_test.cc
+++ b/internal/ceres/rotation_test.cc
@@ -28,14 +28,16 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/rotation.h"
+
 #include <cmath>
 #include <limits>
 #include <string>
+
 #include "ceres/internal/eigen.h"
-#include "ceres/is_close.h"
 #include "ceres/internal/port.h"
+#include "ceres/is_close.h"
 #include "ceres/jet.h"
-#include "ceres/rotation.h"
 #include "ceres/stringprintf.h"
 #include "ceres/test_util.h"
 #include "glog/logging.h"
@@ -45,8 +47,8 @@
 namespace ceres {
 namespace internal {
 
-using std::min;
 using std::max;
+using std::min;
 using std::numeric_limits;
 using std::string;
 using std::swap;
@@ -74,8 +76,8 @@
     return false;
   }
 
-  double norm2 = arg[0] * arg[0] + arg[1] * arg[1] +
-      arg[2] * arg[2] + arg[3] * arg[3];
+  double norm2 =
+      arg[0] * arg[0] + arg[1] * arg[1] + arg[2] * arg[2] + arg[3] * arg[3];
   if (fabs(norm2 - 1.0) > kTolerance) {
     *result_listener << "squared norm is " << norm2;
     return false;
@@ -120,6 +122,7 @@
     return true;
   }
 
+  // clang-format off
   *result_listener << "expected : "
                    << expected[0] << " "
                    << expected[1] << " "
@@ -130,6 +133,7 @@
                    << arg[1] << " "
                    << arg[2] << " "
                    << arg[3];
+  // clang-format on
   return false;
 }
 
@@ -164,6 +168,7 @@
     return true;
   }
 
+  // clang-format off
   *result_listener << " arg:"
                    << " " << arg[0]
                    << " " << arg[1]
@@ -172,6 +177,7 @@
                    << " " << expected[0]
                    << " " << expected[1]
                    << " " << expected[2];
+  // clang-format on
   return false;
 }
 
@@ -225,9 +231,9 @@
 
 // Transforms a zero axis/angle to a quaternion.
 TEST(Rotation, ZeroAngleAxisToQuaternion) {
-  double axis_angle[3] = { 0, 0, 0 };
+  double axis_angle[3] = {0, 0, 0};
   double quaternion[4];
-  double expected[4] = { 1, 0, 0, 0 };
+  double expected[4] = {1, 0, 0, 0};
   AngleAxisToQuaternion(axis_angle, quaternion);
   EXPECT_THAT(quaternion, IsNormalizedQuaternion());
   EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -237,9 +243,9 @@
 TEST(Rotation, SmallAngleAxisToQuaternion) {
   // Small, finite value to test.
   double theta = 1.0e-2;
-  double axis_angle[3] = { theta, 0, 0 };
+  double axis_angle[3] = {theta, 0, 0};
   double quaternion[4];
-  double expected[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+  double expected[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
   AngleAxisToQuaternion(axis_angle, quaternion);
   EXPECT_THAT(quaternion, IsNormalizedQuaternion());
   EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -249,9 +255,9 @@
 TEST(Rotation, TinyAngleAxisToQuaternion) {
   // Very small value that could potentially cause underflow.
   double theta = pow(numeric_limits<double>::min(), 0.75);
-  double axis_angle[3] = { theta, 0, 0 };
+  double axis_angle[3] = {theta, 0, 0};
   double quaternion[4];
-  double expected[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+  double expected[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
   AngleAxisToQuaternion(axis_angle, quaternion);
   EXPECT_THAT(quaternion, IsNormalizedQuaternion());
   EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -259,9 +265,9 @@
 
 // Transforms a rotation by pi/2 around X to a quaternion.
 TEST(Rotation, XRotationToQuaternion) {
-  double axis_angle[3] = { kPi / 2, 0, 0 };
+  double axis_angle[3] = {kPi / 2, 0, 0};
   double quaternion[4];
-  double expected[4] = { kHalfSqrt2, kHalfSqrt2, 0, 0 };
+  double expected[4] = {kHalfSqrt2, kHalfSqrt2, 0, 0};
   AngleAxisToQuaternion(axis_angle, quaternion);
   EXPECT_THAT(quaternion, IsNormalizedQuaternion());
   EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -269,18 +275,18 @@
 
 // Transforms a unit quaternion to an axis angle.
 TEST(Rotation, UnitQuaternionToAngleAxis) {
-  double quaternion[4] = { 1, 0, 0, 0 };
+  double quaternion[4] = {1, 0, 0, 0};
   double axis_angle[3];
-  double expected[3] = { 0, 0, 0 };
+  double expected[3] = {0, 0, 0};
   QuaternionToAngleAxis(quaternion, axis_angle);
   EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
 }
 
 // Transforms a quaternion that rotates by pi about the Y axis to an axis angle.
 TEST(Rotation, YRotationQuaternionToAngleAxis) {
-  double quaternion[4] = { 0, 0, 1, 0 };
+  double quaternion[4] = {0, 0, 1, 0};
   double axis_angle[3];
-  double expected[3] = { 0, kPi, 0 };
+  double expected[3] = {0, kPi, 0};
   QuaternionToAngleAxis(quaternion, axis_angle);
   EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
 }
@@ -288,9 +294,9 @@
 // Transforms a quaternion that rotates by pi/3 about the Z axis to an axis
 // angle.
 TEST(Rotation, ZRotationQuaternionToAngleAxis) {
-  double quaternion[4] = { sqrt(3) / 2, 0, 0, 0.5 };
+  double quaternion[4] = {sqrt(3) / 2, 0, 0, 0.5};
   double axis_angle[3];
-  double expected[3] = { 0, 0, kPi / 3 };
+  double expected[3] = {0, 0, kPi / 3};
   QuaternionToAngleAxis(quaternion, axis_angle);
   EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
 }
@@ -299,9 +305,9 @@
 TEST(Rotation, SmallQuaternionToAngleAxis) {
   // Small, finite value to test.
   double theta = 1.0e-2;
-  double quaternion[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+  double quaternion[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
   double axis_angle[3];
-  double expected[3] = { theta, 0, 0 };
+  double expected[3] = {theta, 0, 0};
   QuaternionToAngleAxis(quaternion, axis_angle);
   EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
 }
@@ -310,9 +316,9 @@
 TEST(Rotation, TinyQuaternionToAngleAxis) {
   // Very small value that could potentially cause underflow.
   double theta = pow(numeric_limits<double>::min(), 0.75);
-  double quaternion[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+  double quaternion[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
   double axis_angle[3];
-  double expected[3] = { theta, 0, 0 };
+  double expected[3] = {theta, 0, 0};
   QuaternionToAngleAxis(quaternion, axis_angle);
   EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
 }
@@ -328,9 +334,9 @@
   quaternion[2] = 0.0;
   quaternion[3] = 0.0;
   QuaternionToAngleAxis(quaternion, angle_axis);
-  const double angle = sqrt(angle_axis[0] * angle_axis[0] +
-                            angle_axis[1] * angle_axis[1] +
-                            angle_axis[2] * angle_axis[2]);
+  const double angle =
+      sqrt(angle_axis[0] * angle_axis[0] + angle_axis[1] * angle_axis[1] +
+           angle_axis[2] * angle_axis[2]);
   EXPECT_LE(angle, kPi);
 }
 
@@ -398,18 +404,18 @@
 
 // Transforms a zero axis/angle to a rotation matrix.
 TEST(Rotation, ZeroAngleAxisToRotationMatrix) {
-  double axis_angle[3] = { 0, 0, 0 };
+  double axis_angle[3] = {0, 0, 0};
   double matrix[9];
-  double expected[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+  double expected[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
   AngleAxisToRotationMatrix(axis_angle, matrix);
   EXPECT_THAT(matrix, IsOrthonormal());
   EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
 }
 
 TEST(Rotation, NearZeroAngleAxisToRotationMatrix) {
-  double axis_angle[3] = { 1e-24, 2e-24, 3e-24 };
+  double axis_angle[3] = {1e-24, 2e-24, 3e-24};
   double matrix[9];
-  double expected[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+  double expected[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
   AngleAxisToRotationMatrix(axis_angle, matrix);
   EXPECT_THAT(matrix, IsOrthonormal());
   EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -417,10 +423,10 @@
 
 // Transforms a rotation by pi/2 around X to a rotation matrix and back.
 TEST(Rotation, XRotationToRotationMatrix) {
-  double axis_angle[3] = { kPi / 2, 0, 0 };
+  double axis_angle[3] = {kPi / 2, 0, 0};
   double matrix[9];
   // The rotation matrices are stored column-major.
-  double expected[9] = { 1, 0, 0, 0, 0, 1, 0, -1, 0 };
+  double expected[9] = {1, 0, 0, 0, 0, 1, 0, -1, 0};
   AngleAxisToRotationMatrix(axis_angle, matrix);
   EXPECT_THAT(matrix, IsOrthonormal());
   EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -432,9 +438,9 @@
 // Transforms an axis angle that rotates by pi about the Y axis to a
 // rotation matrix and back.
 TEST(Rotation, YRotationToRotationMatrix) {
-  double axis_angle[3] = { 0, kPi, 0 };
+  double axis_angle[3] = {0, kPi, 0};
   double matrix[9];
-  double expected[9] = { -1, 0, 0, 0, 1, 0, 0, 0, -1 };
+  double expected[9] = {-1, 0, 0, 0, 1, 0, 0, 0, -1};
   AngleAxisToRotationMatrix(axis_angle, matrix);
   EXPECT_THAT(matrix, IsOrthonormal());
   EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -475,29 +481,31 @@
 
 TEST(Rotation, AtPiAngleAxisRoundTrip) {
   // A rotation of kPi about the X axis;
+  // clang-format off
   static constexpr double kMatrix[3][3] = {
     {1.0,  0.0,  0.0},
     {0.0,  -1.0,  0.0},
     {0.0,  0.0,  -1.0}
   };
+  // clang-format on
 
   double in_matrix[9];
   // Fill it from kMatrix in col-major order.
   for (int j = 0, k = 0; j < 3; ++j) {
-     for (int i = 0; i < 3; ++i, ++k) {
-       in_matrix[k] = kMatrix[i][j];
-     }
+    for (int i = 0; i < 3; ++i, ++k) {
+      in_matrix[k] = kMatrix[i][j];
+    }
   }
 
-  const double expected_axis_angle[3] = { kPi, 0, 0 };
+  const double expected_axis_angle[3] = {kPi, 0, 0};
 
   double out_matrix[9];
   double axis_angle[3];
   RotationMatrixToAngleAxis(in_matrix, axis_angle);
   AngleAxisToRotationMatrix(axis_angle, out_matrix);
 
-  LOG(INFO) << "AngleAxis = " << axis_angle[0] << " " << axis_angle[1]
-            << " " << axis_angle[2];
+  LOG(INFO) << "AngleAxis = " << axis_angle[0] << " " << axis_angle[1] << " "
+            << axis_angle[2];
   LOG(INFO) << "Expected AngleAxis = " << kPi << " 0 0";
   double out_rowmajor[3][3];
   for (int j = 0, k = 0; j < 3; ++j) {
@@ -526,13 +534,15 @@
 // Transforms an axis angle that rotates by pi/3 about the Z axis to a
 // rotation matrix.
 TEST(Rotation, ZRotationToRotationMatrix) {
-  double axis_angle[3] =  { 0, 0, kPi / 3 };
+  double axis_angle[3] = {0, 0, kPi / 3};
   double matrix[9];
   // This is laid-out row-major on the screen but is actually stored
   // column-major.
+  // clang-format off
   double expected[9] = { 0.5, sqrt(3) / 2, 0,   // Column 1
                          -sqrt(3) / 2, 0.5, 0,  // Column 2
                          0, 0, 1 };             // Column 3
+  // clang-format on
   AngleAxisToRotationMatrix(axis_angle, matrix);
   EXPECT_THAT(matrix, IsOrthonormal());
   EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -602,13 +612,12 @@
     RotationMatrixToAngleAxis(matrix, round_trip);
 
     for (int i = 0; i < 3; ++i) {
-      EXPECT_NEAR(round_trip[i], axis_angle[i],
-                  numeric_limits<double>::epsilon());
+      EXPECT_NEAR(
+          round_trip[i], axis_angle[i], numeric_limits<double>::epsilon());
     }
   }
 }
 
-
 // Transposes a 3x3 matrix.
 static void Transpose3x3(double m[9]) {
   swap(m[1], m[3]);
@@ -647,8 +656,7 @@
   for (double x = -1.0; x <= 1.0; x += 1.0) {
     for (double y = -1.0; y <= 1.0; y += 1.0) {
       for (double z = -1.0; z <= 1.0; z += 1.0) {
-        if ((x != 0) + (y != 0) + (z != 0) > 1)
-          continue;
+        if ((x != 0) + (y != 0) + (z != 0) > 1) continue;
         double axis_angle[3] = {x, y, z};
         double euler_angles[3] = {x, y, z};
         CompareEulerToAngleAxis(axis_angle, euler_angles);
@@ -710,7 +718,7 @@
 }  // namespace
 
 template <int N>
-bool IsClose(const Jet<double, N> &x, const Jet<double, N> &y) {
+bool IsClose(const Jet<double, N>& x, const Jet<double, N>& y) {
   if (!IsClose(x.a, y.a)) {
     return false;
   }
@@ -723,7 +731,7 @@
 }
 
 template <int M, int N>
-void ExpectJetArraysClose(const Jet<double, N> *x, const Jet<double, N> *y) {
+void ExpectJetArraysClose(const Jet<double, N>* x, const Jet<double, N>* y) {
   for (int i = 0; i < M; i++) {
     if (!IsClose(x[i], y[i])) {
       LOG(ERROR) << "Jet " << i << "/" << M << " not equal";
@@ -742,11 +750,11 @@
 
 // Log-10 of a value well below machine precision.
 static const int kSmallTinyCutoff =
-    static_cast<int>(2 * log(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(numeric_limits<double>::min())/log(10.0));
+static const int kTinyZeroLimit =
+    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) {
@@ -754,27 +762,26 @@
   // to be well within the range represented by doubles.
   for (int i = -2; i >= kSmallTinyCutoff; i--) {
     double theta = pow(10.0, i);
-    J3 axis_angle[3] = { J3(theta, 0), J3(0, 1), J3(0, 2) };
+    J3 axis_angle[3] = {J3(theta, 0), J3(0, 1), J3(0, 2)};
     J3 quaternion[4];
     J3 expected[4] = {
-        MakeJ3(cos(theta/2), -sin(theta/2)/2, 0, 0),
-        MakeJ3(sin(theta/2), cos(theta/2)/2, 0, 0),
-        MakeJ3(0, 0, sin(theta/2)/theta, 0),
-        MakeJ3(0, 0, 0, sin(theta/2)/theta),
+        MakeJ3(cos(theta / 2), -sin(theta / 2) / 2, 0, 0),
+        MakeJ3(sin(theta / 2), cos(theta / 2) / 2, 0, 0),
+        MakeJ3(0, 0, sin(theta / 2) / theta, 0),
+        MakeJ3(0, 0, 0, sin(theta / 2) / theta),
     };
     AngleAxisToQuaternion(axis_angle, quaternion);
     ExpectJetArraysClose<4, 3>(quaternion, expected);
   }
 }
 
-
 // Test that conversion works for very small angles when jets are used.
 TEST(Rotation, TinyAngleAxisToQuaternionForJets) {
   // Examine tiny x rotations that extend all the way to where
   // underflow occurs.
   for (int i = kSmallTinyCutoff; i >= kTinyZeroLimit; i--) {
     double theta = pow(10.0, i);
-    J3 axis_angle[3] = { J3(theta, 0), J3(0, 1), J3(0, 2) };
+    J3 axis_angle[3] = {J3(theta, 0), J3(0, 1), J3(0, 2)};
     J3 quaternion[4];
     // To avoid loss of precision in the test itself,
     // a finite expansion is used here, which will
@@ -792,7 +799,7 @@
 
 // Test that derivatives are correct for zero rotation.
 TEST(Rotation, ZeroAngleAxisToQuaternionForJets) {
-  J3 axis_angle[3] = { J3(0, 0), J3(0, 1), J3(0, 2) };
+  J3 axis_angle[3] = {J3(0, 0), J3(0, 1), J3(0, 2)};
   J3 quaternion[4];
   J3 expected[4] = {
       MakeJ3(1.0, 0, 0, 0),
@@ -812,13 +819,15 @@
     double theta = pow(10.0, i);
     double s = sin(theta);
     double c = cos(theta);
-    J4 quaternion[4] = { J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3) };
+    J4 quaternion[4] = {J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3)};
     J4 axis_angle[3];
+    // clang-format off
     J4 expected[3] = {
         MakeJ4(2*theta, -2*s, 2*c,  0,         0),
         MakeJ4(0,        0,   0,    2*theta/s, 0),
         MakeJ4(0,        0,   0,    0,         2*theta/s),
     };
+    // clang-format on
     QuaternionToAngleAxis(quaternion, axis_angle);
     ExpectJetArraysClose<3, 4>(axis_angle, expected);
   }
@@ -832,16 +841,18 @@
     double theta = pow(10.0, i);
     double s = sin(theta);
     double c = cos(theta);
-    J4 quaternion[4] = { J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3) };
+    J4 quaternion[4] = {J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3)};
     J4 axis_angle[3];
     // To avoid loss of precision in the test itself,
     // a finite expansion is used here, which will
     // be exact up to machine precision for the test values used.
+    // clang-format off
     J4 expected[3] = {
         MakeJ4(2*theta, -2*s, 2.0, 0,   0),
         MakeJ4(0,        0,   0,   2.0, 0),
         MakeJ4(0,        0,   0,   0,   2.0),
     };
+    // clang-format on
     QuaternionToAngleAxis(quaternion, axis_angle);
     ExpectJetArraysClose<3, 4>(axis_angle, expected);
   }
@@ -849,7 +860,7 @@
 
 // Test that conversion works for no rotation.
 TEST(Rotation, ZeroQuaternionToAngleAxisForJets) {
-  J4 quaternion[4] = { J4(1, 0), J4(0, 1), J4(0, 2), J4(0, 3) };
+  J4 quaternion[4] = {J4(1, 0), J4(0, 1), J4(0, 2), J4(0, 3)};
   J4 axis_angle[3];
   J4 expected[3] = {
       MakeJ4(0, 0, 2.0, 0, 0),
@@ -863,20 +874,22 @@
 TEST(Quaternion, RotatePointGivesSameAnswerAsRotationByMatrixCanned) {
   // Canned data generated in octave.
   double const q[4] = {
-    +0.1956830471754074,
-    -0.0150618562474847,
-    +0.7634572982788086,
-    -0.3019454777240753,
+      +0.1956830471754074,
+      -0.0150618562474847,
+      +0.7634572982788086,
+      -0.3019454777240753,
   };
-  double const Q[3][3] = {  // Scaled rotation matrix.
-    { -0.6355194033477252,  0.0951730541682254,  0.3078870197911186 },
-    { -0.1411693904792992,  0.5297609702153905, -0.4551502574482019 },
-    { -0.2896955822708862, -0.4669396571547050, -0.4536309793389248 },
+  double const Q[3][3] = {
+      // Scaled rotation matrix.
+      {-0.6355194033477252, +0.0951730541682254, +0.3078870197911186},
+      {-0.1411693904792992, +0.5297609702153905, -0.4551502574482019},
+      {-0.2896955822708862, -0.4669396571547050, -0.4536309793389248},
   };
-  double const R[3][3] = {  // With unit rows and columns.
-    { -0.8918859164053080,  0.1335655625725649,  0.4320876677394745 },
-    { -0.1981166751680096,  0.7434648665444399, -0.6387564287225856 },
-    { -0.4065578619806013, -0.6553016349046693, -0.6366242786393164 },
+  double const R[3][3] = {
+      // With unit rows and columns.
+      {-0.8918859164053080, +0.1335655625725649, +0.4320876677394745},
+      {-0.1981166751680096, +0.7434648665444399, -0.6387564287225856},
+      {-0.4065578619806013, -0.6553016349046693, -0.6366242786393164},
   };
 
   // Compute R from q and compare to known answer.
@@ -889,19 +902,18 @@
   ExpectArraysClose(9, R[0], Rq[0], kTolerance);
 }
 
-
 TEST(Quaternion, RotatePointGivesSameAnswerAsRotationByMatrix) {
   // Rotation defined by a unit quaternion.
   double const q[4] = {
-    0.2318160216097109,
-    -0.0178430356832060,
-    0.9044300776717159,
-    -0.3576998641394597,
+      +0.2318160216097109,
+      -0.0178430356832060,
+      +0.9044300776717159,
+      -0.3576998641394597,
   };
   double const p[3] = {
-    +0.11,
-    -13.15,
-    1.17,
+      +0.11,
+      -13.15,
+      1.17,
   };
 
   double R[3 * 3];
@@ -911,11 +923,10 @@
   UnitQuaternionRotatePoint(q, p, result1);
 
   double result2[3];
-  VectorRef(result2, 3) = ConstMatrixRef(R, 3, 3)* ConstVectorRef(p, 3);
+  VectorRef(result2, 3) = ConstMatrixRef(R, 3, 3) * ConstVectorRef(p, 3);
   ExpectArraysClose(3, result1, result2, kTolerance);
 }
 
-
 // Verify that (a * b) * c == a * (b * c).
 TEST(Quaternion, MultiplicationIsAssociative) {
   double a[4];
@@ -943,7 +954,6 @@
   ASSERT_NEAR(ab_c[3], a_bc[3], kTolerance);
 }
 
-
 TEST(AngleAxis, RotatePointGivesSameAnswerAsRotationMatrix) {
   double angle_axis[3];
   double R[9];
@@ -973,6 +983,7 @@
 
       AngleAxisRotatePoint(angle_axis, p, angle_axis_rotated_p);
       for (int k = 0; k < 3; ++k) {
+        // clang-format off
         EXPECT_NEAR(rotation_matrix_rotated_p[k],
                     angle_axis_rotated_p[k],
                     kTolerance) << "p: " << p[0]
@@ -981,6 +992,7 @@
                                 << " angle_axis: " << angle_axis[0]
                                 << " " << angle_axis[1]
                                 << " " << angle_axis[2];
+        // clang-format on
       }
     }
   }
@@ -1001,7 +1013,7 @@
       norm2 = angle_axis[k] * angle_axis[k];
     }
 
-    double theta = (2.0 * i * 0.0001  - 1.0) * 1e-16;
+    double theta = (2.0 * i * 0.0001 - 1.0) * 1e-16;
     const double inv_norm = theta / sqrt(norm2);
     for (int k = 0; k < 3; ++k) {
       angle_axis[k] *= inv_norm;
@@ -1014,6 +1026,7 @@
 
     AngleAxisRotatePoint(angle_axis, p, angle_axis_rotated_p);
     for (int k = 0; k < 3; ++k) {
+      // clang-format off
       EXPECT_NEAR(rotation_matrix_rotated_p[k],
                   angle_axis_rotated_p[k],
                   kTolerance) << "p: " << p[0]
@@ -1022,14 +1035,15 @@
                               << " angle_axis: " << angle_axis[0]
                               << " " << angle_axis[1]
                               << " " << angle_axis[2];
+      // clang-format on
     }
   }
 }
 
 TEST(MatrixAdapter, RowMajor3x3ReturnTypeAndAccessIsCorrect) {
-  double array[9] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
-  const float const_array[9] =
-      { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f };
+  double array[9] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
+  const float const_array[9] = {
+      1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
   MatrixAdapter<double, 3, 1> A = RowMajorAdapter3x3(array);
   MatrixAdapter<const float, 3, 1> B = RowMajorAdapter3x3(const_array);
 
@@ -1037,16 +1051,16 @@
     for (int j = 0; j < 3; ++j) {
       // The values are integers from 1 to 9, so equality tests are appropriate
       // even for float and double values.
-      EXPECT_EQ(A(i, j), array[3*i+j]);
-      EXPECT_EQ(B(i, j), const_array[3*i+j]);
+      EXPECT_EQ(A(i, j), array[3 * i + j]);
+      EXPECT_EQ(B(i, j), const_array[3 * i + j]);
     }
   }
 }
 
 TEST(MatrixAdapter, ColumnMajor3x3ReturnTypeAndAccessIsCorrect) {
-  double array[9] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
-  const float const_array[9] =
-      { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f };
+  double array[9] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
+  const float const_array[9] = {
+      1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
   MatrixAdapter<double, 1, 3> A = ColumnMajorAdapter3x3(array);
   MatrixAdapter<const float, 1, 3> B = ColumnMajorAdapter3x3(const_array);
 
@@ -1054,29 +1068,33 @@
     for (int j = 0; j < 3; ++j) {
       // The values are integers from 1 to 9, so equality tests are
       // appropriate even for float and double values.
-      EXPECT_EQ(A(i, j), array[3*j+i]);
-      EXPECT_EQ(B(i, j), const_array[3*j+i]);
+      EXPECT_EQ(A(i, j), array[3 * j + i]);
+      EXPECT_EQ(B(i, j), const_array[3 * j + i]);
     }
   }
 }
 
 TEST(MatrixAdapter, RowMajor2x4IsCorrect) {
-  const int expected[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+  const int expected[8] = {1, 2, 3, 4, 5, 6, 7, 8};
   int array[8];
   MatrixAdapter<int, 4, 1> M(array);
+  // clang-format off
   M(0, 0) = 1; M(0, 1) = 2; M(0, 2) = 3; M(0, 3) = 4;
   M(1, 0) = 5; M(1, 1) = 6; M(1, 2) = 7; M(1, 3) = 8;
+  // clang-format on
   for (int k = 0; k < 8; ++k) {
     EXPECT_EQ(array[k], expected[k]);
   }
 }
 
 TEST(MatrixAdapter, ColumnMajor2x4IsCorrect) {
-  const int expected[8] = { 1, 5, 2, 6, 3, 7, 4, 8 };
+  const int expected[8] = {1, 5, 2, 6, 3, 7, 4, 8};
   int array[8];
   MatrixAdapter<int, 1, 2> M(array);
+  // clang-format off
   M(0, 0) = 1; M(0, 1) = 2; M(0, 2) = 3; M(0, 3) = 4;
   M(1, 0) = 5; M(1, 1) = 6; M(1, 2) = 7; M(1, 3) = 8;
+  // clang-format on
   for (int k = 0; k < 8; ++k) {
     EXPECT_EQ(array[k], expected[k]);
   }
@@ -1084,11 +1102,13 @@
 
 TEST(RotationMatrixToAngleAxis, NearPiExampleOneFromTobiasStrauss) {
   // Example from Tobias Strauss
+  // clang-format off
   const double rotation_matrix[] = {
     -0.999807135425239,    -0.0128154391194470,   -0.0148814136745799,
     -0.0128154391194470,   -0.148441438622958,     0.988838158557669,
     -0.0148814136745799,    0.988838158557669,     0.148248574048196
   };
+  // clang-format on
 
   double angle_axis[3];
   RotationMatrixToAngleAxis(RowMajorAdapter3x3(rotation_matrix), angle_axis);
diff --git a/internal/ceres/schur_complement_solver.cc b/internal/ceres/schur_complement_solver.cc
index 0083300..65e7854 100644
--- a/internal/ceres/schur_complement_solver.cc
+++ b/internal/ceres/schur_complement_solver.cc
@@ -139,10 +139,8 @@
     //
     // TODO(sameeragarwal): A more scalable template specialization
     // mechanism that does not cause binary bloat.
-    if (options_.row_block_size == 2 &&
-        options_.e_block_size == 3 &&
-        options_.f_block_size == 6 &&
-        num_f_blocks == 1) {
+    if (options_.row_block_size == 2 && options_.e_block_size == 3 &&
+        options_.f_block_size == 6 && num_f_blocks == 1) {
       eliminator_.reset(new SchurEliminatorForOneFBlock<2, 3, 6>);
     } else {
       eliminator_.reset(SchurEliminatorBase::Create(options_));
diff --git a/internal/ceres/schur_complement_solver.h b/internal/ceres/schur_complement_solver.h
index 87f0478..464af09 100644
--- a/internal/ceres/schur_complement_solver.h
+++ b/internal/ceres/schur_complement_solver.h
@@ -46,8 +46,8 @@
 #include "ceres/types.h"
 
 #ifdef CERES_USE_EIGEN_SPARSE
-#include "Eigen/SparseCholesky"
 #include "Eigen/OrderingMethods"
+#include "Eigen/SparseCholesky"
 #endif
 
 namespace ceres {
@@ -179,8 +179,7 @@
       const LinearSolver::PerSolveOptions& per_solve_options,
       double* solution) final;
   LinearSolver::Summary SolveReducedLinearSystemUsingConjugateGradients(
-      const LinearSolver::PerSolveOptions& per_solve_options,
-      double* solution);
+      const LinearSolver::PerSolveOptions& per_solve_options, double* solution);
 
   // Size of the blocks in the Schur complement.
   std::vector<int> blocks_;
diff --git a/internal/ceres/schur_complement_solver_test.cc b/internal/ceres/schur_complement_solver_test.cc
index 23d3674..550733e 100644
--- a/internal/ceres/schur_complement_solver_test.cc
+++ b/internal/ceres/schur_complement_solver_test.cc
@@ -74,9 +74,8 @@
 
     std::unique_ptr<LinearSolver> qr(LinearSolver::Create(options));
 
-    TripletSparseMatrix triplet_A(A->num_rows(),
-                                  A->num_cols(),
-                                  A->num_nonzeros());
+    TripletSparseMatrix triplet_A(
+        A->num_rows(), A->num_cols(), A->num_nonzeros());
     A->ToTripletSparseMatrix(&triplet_A);
 
     // Gold standard solutions using dense QR factorization.
@@ -99,8 +98,8 @@
     SetUpFromProblemId(problem_id);
     LinearSolver::Options options;
     options.elimination_groups.push_back(num_eliminate_blocks);
-    options.elimination_groups.push_back(
-        A->block_structure()->cols.size() - num_eliminate_blocks);
+    options.elimination_groups.push_back(A->block_structure()->cols.size() -
+                                         num_eliminate_blocks);
     options.type = linear_solver_type;
     options.dense_linear_algebra_library_type =
         dense_linear_algebra_library_type;
@@ -127,7 +126,6 @@
     EXPECT_EQ(summary.termination_type, LINEAR_SOLVER_SUCCESS);
 
     if (regularization) {
-
       ASSERT_NEAR((sol_d - x).norm() / num_cols, 0, 1e-10)
           << "Regularized Expected solution: " << sol_d.transpose()
           << " Actual solution: " << x.transpose();
@@ -207,42 +205,40 @@
 #endif  // CERES_NO_SUITESPARSE
 
 #ifndef CERES_NO_CXSPARSE
-TEST_F(SchurComplementSolverTest,
-       SparseSchurWithCXSparseSmallProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithCXSparseSmallProblem) {
   ComputeAndCompareSolutions(2, false, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
   ComputeAndCompareSolutions(2, true, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
 }
 
-TEST_F(SchurComplementSolverTest,
-       SparseSchurWithCXSparseLargeProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithCXSparseLargeProblem) {
   ComputeAndCompareSolutions(3, false, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
   ComputeAndCompareSolutions(3, true, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
 }
 #endif  // CERES_NO_CXSPARSE
 
 #ifndef CERES_NO_ACCELERATE_SPARSE
-TEST_F(SchurComplementSolverTest,
-       SparseSchurWithAccelerateSparseSmallProblem) {
-  ComputeAndCompareSolutions(2, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
-  ComputeAndCompareSolutions(2, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+TEST_F(SchurComplementSolverTest, SparseSchurWithAccelerateSparseSmallProblem) {
+  ComputeAndCompareSolutions(
+      2, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+  ComputeAndCompareSolutions(
+      2, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
 }
 
-TEST_F(SchurComplementSolverTest,
-       SparseSchurWithAccelerateSparseLargeProblem) {
-  ComputeAndCompareSolutions(3, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
-  ComputeAndCompareSolutions(3, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+TEST_F(SchurComplementSolverTest, SparseSchurWithAccelerateSparseLargeProblem) {
+  ComputeAndCompareSolutions(
+      3, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+  ComputeAndCompareSolutions(
+      3, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
 }
 #endif  // CERES_NO_ACCELERATE_SPARSE
 
 #ifdef CERES_USE_EIGEN_SPARSE
-TEST_F(SchurComplementSolverTest,
-       SparseSchurWithEigenSparseSmallProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithEigenSparseSmallProblem) {
   ComputeAndCompareSolutions(2, false, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
   ComputeAndCompareSolutions(2, true, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
 }
 
-TEST_F(SchurComplementSolverTest,
-       SparseSchurWithEigenSparseLargeProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithEigenSparseLargeProblem) {
   ComputeAndCompareSolutions(3, false, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
   ComputeAndCompareSolutions(3, true, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
 }
diff --git a/internal/ceres/schur_eliminator_impl.h b/internal/ceres/schur_eliminator_impl.h
index bd0881e..1f0b4fa 100644
--- a/internal/ceres/schur_eliminator_impl.h
+++ b/internal/ceres/schur_eliminator_impl.h
@@ -46,7 +46,9 @@
 #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 10
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
 
 #include <algorithm>
 #include <map>
@@ -152,7 +154,7 @@
       ++chunk.size;
     }
 
-    CHECK_GT(chunk.size, 0); // This check will need to be resolved.
+    CHECK_GT(chunk.size, 0);  // This check will need to be resolved.
     r += chunk.size;
   }
   const Chunk& chunk = chunks_.back();
@@ -174,13 +176,12 @@
 }
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-Eliminate(const BlockSparseMatrixData& A,
-          const double* b,
-          const double* D,
-          BlockRandomAccessMatrix* lhs,
-          double* rhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::Eliminate(
+    const BlockSparseMatrixData& A,
+    const double* b,
+    const double* D,
+    BlockRandomAccessMatrix* lhs,
+    double* rhs) {
   if (lhs->num_rows() > 0) {
     lhs->SetZero();
     if (rhs) {
@@ -193,27 +194,26 @@
 
   // Add the diagonal to the schur complement.
   if (D != NULL) {
-    ParallelFor(
-        context_,
-        num_eliminate_blocks_,
-        num_col_blocks,
-        num_threads_,
-        [&](int i) {
-          const int block_id = i - num_eliminate_blocks_;
-          int r, c, row_stride, col_stride;
-          CellInfo* cell_info = lhs->GetCell(block_id, block_id, &r, &c,
-                                             &row_stride, &col_stride);
-          if (cell_info != NULL) {
-            const int block_size = bs->cols[i].size;
-            typename EigenTypes<Eigen::Dynamic>::ConstVectorRef diag(
-                D + bs->cols[i].position, block_size);
+    ParallelFor(context_,
+                num_eliminate_blocks_,
+                num_col_blocks,
+                num_threads_,
+                [&](int i) {
+                  const int block_id = i - num_eliminate_blocks_;
+                  int r, c, row_stride, col_stride;
+                  CellInfo* cell_info = lhs->GetCell(
+                      block_id, block_id, &r, &c, &row_stride, &col_stride);
+                  if (cell_info != NULL) {
+                    const int block_size = bs->cols[i].size;
+                    typename EigenTypes<Eigen::Dynamic>::ConstVectorRef diag(
+                        D + bs->cols[i].position, block_size);
 
-            std::lock_guard<std::mutex> l(cell_info->m);
-            MatrixRef m(cell_info->values, row_stride, col_stride);
-            m.block(r, c, block_size, block_size).diagonal() +=
-                diag.array().square().matrix();
-          }
-        });
+                    std::lock_guard<std::mutex> l(cell_info->m);
+                    MatrixRef m(cell_info->values, row_stride, col_stride);
+                    m.block(r, c, block_size, block_size).diagonal() +=
+                        diag.array().square().matrix();
+                  }
+                });
   }
 
   // Eliminate y blocks one chunk at a time.  For each chunk, compute
@@ -242,12 +242,12 @@
 
         VectorRef(buffer, buffer_size_).setZero();
 
-        typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix
-            ete(e_block_size, e_block_size);
+        typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix ete(e_block_size,
+                                                                  e_block_size);
 
         if (D != NULL) {
-          const typename EigenTypes<kEBlockSize>::ConstVectorRef
-              diag(D + bs->cols[e_block_id].position, e_block_size);
+          const typename EigenTypes<kEBlockSize>::ConstVectorRef diag(
+              D + bs->cols[e_block_id].position, e_block_size);
           ete = diag.array().square().matrix().asDiagonal();
         } else {
           ete.setZero();
@@ -299,31 +299,25 @@
 
         // S -= F'E(E'E)^{-1}E'F
         ChunkOuterProduct(
-        thread_id, bs, inverse_ete, buffer, chunk.buffer_layout, lhs);
+            thread_id, bs, inverse_ete, buffer, chunk.buffer_layout, lhs);
       });
 
   // For rows with no e_blocks, the schur complement update reduces to
   // S += F'F.
-  NoEBlockRowsUpdate(A, b,  uneliminated_row_begins_, lhs, rhs);
+  NoEBlockRowsUpdate(A, b, uneliminated_row_begins_, lhs, rhs);
 }
 
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-BackSubstitute(const BlockSparseMatrixData& A,
-               const double* b,
-               const double* D,
-               const double* z,
-               double* y) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::BackSubstitute(
+    const BlockSparseMatrixData& A,
+    const double* b,
+    const double* D,
+    const double* z,
+    double* y) {
   const CompressedRowBlockStructure* bs = A.block_structure();
   const double* values = A.values();
 
-  ParallelFor(
-      context_,
-      0,
-      int(chunks_.size()),
-      num_threads_,
-      [&](int i) {
+  ParallelFor(context_, 0, int(chunks_.size()), num_threads_, [&](int i) {
     const Chunk& chunk = chunks_[i];
     const int e_block_id = bs->rows[chunk.start].cells.front().block_id;
     const int e_block_size = bs->cols[e_block_id].size;
@@ -331,11 +325,11 @@
     double* y_ptr = y + bs->cols[e_block_id].position;
     typename EigenTypes<kEBlockSize>::VectorRef y_block(y_ptr, e_block_size);
 
-    typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix
-        ete(e_block_size, e_block_size);
+    typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix ete(e_block_size,
+                                                              e_block_size);
     if (D != NULL) {
-      const typename EigenTypes<kEBlockSize>::ConstVectorRef
-          diag(D + bs->cols[e_block_id].position, e_block_size);
+      const typename EigenTypes<kEBlockSize>::ConstVectorRef diag(
+          D + bs->cols[e_block_id].position, e_block_size);
       ete = diag.array().square().matrix().asDiagonal();
     } else {
       ete.setZero();
@@ -357,6 +351,7 @@
         const int f_block_size = bs->cols[f_block_id].size;
         const int r_block = f_block_id - num_eliminate_blocks_;
 
+        // clang-format off
         MatrixVectorMultiply<kRowBlockSize, kFBlockSize, -1>(
             values + row.cells[c].position, row.block.size, f_block_size,
             z + lhs_row_layout_[r_block],
@@ -373,6 +368,7 @@
           values + e_cell.position, row.block.size, e_block_size,
           values + e_cell.position, row.block.size, e_block_size,
           ete.data(), 0, 0, e_block_size, e_block_size);
+      // clang-format on
     }
 
     y_block =
@@ -384,14 +380,13 @@
 //
 //   F'b - F'E(E'E)^(-1) E'b
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-UpdateRhs(const Chunk& chunk,
-          const BlockSparseMatrixData& A,
-          const double* b,
-          int row_block_counter,
-          const double* inverse_ete_g,
-          double* rhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::UpdateRhs(
+    const Chunk& chunk,
+    const BlockSparseMatrixData& A,
+    const double* b,
+    int row_block_counter,
+    const double* inverse_ete_g,
+    double* rhs) {
   const CompressedRowBlockStructure* bs = A.block_structure();
   const double* values = A.values();
 
@@ -403,22 +398,26 @@
     const Cell& e_cell = row.cells.front();
 
     typename EigenTypes<kRowBlockSize>::Vector sj =
-        typename EigenTypes<kRowBlockSize>::ConstVectorRef
-        (b + b_pos, row.block.size);
+        typename EigenTypes<kRowBlockSize>::ConstVectorRef(b + b_pos,
+                                                           row.block.size);
 
+    // clang-format off
     MatrixVectorMultiply<kRowBlockSize, kEBlockSize, -1>(
         values + e_cell.position, row.block.size, e_block_size,
         inverse_ete_g, sj.data());
+    // clang-format on
 
     for (int c = 1; c < row.cells.size(); ++c) {
       const int block_id = row.cells[c].block_id;
       const int block_size = bs->cols[block_id].size;
       const int block = block_id - num_eliminate_blocks_;
       std::lock_guard<std::mutex> l(*rhs_locks_[block]);
+      // clang-format off
       MatrixTransposeVectorMultiply<kRowBlockSize, kFBlockSize, 1>(
           values + row.cells[c].position,
           row.block.size, block_size,
           sj.data(), rhs + lhs_row_layout_[block]);
+      // clang-format on
     }
     b_pos += row.block.size;
   }
@@ -444,17 +443,16 @@
 //
 // and the gradient of the e_block, E'b.
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-ChunkDiagonalBlockAndGradient(
-    const Chunk& chunk,
-    const BlockSparseMatrixData& A,
-    const double* b,
-    int row_block_counter,
-    typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix* ete,
-    double* g,
-    double* buffer,
-    BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    ChunkDiagonalBlockAndGradient(
+        const Chunk& chunk,
+        const BlockSparseMatrixData& A,
+        const double* b,
+        int row_block_counter,
+        typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix* ete,
+        double* g,
+        double* buffer,
+        BlockRandomAccessMatrix* lhs) {
   const CompressedRowBlockStructure* bs = A.block_structure();
   const double* values = A.values();
 
@@ -474,18 +472,22 @@
 
     // Extract the e_block, ETE += E_i' E_i
     const Cell& e_cell = row.cells.front();
+    // clang-format off
     MatrixTransposeMatrixMultiply
         <kRowBlockSize, kEBlockSize, kRowBlockSize, kEBlockSize, 1>(
             values + e_cell.position, row.block.size, e_block_size,
             values + e_cell.position, row.block.size, e_block_size,
             ete->data(), 0, 0, e_block_size, e_block_size);
+    // clang-format on
 
     if (b) {
       // g += E_i' b_i
+      // clang-format off
       MatrixTransposeVectorMultiply<kRowBlockSize, kEBlockSize, 1>(
           values + e_cell.position, row.block.size, e_block_size,
           b + b_pos,
           g);
+      // clang-format on
     }
 
     // buffer = E'F. This computation is done by iterating over the
@@ -493,13 +495,14 @@
     for (int c = 1; c < row.cells.size(); ++c) {
       const int f_block_id = row.cells[c].block_id;
       const int f_block_size = bs->cols[f_block_id].size;
-      double* buffer_ptr =
-          buffer +  FindOrDie(chunk.buffer_layout, f_block_id);
+      double* buffer_ptr = buffer + FindOrDie(chunk.buffer_layout, f_block_id);
+      // clang-format off
       MatrixTransposeMatrixMultiply
           <kRowBlockSize, kEBlockSize, kRowBlockSize, kFBlockSize, 1>(
           values + e_cell.position, row.block.size, e_block_size,
           values + row.cells[c].position, row.block.size, f_block_size,
           buffer_ptr, 0, 0, e_block_size, f_block_size);
+      // clang-format on
     }
     b_pos += row.block.size;
   }
@@ -510,14 +513,13 @@
 //
 //  S -= F'E(E'E)^{-1}E'F.
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-ChunkOuterProduct(int thread_id,
-                  const CompressedRowBlockStructure* bs,
-                  const Matrix& inverse_ete,
-                  const double* buffer,
-                  const BufferLayoutType& buffer_layout,
-                  BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    ChunkOuterProduct(int thread_id,
+                      const CompressedRowBlockStructure* bs,
+                      const Matrix& inverse_ete,
+                      const double* buffer,
+                      const BufferLayoutType& buffer_layout,
+                      BlockRandomAccessMatrix* lhs) {
   // This is the most computationally expensive part of this
   // code. Profiling experiments reveal that the bottleneck is not the
   // computation of the right-hand matrix product, but memory
@@ -532,28 +534,31 @@
   for (; it1 != buffer_layout.end(); ++it1) {
     const int block1 = it1->first - num_eliminate_blocks_;
     const int block1_size = bs->cols[it1->first].size;
+    // clang-format off
     MatrixTransposeMatrixMultiply
         <kEBlockSize, kFBlockSize, kEBlockSize, kEBlockSize, 0>(
         buffer + it1->second, e_block_size, block1_size,
         inverse_ete.data(), e_block_size, e_block_size,
         b1_transpose_inverse_ete, 0, 0, block1_size, e_block_size);
+    // clang-format on
 
     BufferLayoutType::const_iterator it2 = it1;
     for (; it2 != buffer_layout.end(); ++it2) {
       const int block2 = it2->first - num_eliminate_blocks_;
 
       int r, c, row_stride, col_stride;
-      CellInfo* cell_info = lhs->GetCell(block1, block2,
-                                         &r, &c,
-                                         &row_stride, &col_stride);
+      CellInfo* cell_info =
+          lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
       if (cell_info != NULL) {
         const int block2_size = bs->cols[it2->first].size;
         std::lock_guard<std::mutex> l(cell_info->m);
+        // clang-format off
         MatrixMatrixMultiply
             <kFBlockSize, kEBlockSize, kEBlockSize, kFBlockSize, -1>(
                 b1_transpose_inverse_ete, block1_size, e_block_size,
                 buffer  + it2->second, e_block_size, block2_size,
                 cell_info->values, r, c, row_stride, col_stride);
+        // clang-format on
       }
     }
   }
@@ -563,13 +568,12 @@
 // += F'F. This function iterates over the rows of A with no e_block,
 // and calls NoEBlockRowOuterProduct on each row.
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-NoEBlockRowsUpdate(const BlockSparseMatrixData& A,
-                   const double* b,
-                   int row_block_counter,
-                   BlockRandomAccessMatrix* lhs,
-                   double* rhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    NoEBlockRowsUpdate(const BlockSparseMatrixData& A,
+                       const double* b,
+                       int row_block_counter,
+                       BlockRandomAccessMatrix* lhs,
+                       double* rhs) {
   const CompressedRowBlockStructure* bs = A.block_structure();
   const double* values = A.values();
   for (; row_block_counter < bs->rows.size(); ++row_block_counter) {
@@ -582,15 +586,16 @@
       const int block_id = row.cells[c].block_id;
       const int block_size = bs->cols[block_id].size;
       const int block = block_id - num_eliminate_blocks_;
+      // clang-format off
       MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
           values + row.cells[c].position, row.block.size, block_size,
           b + row.block.position,
           rhs + lhs_row_layout_[block]);
+      // clang-format on
     }
   }
 }
 
-
 // A row r of A, which has no e_blocks gets added to the Schur
 // Complement as S += r r'. This function is responsible for computing
 // the contribution of a single row r to the Schur complement. It is
@@ -606,11 +611,10 @@
 // dynamic. Since the number of rows without e_blocks is small, the
 // lack of templating is not an issue.
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-NoEBlockRowOuterProduct(const BlockSparseMatrixData& A,
-                        int row_block_index,
-                        BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    NoEBlockRowOuterProduct(const BlockSparseMatrixData& A,
+                            int row_block_index,
+                            BlockRandomAccessMatrix* lhs) {
   const CompressedRowBlockStructure* bs = A.block_structure();
   const double* values = A.values();
 
@@ -621,18 +625,19 @@
 
     const int block1_size = bs->cols[row.cells[i].block_id].size;
     int r, c, row_stride, col_stride;
-    CellInfo* cell_info = lhs->GetCell(block1, block1,
-                                       &r, &c,
-                                       &row_stride, &col_stride);
+    CellInfo* cell_info =
+        lhs->GetCell(block1, block1, &r, &c, &row_stride, &col_stride);
     if (cell_info != NULL) {
       std::lock_guard<std::mutex> l(cell_info->m);
       // This multiply currently ignores the fact that this is a
       // symmetric outer product.
+      // clang-format off
       MatrixTransposeMatrixMultiply
           <Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, 1>(
               values + row.cells[i].position, row.block.size, block1_size,
               values + row.cells[i].position, row.block.size, block1_size,
               cell_info->values, r, c, row_stride, col_stride);
+      // clang-format on
     }
 
     for (int j = i + 1; j < row.cells.size(); ++j) {
@@ -640,17 +645,18 @@
       DCHECK_GE(block2, 0);
       DCHECK_LT(block1, block2);
       int r, c, row_stride, col_stride;
-      CellInfo* cell_info = lhs->GetCell(block1, block2,
-                                         &r, &c,
-                                         &row_stride, &col_stride);
+      CellInfo* cell_info =
+          lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
       if (cell_info != NULL) {
         const int block2_size = bs->cols[row.cells[j].block_id].size;
         std::lock_guard<std::mutex> l(cell_info->m);
+        // clang-format off
         MatrixTransposeMatrixMultiply
             <Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, 1>(
                 values + row.cells[i].position, row.block.size, block1_size,
                 values + row.cells[j].position, row.block.size, block2_size,
                 cell_info->values, r, c, row_stride, col_stride);
+        // clang-format on
       }
     }
   }
@@ -660,11 +666,10 @@
 // function has the same structure as NoEBlockRowOuterProduct, except
 // that this function uses the template parameters.
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-EBlockRowOuterProduct(const BlockSparseMatrixData& A,
-                      int row_block_index,
-                      BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+    EBlockRowOuterProduct(const BlockSparseMatrixData& A,
+                          int row_block_index,
+                          BlockRandomAccessMatrix* lhs) {
   const CompressedRowBlockStructure* bs = A.block_structure();
   const double* values = A.values();
 
@@ -675,17 +680,18 @@
 
     const int block1_size = bs->cols[row.cells[i].block_id].size;
     int r, c, row_stride, col_stride;
-    CellInfo* cell_info = lhs->GetCell(block1, block1,
-                                       &r, &c,
-                                       &row_stride, &col_stride);
+    CellInfo* cell_info =
+        lhs->GetCell(block1, block1, &r, &c, &row_stride, &col_stride);
     if (cell_info != NULL) {
       std::lock_guard<std::mutex> l(cell_info->m);
       // block += b1.transpose() * b1;
+      // clang-format off
       MatrixTransposeMatrixMultiply
           <kRowBlockSize, kFBlockSize, kRowBlockSize, kFBlockSize, 1>(
           values + row.cells[i].position, row.block.size, block1_size,
           values + row.cells[i].position, row.block.size, block1_size,
           cell_info->values, r, c, row_stride, col_stride);
+      // clang-format on
     }
 
     for (int j = i + 1; j < row.cells.size(); ++j) {
@@ -694,17 +700,18 @@
       DCHECK_LT(block1, block2);
       const int block2_size = bs->cols[row.cells[j].block_id].size;
       int r, c, row_stride, col_stride;
-      CellInfo* cell_info = lhs->GetCell(block1, block2,
-                                         &r, &c,
-                                         &row_stride, &col_stride);
+      CellInfo* cell_info =
+          lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
       if (cell_info != NULL) {
         // block += b1.transpose() * b2;
         std::lock_guard<std::mutex> l(cell_info->m);
+        // clang-format off
         MatrixTransposeMatrixMultiply
             <kRowBlockSize, kFBlockSize, kRowBlockSize, kFBlockSize, 1>(
                 values + row.cells[i].position, row.block.size, block1_size,
                 values + row.cells[j].position, row.block.size, block2_size,
                 cell_info->values, r, c, row_stride, col_stride);
+        // clang-format on
       }
     }
   }
diff --git a/internal/ceres/scratch_evaluate_preparer.cc b/internal/ceres/scratch_evaluate_preparer.cc
index f01ef11..9905b22 100644
--- a/internal/ceres/scratch_evaluate_preparer.cc
+++ b/internal/ceres/scratch_evaluate_preparer.cc
@@ -37,9 +37,8 @@
 namespace ceres {
 namespace internal {
 
-ScratchEvaluatePreparer* ScratchEvaluatePreparer::Create(
-    const Program &program,
-    int num_threads) {
+ScratchEvaluatePreparer* ScratchEvaluatePreparer::Create(const Program& program,
+                                                         int num_threads) {
   ScratchEvaluatePreparer* preparers = new ScratchEvaluatePreparer[num_threads];
   int max_derivatives_per_residual_block =
       program.MaxDerivativesPerResidualBlock();
@@ -50,8 +49,7 @@
 }
 
 void ScratchEvaluatePreparer::Init(int max_derivatives_per_residual_block) {
-  jacobian_scratch_.reset(
-      new double[max_derivatives_per_residual_block]);
+  jacobian_scratch_.reset(new double[max_derivatives_per_residual_block]);
 }
 
 // Point the jacobian blocks into the scratch area of this evaluate preparer.
diff --git a/internal/ceres/scratch_evaluate_preparer.h b/internal/ceres/scratch_evaluate_preparer.h
index c8d9b93..2d2745d 100644
--- a/internal/ceres/scratch_evaluate_preparer.h
+++ b/internal/ceres/scratch_evaluate_preparer.h
@@ -47,7 +47,7 @@
 class ScratchEvaluatePreparer {
  public:
   // Create num_threads ScratchEvaluatePreparers.
-  static ScratchEvaluatePreparer* Create(const Program &program,
+  static ScratchEvaluatePreparer* Create(const Program& program,
                                          int num_threads);
 
   // EvaluatePreparer interface
diff --git a/internal/ceres/single_linkage_clustering.cc b/internal/ceres/single_linkage_clustering.cc
index 394492c..0e78131 100644
--- a/internal/ceres/single_linkage_clustering.cc
+++ b/internal/ceres/single_linkage_clustering.cc
@@ -30,8 +30,9 @@
 
 #include "ceres/single_linkage_clustering.h"
 
-#include <unordered_set>
 #include <unordered_map>
+#include <unordered_set>
+
 #include "ceres/graph.h"
 #include "ceres/graph_algorithms.h"
 
diff --git a/internal/ceres/single_linkage_clustering.h b/internal/ceres/single_linkage_clustering.h
index ccd6f8e..ef6bff4 100644
--- a/internal/ceres/single_linkage_clustering.h
+++ b/internal/ceres/single_linkage_clustering.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_SINGLE_LINKAGE_CLUSTERING_H_
 
 #include <unordered_map>
+
 #include "ceres/graph.h"
 
 namespace ceres {
diff --git a/internal/ceres/single_linkage_clustering_test.cc b/internal/ceres/single_linkage_clustering_test.cc
index 281c281..28c7c41 100644
--- a/internal/ceres/single_linkage_clustering_test.cc
+++ b/internal/ceres/single_linkage_clustering_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/single_linkage_clustering.h"
 
 #include <unordered_map>
+
 #include "ceres/graph.h"
 #include "gtest/gtest.h"
 
diff --git a/internal/ceres/small_blas.h b/internal/ceres/small_blas.h
index 81c5872..4ee9229 100644
--- a/internal/ceres/small_blas.h
+++ b/internal/ceres/small_blas.h
@@ -35,8 +35,8 @@
 #ifndef CERES_INTERNAL_SMALL_BLAS_H_
 #define CERES_INTERNAL_SMALL_BLAS_H_
 
-#include "ceres/internal/port.h"
 #include "ceres/internal/eigen.h"
+#include "ceres/internal/port.h"
 #include "glog/logging.h"
 #include "small_blas_generic.h"
 
@@ -46,7 +46,7 @@
 // The following three macros are used to share code and reduce
 // template junk across the various GEMM variants.
 #define CERES_GEMM_BEGIN(name)                                          \
-  template<int kRowA, int kColA, int kRowB, int kColB, int kOperation>  \
+  template <int kRowA, int kColA, int kRowB, int kColB, int kOperation> \
   inline void name(const double* A,                                     \
                    const int num_row_a,                                 \
                    const int num_col_a,                                 \
@@ -59,56 +59,58 @@
                    const int row_stride_c,                              \
                    const int col_stride_c)
 
-#define CERES_GEMM_NAIVE_HEADER                                         \
-  DCHECK_GT(num_row_a, 0);                                              \
-  DCHECK_GT(num_col_a, 0);                                              \
-  DCHECK_GT(num_row_b, 0);                                              \
-  DCHECK_GT(num_col_b, 0);                                              \
-  DCHECK_GE(start_row_c, 0);                                            \
-  DCHECK_GE(start_col_c, 0);                                            \
-  DCHECK_GT(row_stride_c, 0);                                           \
-  DCHECK_GT(col_stride_c, 0);                                           \
-  DCHECK((kRowA == Eigen::Dynamic) || (kRowA == num_row_a));            \
-  DCHECK((kColA == Eigen::Dynamic) || (kColA == num_col_a));            \
-  DCHECK((kRowB == Eigen::Dynamic) || (kRowB == num_row_b));            \
-  DCHECK((kColB == Eigen::Dynamic) || (kColB == num_col_b));            \
-  const int NUM_ROW_A = (kRowA != Eigen::Dynamic ? kRowA : num_row_a);  \
-  const int NUM_COL_A = (kColA != Eigen::Dynamic ? kColA : num_col_a);  \
-  const int NUM_ROW_B = (kRowB != Eigen::Dynamic ? kRowB : num_row_b);  \
+#define CERES_GEMM_NAIVE_HEADER                                        \
+  DCHECK_GT(num_row_a, 0);                                             \
+  DCHECK_GT(num_col_a, 0);                                             \
+  DCHECK_GT(num_row_b, 0);                                             \
+  DCHECK_GT(num_col_b, 0);                                             \
+  DCHECK_GE(start_row_c, 0);                                           \
+  DCHECK_GE(start_col_c, 0);                                           \
+  DCHECK_GT(row_stride_c, 0);                                          \
+  DCHECK_GT(col_stride_c, 0);                                          \
+  DCHECK((kRowA == Eigen::Dynamic) || (kRowA == num_row_a));           \
+  DCHECK((kColA == Eigen::Dynamic) || (kColA == num_col_a));           \
+  DCHECK((kRowB == Eigen::Dynamic) || (kRowB == num_row_b));           \
+  DCHECK((kColB == Eigen::Dynamic) || (kColB == num_col_b));           \
+  const int NUM_ROW_A = (kRowA != Eigen::Dynamic ? kRowA : num_row_a); \
+  const int NUM_COL_A = (kColA != Eigen::Dynamic ? kColA : num_col_a); \
+  const int NUM_ROW_B = (kRowB != Eigen::Dynamic ? kRowB : num_row_b); \
   const int NUM_COL_B = (kColB != Eigen::Dynamic ? kColB : num_col_b);
 
-#define CERES_GEMM_EIGEN_HEADER                                         \
-  const typename EigenTypes<kRowA, kColA>::ConstMatrixRef               \
-  Aref(A, num_row_a, num_col_a);                                        \
-  const typename EigenTypes<kRowB, kColB>::ConstMatrixRef               \
-  Bref(B, num_row_b, num_col_b);                                        \
-  MatrixRef Cref(C, row_stride_c, col_stride_c);                        \
+#define CERES_GEMM_EIGEN_HEADER                                 \
+  const typename EigenTypes<kRowA, kColA>::ConstMatrixRef Aref( \
+      A, num_row_a, num_col_a);                                 \
+  const typename EigenTypes<kRowB, kColB>::ConstMatrixRef Bref( \
+      B, num_row_b, num_col_b);                                 \
+  MatrixRef Cref(C, row_stride_c, col_stride_c);
 
+// clang-format off
 #define CERES_CALL_GEMM(name)                                           \
   name<kRowA, kColA, kRowB, kColB, kOperation>(                         \
       A, num_row_a, num_col_a,                                          \
       B, num_row_b, num_col_b,                                          \
       C, start_row_c, start_col_c, row_stride_c, col_stride_c);
+// clang-format on
 
-#define CERES_GEMM_STORE_SINGLE(p, index, value)                        \
-  if (kOperation > 0) {                                                 \
-    p[index] += value;                                                  \
-  } else if (kOperation < 0) {                                          \
-    p[index] -= value;                                                  \
-  } else {                                                              \
-    p[index] = value;                                                   \
+#define CERES_GEMM_STORE_SINGLE(p, index, value) \
+  if (kOperation > 0) {                          \
+    p[index] += value;                           \
+  } else if (kOperation < 0) {                   \
+    p[index] -= value;                           \
+  } else {                                       \
+    p[index] = value;                            \
   }
 
-#define CERES_GEMM_STORE_PAIR(p, index, v1, v2)                         \
-  if (kOperation > 0) {                                                 \
-    p[index] += v1;                                                     \
-    p[index + 1] += v2;                                                 \
-  } else if (kOperation < 0) {                                          \
-    p[index] -= v1;                                                     \
-    p[index + 1] -= v2;                                                 \
-  } else {                                                              \
-    p[index] = v1;                                                      \
-    p[index + 1] = v2;                                                  \
+#define CERES_GEMM_STORE_PAIR(p, index, v1, v2) \
+  if (kOperation > 0) {                         \
+    p[index] += v1;                             \
+    p[index + 1] += v2;                         \
+  } else if (kOperation < 0) {                  \
+    p[index] -= v1;                             \
+    p[index + 1] -= v2;                         \
+  } else {                                      \
+    p[index] = v1;                              \
+    p[index + 1] = v2;                          \
   }
 
 // For the matrix-matrix functions below, there are three variants for
@@ -161,8 +163,8 @@
 //
 CERES_GEMM_BEGIN(MatrixMatrixMultiplyEigen) {
   CERES_GEMM_EIGEN_HEADER
-  Eigen::Block<MatrixRef, kRowA, kColB>
-    block(Cref, start_row_c, start_col_c, num_row_a, num_col_b);
+  Eigen::Block<MatrixRef, kRowA, kColB> block(
+      Cref, start_row_c, start_col_c, num_row_a, num_col_b);
 
   if (kOperation > 0) {
     block.noalias() += Aref * Bref;
@@ -208,7 +210,7 @@
 
   // Process the couple columns in remainder if present.
   if (NUM_COL_C & 2) {
-    int col = NUM_COL_C & (int)(~(span - 1)) ;
+    int col = NUM_COL_C & (int)(~(span - 1));
     const double* pa = &A[0];
     for (int row = 0; row < NUM_ROW_C; ++row, pa += NUM_COL_A) {
       const double* pb = &B[col];
@@ -234,11 +236,12 @@
   for (int col = 0; col < col_m; col += span) {
     for (int row = 0; row < NUM_ROW_C; ++row) {
       const int index = (row + start_row_c) * col_stride_c + start_col_c + col;
+      // clang-format off
       MMM_mat1x4(NUM_COL_A, &A[row * NUM_COL_A],
                  &B[col], NUM_COL_B, &C[index], kOperation);
+      // clang-format on
     }
   }
-
 }
 
 CERES_GEMM_BEGIN(MatrixMatrixMultiply) {
@@ -261,9 +264,11 @@
 
 CERES_GEMM_BEGIN(MatrixTransposeMatrixMultiplyEigen) {
   CERES_GEMM_EIGEN_HEADER
+  // clang-format off
   Eigen::Block<MatrixRef, kColA, kColB> block(Cref,
                                               start_row_c, start_col_c,
                                               num_col_a, num_col_b);
+  // clang-format on
   if (kOperation > 0) {
     block.noalias() += Aref.transpose() * Bref;
   } else if (kOperation < 0) {
@@ -310,7 +315,7 @@
 
   // Process the couple columns in remainder if present.
   if (NUM_COL_C & 2) {
-    int col = NUM_COL_C & (int)(~(span - 1)) ;
+    int col = NUM_COL_C & (int)(~(span - 1));
     for (int row = 0; row < NUM_ROW_C; ++row) {
       const double* pa = &A[row];
       const double* pb = &B[col];
@@ -338,11 +343,12 @@
   for (int col = 0; col < col_m; col += span) {
     for (int row = 0; row < NUM_ROW_C; ++row) {
       const int index = (row + start_row_c) * col_stride_c + start_col_c + col;
+      // clang-format off
       MTM_mat1x4(NUM_ROW_A, &A[row], NUM_COL_A,
                  &B[col], NUM_COL_B, &C[index], kOperation);
+      // clang-format on
     }
   }
-
 }
 
 CERES_GEMM_BEGIN(MatrixTransposeMatrixMultiply) {
@@ -376,15 +382,15 @@
 // kOperation =  1  -> c += A' * b
 // kOperation = -1  -> c -= A' * b
 // kOperation =  0  -> c  = A' * b
-template<int kRowA, int kColA, int kOperation>
+template <int kRowA, int kColA, int kOperation>
 inline void MatrixVectorMultiply(const double* A,
                                  const int num_row_a,
                                  const int num_col_a,
                                  const double* b,
                                  double* c) {
 #ifdef CERES_NO_CUSTOM_BLAS
-  const typename EigenTypes<kRowA, kColA>::ConstMatrixRef
-      Aref(A, num_row_a, num_col_a);
+  const typename EigenTypes<kRowA, kColA>::ConstMatrixRef Aref(
+      A, num_row_a, num_col_a);
   const typename EigenTypes<kColA>::ConstVectorRef bref(b, num_col_a);
   typename EigenTypes<kRowA>::VectorRef cref(c, num_row_a);
 
@@ -412,7 +418,7 @@
 
   // Process the last odd row if present.
   if (NUM_ROW_A & 1) {
-    int row  = NUM_ROW_A - 1;
+    int row = NUM_ROW_A - 1;
     const double* pa = &A[row * NUM_COL_A];
     const double* pb = &b[0];
     double tmp = 0.0;
@@ -450,8 +456,10 @@
   // Calculate the main part with multiples of 4.
   int row_m = NUM_ROW_A & (int)(~(span - 1));
   for (int row = 0; row < row_m; row += span) {
+    // clang-format off
     MVM_mat4x1(NUM_COL_A, &A[row * NUM_COL_A], NUM_COL_A,
                &b[0], &c[row], kOperation);
+    // clang-format on
   }
 
 #endif  // CERES_NO_CUSTOM_BLAS
@@ -460,15 +468,15 @@
 // Similar to MatrixVectorMultiply, except that A is transposed, i.e.,
 //
 // c op A' * b;
-template<int kRowA, int kColA, int kOperation>
+template <int kRowA, int kColA, int kOperation>
 inline void MatrixTransposeVectorMultiply(const double* A,
                                           const int num_row_a,
                                           const int num_col_a,
                                           const double* b,
                                           double* c) {
 #ifdef CERES_NO_CUSTOM_BLAS
-  const typename EigenTypes<kRowA, kColA>::ConstMatrixRef
-      Aref(A, num_row_a, num_col_a);
+  const typename EigenTypes<kRowA, kColA>::ConstMatrixRef Aref(
+      A, num_row_a, num_col_a);
   const typename EigenTypes<kRowA>::ConstVectorRef bref(b, num_row_a);
   typename EigenTypes<kColA>::VectorRef cref(c, num_col_a);
 
@@ -496,7 +504,7 @@
 
   // Process the last odd column if present.
   if (NUM_COL_A & 1) {
-    int row  = NUM_COL_A - 1;
+    int row = NUM_COL_A - 1;
     const double* pa = &A[row];
     const double* pb = &b[0];
     double tmp = 0.0;
@@ -519,10 +527,12 @@
     const double* pb = &b[0];
     double tmp1 = 0.0, tmp2 = 0.0;
     for (int col = 0; col < NUM_ROW_A; ++col) {
+      // clang-format off
       double bv = *pb++;
       tmp1 += *(pa    ) * bv;
       tmp2 += *(pa + 1) * bv;
       pa += NUM_COL_A;
+      // clang-format on
     }
     CERES_GEMM_STORE_PAIR(c, row, tmp1, tmp2);
 
@@ -535,8 +545,10 @@
   // Calculate the main part with multiples of 4.
   int row_m = NUM_COL_A & (int)(~(span - 1));
   for (int row = 0; row < row_m; row += span) {
+    // clang-format off
     MTV_mat4x1(NUM_ROW_A, &A[row], NUM_COL_A,
                &b[0], &c[row], kOperation);
+    // clang-format on
   }
 
 #endif  // CERES_NO_CUSTOM_BLAS
diff --git a/internal/ceres/small_blas_gemm_benchmark.cc b/internal/ceres/small_blas_gemm_benchmark.cc
index 0a760a5..aa6c41d 100644
--- a/internal/ceres/small_blas_gemm_benchmark.cc
+++ b/internal/ceres/small_blas_gemm_benchmark.cc
@@ -29,6 +29,7 @@
 // Authors: sameeragarwal@google.com (Sameer Agarwal)
 
 #include <iostream>
+
 #include "Eigen/Dense"
 #include "benchmark/benchmark.h"
 #include "ceres/small_blas.h"
@@ -103,11 +104,13 @@
   int iter = 0;
   for (auto _ : state) {
     // a += b * c
+    // clang-format off
     MatrixMatrixMultiply
         <Eigen::Dynamic, Eigen::Dynamic,Eigen::Dynamic,Eigen::Dynamic, 1>
         (data.GetB(iter), b_rows, b_cols,
          data.GetC(iter), c_rows, c_cols,
          data.GetA(iter), 0, 0, a_rows, a_cols);
+    // clang-format on
     iter = (iter + 1) % num_elements;
   }
 }
@@ -147,11 +150,13 @@
   int iter = 0;
   for (auto _ : state) {
     // a += b' * c
+    // clang-format off
     MatrixTransposeMatrixMultiply
         <Eigen::Dynamic,Eigen::Dynamic,Eigen::Dynamic,Eigen::Dynamic, 1>
         (data.GetB(iter), b_rows, b_cols,
          data.GetC(iter), c_rows, c_cols,
          data.GetA(iter), 0, 0, a_rows, a_cols);
+    // clang-format on
     iter = (iter + 1) % num_elements;
   }
 }
@@ -159,7 +164,7 @@
 BENCHMARK(BM_MatrixTransposeMatrixMultiplyDynamic)
     ->Apply(MatrixTransposeMatrixMultiplySizeArguments);
 
-}  // internal
+}  // namespace internal
 }  // namespace ceres
 
 BENCHMARK_MAIN();
diff --git a/internal/ceres/small_blas_generic.h b/internal/ceres/small_blas_generic.h
index 978c5d5..3f3ea42 100644
--- a/internal/ceres/small_blas_generic.h
+++ b/internal/ceres/small_blas_generic.h
@@ -39,33 +39,33 @@
 namespace internal {
 
 // The following macros are used to share code
-#define CERES_GEMM_OPT_NAIVE_HEADER              \
-  double c0 = 0.0;                               \
-  double c1 = 0.0;                               \
-  double c2 = 0.0;                               \
-  double c3 = 0.0;                               \
-  const double* pa = a;                          \
-  const double* pb = b;                          \
-  const int span = 4;                            \
-  int col_r = col_a & (span - 1);                \
+#define CERES_GEMM_OPT_NAIVE_HEADER \
+  double c0 = 0.0;                  \
+  double c1 = 0.0;                  \
+  double c2 = 0.0;                  \
+  double c3 = 0.0;                  \
+  const double* pa = a;             \
+  const double* pb = b;             \
+  const int span = 4;               \
+  int col_r = col_a & (span - 1);   \
   int col_m = col_a - col_r;
 
-#define CERES_GEMM_OPT_STORE_MAT1X4              \
-  if (kOperation > 0) {                          \
-    *c++ += c0;                                  \
-    *c++ += c1;                                  \
-    *c++ += c2;                                  \
-    *c++ += c3;                                  \
-  } else if (kOperation < 0) {                   \
-    *c++ -= c0;                                  \
-    *c++ -= c1;                                  \
-    *c++ -= c2;                                  \
-    *c++ -= c3;                                  \
-  } else {                                       \
-    *c++ = c0;                                   \
-    *c++ = c1;                                   \
-    *c++ = c2;                                   \
-    *c++ = c3;                                   \
+#define CERES_GEMM_OPT_STORE_MAT1X4 \
+  if (kOperation > 0) {             \
+    *c++ += c0;                     \
+    *c++ += c1;                     \
+    *c++ += c2;                     \
+    *c++ += c3;                     \
+  } else if (kOperation < 0) {      \
+    *c++ -= c0;                     \
+    *c++ -= c1;                     \
+    *c++ -= c2;                     \
+    *c++ -= c3;                     \
+  } else {                          \
+    *c++ = c0;                      \
+    *c++ = c1;                      \
+    *c++ = c2;                      \
+    *c++ = c3;                      \
   }
 
 // Matrix-Matrix Multiplication
@@ -97,14 +97,14 @@
   double av = 0.0;
   int bi = 0;
 
-#define CERES_GEMM_OPT_MMM_MAT1X4_MUL  \
-  av = pa[k];                          \
-  pb = b + bi;                         \
-  c0 += av * *pb++;                    \
-  c1 += av * *pb++;                    \
-  c2 += av * *pb++;                    \
-  c3 += av * *pb++;                    \
-  bi += col_stride_b;                  \
+#define CERES_GEMM_OPT_MMM_MAT1X4_MUL \
+  av = pa[k];                         \
+  pb = b + bi;                        \
+  c0 += av * *pb++;                   \
+  c1 += av * *pb++;                   \
+  c2 += av * *pb++;                   \
+  c3 += av * *pb++;                   \
+  bi += col_stride_b;                 \
   k++;
 
   for (int k = 0; k < col_m;) {
@@ -164,14 +164,14 @@
   int ai = 0;
   int bi = 0;
 
-#define CERES_GEMM_OPT_MTM_MAT1X4_MUL  \
-  av = pa[ai];                         \
-  pb = b + bi;                         \
-  c0 += av * *pb++;                    \
-  c1 += av * *pb++;                    \
-  c2 += av * *pb++;                    \
-  c3 += av * *pb++;                    \
-  ai += col_stride_a;                  \
+#define CERES_GEMM_OPT_MTM_MAT1X4_MUL \
+  av = pa[ai];                        \
+  pb = b + bi;                        \
+  c0 += av * *pb++;                   \
+  c1 += av * *pb++;                   \
+  c2 += av * *pb++;                   \
+  c3 += av * *pb++;                   \
+  ai += col_stride_a;                 \
   bi += col_stride_b;
 
   for (int k = 0; k < col_m; k += span) {
@@ -218,14 +218,16 @@
   CERES_GEMM_OPT_NAIVE_HEADER
   double bv = 0.0;
 
-#define CERES_GEMM_OPT_MVM_MAT4X1_MUL              \
-  bv = *pb;                                        \
-  c0 += *(pa                   ) * bv;             \
-  c1 += *(pa + col_stride_a    ) * bv;             \
-  c2 += *(pa + col_stride_a * 2) * bv;             \
-  c3 += *(pa + col_stride_a * 3) * bv;             \
-  pa++;                                            \
+  // clang-format off
+#define CERES_GEMM_OPT_MVM_MAT4X1_MUL  \
+  bv = *pb;                            \
+  c0 += *(pa                   ) * bv; \
+  c1 += *(pa + col_stride_a    ) * bv; \
+  c2 += *(pa + col_stride_a * 2) * bv; \
+  c3 += *(pa + col_stride_a * 3) * bv; \
+  pa++;                                \
   pb++;
+  // clang-format on
 
   for (int k = 0; k < col_m; k += span) {
     CERES_GEMM_OPT_MVM_MAT4X1_MUL
@@ -281,14 +283,16 @@
   CERES_GEMM_OPT_NAIVE_HEADER
   double bv = 0.0;
 
-#define CERES_GEMM_OPT_MTV_MAT4X1_MUL  \
-  bv = *pb;                            \
-  c0 += *(pa    ) * bv;                \
-  c1 += *(pa + 1) * bv;                \
-  c2 += *(pa + 2) * bv;                \
-  c3 += *(pa + 3) * bv;                \
-  pa += col_stride_a;                  \
+  // clang-format off
+#define CERES_GEMM_OPT_MTV_MAT4X1_MUL \
+  bv = *pb;                           \
+  c0 += *(pa    ) * bv;               \
+  c1 += *(pa + 1) * bv;               \
+  c2 += *(pa + 2) * bv;               \
+  c3 += *(pa + 3) * bv;               \
+  pa += col_stride_a;                 \
   pb++;
+  // clang-format on
 
   for (int k = 0; k < col_m; k += span) {
     CERES_GEMM_OPT_MTV_MAT4X1_MUL
diff --git a/internal/ceres/small_blas_test.cc b/internal/ceres/small_blas_test.cc
index 2914244..6f819c4 100644
--- a/internal/ceres/small_blas_test.cc
+++ b/internal/ceres/small_blas_test.cc
@@ -31,8 +31,9 @@
 #include "ceres/small_blas.h"
 
 #include <limits>
-#include "gtest/gtest.h"
+
 #include "ceres/internal/eigen.h"
+#include "gtest/gtest.h"
 
 namespace ceres {
 namespace internal {
@@ -62,6 +63,7 @@
       Matrix C_plus_ref = C;
       Matrix C_minus_ref = C;
       Matrix C_assign_ref = C;
+      // clang-format off
       for (int start_row_c = 0; start_row_c + kRowA < row_stride_c; ++start_row_c) {
         for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
           C_plus_ref.block(start_row_c, start_col_c, kRowA, kColB) +=
@@ -81,7 +83,6 @@
               << "Cref : \n" << C_plus_ref << "\n"
               << "C: \n" << C_plus;
 
-
           C_minus_ref.block(start_row_c, start_col_c, kRowA, kColB) -=
               A * B;
 
@@ -117,6 +118,7 @@
               << "C: \n" << C_assign;
         }
       }
+      // clang-format on
     }
   }
 }
@@ -133,7 +135,7 @@
   B.setOnes();
 
   for (int row_stride_c = kColA; row_stride_c < 3 * kColA; ++row_stride_c) {
-    for (int col_stride_c = kColB; col_stride_c <  3 * kColB; ++col_stride_c) {
+    for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
       Matrix C(row_stride_c, col_stride_c);
       C.setOnes();
 
@@ -144,6 +146,7 @@
       Matrix C_plus_ref = C;
       Matrix C_minus_ref = C;
       Matrix C_assign_ref = C;
+      // clang-format off
       for (int start_row_c = 0; start_row_c + kColA < row_stride_c; ++start_row_c) {
         for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
           C_plus_ref.block(start_row_c, start_col_c, kColA, kColB) +=
@@ -198,6 +201,7 @@
               << "C: \n" << C_assign;
         }
       }
+      // clang-format on
     }
   }
 }
@@ -228,6 +232,7 @@
       Matrix C_plus_ref = C;
       Matrix C_minus_ref = C;
       Matrix C_assign_ref = C;
+      // clang-format off
       for (int start_row_c = 0; start_row_c + kRowA < row_stride_c; ++start_row_c) {
         for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
           C_plus_ref.block(start_row_c, start_col_c, kRowA, kColB) +=
@@ -247,7 +252,6 @@
               << "Cref : \n" << C_plus_ref << "\n"
               << "C: \n" << C_plus;
 
-
           C_minus_ref.block(start_row_c, start_col_c, kRowA, kColB) -=
               A * B;
 
@@ -283,6 +287,7 @@
               << "C: \n" << C_assign;
         }
       }
+      // clang-format on
     }
   }
 }
@@ -299,7 +304,7 @@
   B.setOnes();
 
   for (int row_stride_c = kColA; row_stride_c < 3 * kColA; ++row_stride_c) {
-    for (int col_stride_c = kColB; col_stride_c <  3 * kColB; ++col_stride_c) {
+    for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
       Matrix C(row_stride_c, col_stride_c);
       C.setOnes();
 
@@ -310,6 +315,7 @@
       Matrix C_plus_ref = C;
       Matrix C_minus_ref = C;
       Matrix C_assign_ref = C;
+      // clang-format off
       for (int start_row_c = 0; start_row_c + kColA < row_stride_c; ++start_row_c) {
         for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
           C_plus_ref.block(start_row_c, start_col_c, kColA, kColB) +=
@@ -364,6 +370,7 @@
               << "C: \n" << C_assign;
         }
       }
+      // clang-format on
     }
   }
 }
@@ -388,6 +395,7 @@
       Vector c_minus_ref = c;
       Vector c_assign_ref = c;
 
+      // clang-format off
       c_plus_ref += A * b;
       MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
           A.data(), num_rows_a, num_cols_a,
@@ -417,6 +425,7 @@
           << "c += A * b \n"
           << "c_ref : \n" << c_assign_ref << "\n"
           << "c: \n" << c_assign;
+      // clang-format on
     }
   }
 }
@@ -441,6 +450,7 @@
       Vector c_minus_ref = c;
       Vector c_assign_ref = c;
 
+      // clang-format off
       c_plus_ref += A.transpose() * b;
       MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
           A.data(), num_rows_a, num_cols_a,
@@ -470,6 +480,7 @@
           << "c += A' * b \n"
           << "c_ref : \n" << c_assign_ref << "\n"
           << "c: \n" << c_assign;
+      // clang-format on
     }
   }
 }
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 861d8d3..b7399e6 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -56,34 +56,34 @@
 namespace ceres {
 namespace {
 
+using internal::StringAppendF;
+using internal::StringPrintf;
 using std::map;
 using std::string;
 using std::vector;
-using internal::StringAppendF;
-using internal::StringPrintf;
 
-#define OPTION_OP(x, y, OP)                                             \
-  if (!(options.x OP y)) {                                              \
-    std::stringstream ss;                                               \
-    ss << "Invalid configuration. ";                                    \
-    ss << string("Solver::Options::" #x " = ") << options.x << ". ";    \
-    ss << "Violated constraint: ";                                      \
-    ss << string("Solver::Options::" #x " " #OP " "#y);                 \
-    *error = ss.str();                                                  \
-    return false;                                                       \
+#define OPTION_OP(x, y, OP)                                          \
+  if (!(options.x OP y)) {                                           \
+    std::stringstream ss;                                            \
+    ss << "Invalid configuration. ";                                 \
+    ss << string("Solver::Options::" #x " = ") << options.x << ". "; \
+    ss << "Violated constraint: ";                                   \
+    ss << string("Solver::Options::" #x " " #OP " " #y);             \
+    *error = ss.str();                                               \
+    return false;                                                    \
   }
 
-#define OPTION_OP_OPTION(x, y, OP)                                      \
-  if (!(options.x OP options.y)) {                                      \
-    std::stringstream ss;                                               \
-    ss << "Invalid configuration. ";                                    \
-    ss << string("Solver::Options::" #x " = ") << options.x << ". ";    \
-    ss << string("Solver::Options::" #y " = ") << options.y << ". ";    \
-    ss << "Violated constraint: ";                                      \
-    ss << string("Solver::Options::" #x);                               \
-    ss << string(#OP " Solver::Options::" #y ".");                      \
-    *error = ss.str();                                                  \
-    return false;                                                       \
+#define OPTION_OP_OPTION(x, y, OP)                                   \
+  if (!(options.x OP options.y)) {                                   \
+    std::stringstream ss;                                            \
+    ss << "Invalid configuration. ";                                 \
+    ss << string("Solver::Options::" #x " = ") << options.x << ". "; \
+    ss << string("Solver::Options::" #y " = ") << options.y << ". "; \
+    ss << "Violated constraint: ";                                   \
+    ss << string("Solver::Options::" #x);                            \
+    ss << string(#OP " Solver::Options::" #y ".");                   \
+    *error = ss.str();                                               \
+    return false;                                                    \
   }
 
 #define OPTION_GE(x, y) OPTION_OP(x, y, >=);
@@ -135,7 +135,8 @@
   if (options.linear_solver_type == ITERATIVE_SCHUR &&
       options.use_explicit_schur_complement &&
       options.preconditioner_type != SCHUR_JACOBI) {
-    *error =  "use_explicit_schur_complement only supports "
+    *error =
+        "use_explicit_schur_complement only supports "
         "SCHUR_JACOBI as the preconditioner.";
     return false;
   }
@@ -174,7 +175,8 @@
         *error = StringPrintf(
             "Can't use %s with "
             "Solver::Options::sparse_linear_algebra_library_type = %s.",
-            name, sparse_linear_algebra_library_name);
+            name,
+            sparse_linear_algebra_library_name);
         return false;
       } else if (!IsSparseLinearAlgebraLibraryTypeAvailable(
                      options.sparse_linear_algebra_library_type)) {
@@ -182,7 +184,8 @@
             "Can't use %s with "
             "Solver::Options::sparse_linear_algebra_library_type = %s, "
             "because support was not enabled when Ceres Solver was built.",
-            name, sparse_linear_algebra_library_name);
+            name,
+            sparse_linear_algebra_library_name);
         return false;
       }
     }
@@ -191,7 +194,8 @@
   if (options.trust_region_strategy_type == DOGLEG) {
     if (options.linear_solver_type == ITERATIVE_SCHUR ||
         options.linear_solver_type == CGNR) {
-      *error = "DOGLEG only supports exact factorization based linear "
+      *error =
+          "DOGLEG only supports exact factorization based linear "
           "solvers. If you want to use an iterative solver please "
           "use LEVENBERG_MARQUARDT as the trust_region_strategy_type";
       return false;
@@ -207,12 +211,13 @@
 
   if (options.dynamic_sparsity) {
     if (options.linear_solver_type != SPARSE_NORMAL_CHOLESKY) {
-      *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
+      *error =
+          "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
       return false;
     }
     if (options.sparse_linear_algebra_library_type == ACCELERATE_SPARSE) {
-      *error = "ACCELERATE_SPARSE is not currently supported with dynamic "
-          "sparsity.";
+      *error =
+          "ACCELERATE_SPARSE is not currently supported with dynamic sparsity.";
       return false;
     }
   }
@@ -250,10 +255,11 @@
        options.line_search_direction_type == ceres::LBFGS) &&
       options.line_search_type != ceres::WOLFE) {
     *error =
-        string("Invalid configuration: Solver::Options::line_search_type = ")
-        + string(LineSearchTypeToString(options.line_search_type))
-        + string(". When using (L)BFGS, "
-                 "Solver::Options::line_search_type must be set to WOLFE.");
+        string("Invalid configuration: Solver::Options::line_search_type = ") +
+        string(LineSearchTypeToString(options.line_search_type)) +
+        string(
+            ". When using (L)BFGS, "
+            "Solver::Options::line_search_type must be set to WOLFE.");
     return false;
   }
 
@@ -298,20 +304,24 @@
 
 void SummarizeGivenProgram(const internal::Program& program,
                            Solver::Summary* summary) {
+  // clang-format off
   summary->num_parameter_blocks     = program.NumParameterBlocks();
   summary->num_parameters           = program.NumParameters();
   summary->num_effective_parameters = program.NumEffectiveParameters();
   summary->num_residual_blocks      = program.NumResidualBlocks();
   summary->num_residuals            = program.NumResiduals();
+  // clang-format on
 }
 
 void SummarizeReducedProgram(const internal::Program& program,
                              Solver::Summary* summary) {
+  // clang-format off
   summary->num_parameter_blocks_reduced     = program.NumParameterBlocks();
   summary->num_parameters_reduced           = program.NumParameters();
   summary->num_effective_parameters_reduced = program.NumEffectiveParameters();
   summary->num_residual_blocks_reduced      = program.NumResidualBlocks();
   summary->num_residuals_reduced            = program.NumResiduals();
+  // clang-format on
 }
 
 void PreSolveSummarize(const Solver::Options& options,
@@ -323,6 +333,7 @@
   internal::OrderingToGroupSizes(options.inner_iteration_ordering.get(),
                                  &(summary->inner_iteration_ordering_given));
 
+  // clang-format off
   summary->dense_linear_algebra_library_type  = options.dense_linear_algebra_library_type;  //  NOLINT
   summary->dogleg_type                        = options.dogleg_type;
   summary->inner_iteration_time_in_seconds    = 0.0;
@@ -344,6 +355,7 @@
   summary->sparse_linear_algebra_library_type = options.sparse_linear_algebra_library_type; //  NOLINT
   summary->trust_region_strategy_type         = options.trust_region_strategy_type;         //  NOLINT
   summary->visibility_clustering_type         = options.visibility_clustering_type;         //  NOLINT
+  // clang-format on
 }
 
 void PostSolveSummarize(const internal::PreprocessedProblem& pp,
@@ -353,10 +365,12 @@
   internal::OrderingToGroupSizes(pp.options.inner_iteration_ordering.get(),
                                  &(summary->inner_iteration_ordering_used));
 
+  // clang-format off
   summary->inner_iterations_used          = pp.inner_iteration_minimizer.get() != NULL;     // NOLINT
   summary->linear_solver_type_used        = pp.linear_solver_options.type;
   summary->num_threads_used               = pp.options.num_threads;
   summary->preconditioner_type_used       = pp.options.preconditioner_type;
+  // clang-format on
 
   internal::SetSummaryFinalCost(summary);
 
@@ -402,14 +416,14 @@
   }
 }
 
-void Minimize(internal::PreprocessedProblem* pp,
-              Solver::Summary* summary) {
-  using internal::Program;
+void Minimize(internal::PreprocessedProblem* pp, Solver::Summary* summary) {
   using internal::Minimizer;
+  using internal::Program;
 
   Program* program = pp->reduced_program.get();
   if (pp->reduced_program->NumParameterBlocks() == 0) {
-    summary->message = "Function tolerance reached. "
+    summary->message =
+        "Function tolerance reached. "
         "No non-constant parameter blocks found.";
     summary->termination_type = CONVERGENCE;
     VLOG_IF(1, pp->options.logging_type != SILENT) << summary->message;
@@ -421,31 +435,29 @@
   const Vector original_reduced_parameters = pp->reduced_parameters;
   std::unique_ptr<Minimizer> minimizer(
       Minimizer::Create(pp->options.minimizer_type));
-  minimizer->Minimize(pp->minimizer_options,
-                      pp->reduced_parameters.data(),
-                      summary);
+  minimizer->Minimize(
+      pp->minimizer_options, pp->reduced_parameters.data(), summary);
 
   program->StateVectorToParameterBlocks(
-      summary->IsSolutionUsable()
-      ? pp->reduced_parameters.data()
-      : original_reduced_parameters.data());
+      summary->IsSolutionUsable() ? pp->reduced_parameters.data()
+                                  : original_reduced_parameters.data());
   program->CopyParameterBlockStateToUserState();
 }
 
 std::string SchurStructureToString(const int row_block_size,
                                    const int e_block_size,
                                    const int f_block_size) {
-  const std::string row =
-      (row_block_size == Eigen::Dynamic)
-      ? "d" : internal::StringPrintf("%d", row_block_size);
+  const std::string row = (row_block_size == Eigen::Dynamic)
+                              ? "d"
+                              : internal::StringPrintf("%d", row_block_size);
 
-  const std::string e =
-      (e_block_size == Eigen::Dynamic)
-      ? "d" : internal::StringPrintf("%d", e_block_size);
+  const std::string e = (e_block_size == Eigen::Dynamic)
+                            ? "d"
+                            : internal::StringPrintf("%d", e_block_size);
 
-  const std::string f =
-      (f_block_size == Eigen::Dynamic)
-      ? "d" : internal::StringPrintf("%d", f_block_size);
+  const std::string f = (f_block_size == Eigen::Dynamic)
+                            ? "d"
+                            : internal::StringPrintf("%d", f_block_size);
 
   return internal::StringPrintf("%s,%s,%s", row.c_str(), e.c_str(), f.c_str());
 }
@@ -503,12 +515,11 @@
   Solver::Options modified_options = options;
   if (options.check_gradients) {
     modified_options.callbacks.push_back(&gradient_checking_callback);
-    gradient_checking_problem.reset(
-        CreateGradientCheckingProblemImpl(
-            problem_impl,
-            options.gradient_check_numeric_derivative_relative_step_size,
-            options.gradient_check_relative_precision,
-            &gradient_checking_callback));
+    gradient_checking_problem.reset(CreateGradientCheckingProblemImpl(
+        problem_impl,
+        options.gradient_check_numeric_derivative_relative_step_size,
+        options.gradient_check_relative_precision,
+        &gradient_checking_callback));
     problem_impl = gradient_checking_problem.get();
     program = problem_impl->mutable_program();
   }
@@ -524,7 +535,8 @@
       Preprocessor::Create(modified_options.minimizer_type));
   PreprocessedProblem pp;
 
-  const bool status = preprocessor->Preprocess(modified_options, problem_impl, &pp);
+  const bool status =
+      preprocessor->Preprocess(modified_options, problem_impl, &pp);
 
   // We check the linear_solver_options.type rather than
   // modified_options.linear_solver_type because, depending on the
@@ -538,17 +550,16 @@
     int e_block_size;
     int f_block_size;
     DetectStructure(*static_cast<internal::BlockSparseMatrix*>(
-                        pp.minimizer_options.jacobian.get())
-                    ->block_structure(),
+                         pp.minimizer_options.jacobian.get())
+                         ->block_structure(),
                     pp.linear_solver_options.elimination_groups[0],
                     &row_block_size,
                     &e_block_size,
                     &f_block_size);
     summary->schur_structure_given =
         SchurStructureToString(row_block_size, e_block_size, f_block_size);
-    internal::GetBestSchurTemplateSpecialization(&row_block_size,
-                                                 &e_block_size,
-                                                 &f_block_size);
+    internal::GetBestSchurTemplateSpecialization(
+        &row_block_size, &e_block_size, &f_block_size);
     summary->schur_structure_used =
         SchurStructureToString(row_block_size, e_block_size, f_block_size);
   }
@@ -595,15 +606,16 @@
 }
 
 string Solver::Summary::BriefReport() const {
-  return StringPrintf("Ceres Solver Report: "
-                      "Iterations: %d, "
-                      "Initial cost: %e, "
-                      "Final cost: %e, "
-                      "Termination: %s",
-                      num_successful_steps + num_unsuccessful_steps,
-                      initial_cost,
-                      final_cost,
-                      TerminationTypeToString(termination_type));
+  return StringPrintf(
+      "Ceres Solver Report: "
+      "Iterations: %d, "
+      "Initial cost: %e, "
+      "Final cost: %e, "
+      "Termination: %s",
+      num_successful_steps + num_unsuccessful_steps,
+      initial_cost,
+      final_cost,
+      TerminationTypeToString(termination_type));
 }
 
 string Solver::Summary::FullReport() const {
@@ -612,28 +624,39 @@
   string report = string("\nSolver Summary (v " + VersionString() + ")\n\n");
 
   StringAppendF(&report, "%45s    %21s\n", "Original", "Reduced");
-  StringAppendF(&report, "Parameter blocks    % 25d% 25d\n",
-                num_parameter_blocks, num_parameter_blocks_reduced);
-  StringAppendF(&report, "Parameters          % 25d% 25d\n",
-                num_parameters, num_parameters_reduced);
+  StringAppendF(&report,
+                "Parameter blocks    % 25d% 25d\n",
+                num_parameter_blocks,
+                num_parameter_blocks_reduced);
+  StringAppendF(&report,
+                "Parameters          % 25d% 25d\n",
+                num_parameters,
+                num_parameters_reduced);
   if (num_effective_parameters_reduced != num_parameters_reduced) {
-    StringAppendF(&report, "Effective parameters% 25d% 25d\n",
-                  num_effective_parameters, num_effective_parameters_reduced);
+    StringAppendF(&report,
+                  "Effective parameters% 25d% 25d\n",
+                  num_effective_parameters,
+                  num_effective_parameters_reduced);
   }
-  StringAppendF(&report, "Residual blocks     % 25d% 25d\n",
-                num_residual_blocks, num_residual_blocks_reduced);
-  StringAppendF(&report, "Residuals           % 25d% 25d\n",
-                num_residuals, num_residuals_reduced);
+  StringAppendF(&report,
+                "Residual blocks     % 25d% 25d\n",
+                num_residual_blocks,
+                num_residual_blocks_reduced);
+  StringAppendF(&report,
+                "Residuals           % 25d% 25d\n",
+                num_residuals,
+                num_residuals_reduced);
 
   if (minimizer_type == TRUST_REGION) {
     // TRUST_SEARCH HEADER
-    StringAppendF(&report, "\nMinimizer                 %19s\n",
-                  "TRUST_REGION");
+    StringAppendF(
+        &report, "\nMinimizer                 %19s\n", "TRUST_REGION");
 
     if (linear_solver_type_used == DENSE_NORMAL_CHOLESKY ||
         linear_solver_type_used == DENSE_SCHUR ||
         linear_solver_type_used == DENSE_QR) {
-      StringAppendF(&report, "\nDense linear algebra library  %15s\n",
+      StringAppendF(&report,
+                    "\nDense linear algebra library  %15s\n",
                     DenseLinearAlgebraLibraryTypeToString(
                         dense_linear_algebra_library_type));
     }
@@ -643,14 +666,15 @@
         (linear_solver_type_used == ITERATIVE_SCHUR &&
          (preconditioner_type_used == CLUSTER_JACOBI ||
           preconditioner_type_used == CLUSTER_TRIDIAGONAL))) {
-      StringAppendF(&report, "\nSparse linear algebra library %15s\n",
+      StringAppendF(&report,
+                    "\nSparse linear algebra library %15s\n",
                     SparseLinearAlgebraLibraryTypeToString(
                         sparse_linear_algebra_library_type));
     }
 
-    StringAppendF(&report, "Trust region strategy     %19s",
-                  TrustRegionStrategyTypeToString(
-                      trust_region_strategy_type));
+    StringAppendF(&report,
+                  "Trust region strategy     %19s",
+                  TrustRegionStrategyTypeToString(trust_region_strategy_type));
     if (trust_region_strategy_type == DOGLEG) {
       if (dogleg_type == TRADITIONAL_DOGLEG) {
         StringAppendF(&report, " (TRADITIONAL)");
@@ -661,28 +685,32 @@
     StringAppendF(&report, "\n");
     StringAppendF(&report, "\n");
 
-    StringAppendF(&report, "%45s    %21s\n", "Given",  "Used");
-    StringAppendF(&report, "Linear solver       %25s%25s\n",
+    StringAppendF(&report, "%45s    %21s\n", "Given", "Used");
+    StringAppendF(&report,
+                  "Linear solver       %25s%25s\n",
                   LinearSolverTypeToString(linear_solver_type_given),
                   LinearSolverTypeToString(linear_solver_type_used));
 
     if (linear_solver_type_given == CGNR ||
         linear_solver_type_given == ITERATIVE_SCHUR) {
-      StringAppendF(&report, "Preconditioner      %25s%25s\n",
+      StringAppendF(&report,
+                    "Preconditioner      %25s%25s\n",
                     PreconditionerTypeToString(preconditioner_type_given),
                     PreconditionerTypeToString(preconditioner_type_used));
     }
 
     if (preconditioner_type_used == CLUSTER_JACOBI ||
         preconditioner_type_used == CLUSTER_TRIDIAGONAL) {
-      StringAppendF(&report, "Visibility clustering%24s%25s\n",
-                    VisibilityClusteringTypeToString(
-                        visibility_clustering_type),
-                    VisibilityClusteringTypeToString(
-                        visibility_clustering_type));
+      StringAppendF(
+          &report,
+          "Visibility clustering%24s%25s\n",
+          VisibilityClusteringTypeToString(visibility_clustering_type),
+          VisibilityClusteringTypeToString(visibility_clustering_type));
     }
-    StringAppendF(&report, "Threads             % 25d% 25d\n",
-                  num_threads_given, num_threads_used);
+    StringAppendF(&report,
+                  "Threads             % 25d% 25d\n",
+                  num_threads_given,
+                  num_threads_used);
 
     string given;
     StringifyOrdering(linear_solver_ordering_given, &given);
@@ -711,68 +739,71 @@
       StringifyOrdering(inner_iteration_ordering_given, &given);
       string used;
       StringifyOrdering(inner_iteration_ordering_used, &used);
-    StringAppendF(&report,
-                  "Inner iteration ordering %20s %24s\n",
-                  given.c_str(),
-                  used.c_str());
+      StringAppendF(&report,
+                    "Inner iteration ordering %20s %24s\n",
+                    given.c_str(),
+                    used.c_str());
     }
   } else {
     // LINE_SEARCH HEADER
     StringAppendF(&report, "\nMinimizer                 %19s\n", "LINE_SEARCH");
 
-
     string line_search_direction_string;
     if (line_search_direction_type == LBFGS) {
       line_search_direction_string = StringPrintf("LBFGS (%d)", max_lbfgs_rank);
     } else if (line_search_direction_type == NONLINEAR_CONJUGATE_GRADIENT) {
-      line_search_direction_string =
-          NonlinearConjugateGradientTypeToString(
-              nonlinear_conjugate_gradient_type);
+      line_search_direction_string = NonlinearConjugateGradientTypeToString(
+          nonlinear_conjugate_gradient_type);
     } else {
       line_search_direction_string =
           LineSearchDirectionTypeToString(line_search_direction_type);
     }
 
-    StringAppendF(&report, "Line search direction     %19s\n",
+    StringAppendF(&report,
+                  "Line search direction     %19s\n",
                   line_search_direction_string.c_str());
 
-    const string line_search_type_string =
-        StringPrintf("%s %s",
-                     LineSearchInterpolationTypeToString(
-                         line_search_interpolation_type),
-                     LineSearchTypeToString(line_search_type));
-    StringAppendF(&report, "Line search type          %19s\n",
+    const string line_search_type_string = StringPrintf(
+        "%s %s",
+        LineSearchInterpolationTypeToString(line_search_interpolation_type),
+        LineSearchTypeToString(line_search_type));
+    StringAppendF(&report,
+                  "Line search type          %19s\n",
                   line_search_type_string.c_str());
     StringAppendF(&report, "\n");
 
-    StringAppendF(&report, "%45s    %21s\n", "Given",  "Used");
-    StringAppendF(&report, "Threads             % 25d% 25d\n",
-                  num_threads_given, num_threads_used);
+    StringAppendF(&report, "%45s    %21s\n", "Given", "Used");
+    StringAppendF(&report,
+                  "Threads             % 25d% 25d\n",
+                  num_threads_given,
+                  num_threads_used);
   }
 
   StringAppendF(&report, "\nCost:\n");
   StringAppendF(&report, "Initial        % 30e\n", initial_cost);
-  if (termination_type != FAILURE &&
-      termination_type != USER_FAILURE) {
+  if (termination_type != FAILURE && termination_type != USER_FAILURE) {
     StringAppendF(&report, "Final          % 30e\n", final_cost);
-    StringAppendF(&report, "Change         % 30e\n",
-                  initial_cost - final_cost);
+    StringAppendF(&report, "Change         % 30e\n", initial_cost - final_cost);
   }
 
-  StringAppendF(&report, "\nMinimizer iterations         % 16d\n",
+  StringAppendF(&report,
+                "\nMinimizer iterations         % 16d\n",
                 num_successful_steps + num_unsuccessful_steps);
 
   // Successful/Unsuccessful steps only matter in the case of the
   // trust region solver. Line search terminates when it encounters
   // the first unsuccessful step.
   if (minimizer_type == TRUST_REGION) {
-    StringAppendF(&report, "Successful steps               % 14d\n",
+    StringAppendF(&report,
+                  "Successful steps               % 14d\n",
                   num_successful_steps);
-    StringAppendF(&report, "Unsuccessful steps             % 14d\n",
+    StringAppendF(&report,
+                  "Unsuccessful steps             % 14d\n",
                   num_unsuccessful_steps);
   }
   if (inner_iterations_used) {
-    StringAppendF(&report, "Steps with inner iterations    % 14d\n",
+    StringAppendF(&report,
+                  "Steps with inner iterations    % 14d\n",
                   num_inner_iteration_steps);
   }
 
@@ -781,53 +812,66 @@
        (minimizer_type == TRUST_REGION && is_constrained));
 
   if (line_search_used) {
-    StringAppendF(&report, "Line search steps              % 14d\n",
+    StringAppendF(&report,
+                  "Line search steps              % 14d\n",
                   num_line_search_steps);
   }
 
   StringAppendF(&report, "\nTime (in seconds):\n");
-  StringAppendF(&report, "Preprocessor        %25.6f\n",
-                preprocessor_time_in_seconds);
+  StringAppendF(
+      &report, "Preprocessor        %25.6f\n", preprocessor_time_in_seconds);
 
-  StringAppendF(&report, "\n  Residual only evaluation %18.6f (%d)\n",
-                residual_evaluation_time_in_seconds, num_residual_evaluations);
+  StringAppendF(&report,
+                "\n  Residual only evaluation %18.6f (%d)\n",
+                residual_evaluation_time_in_seconds,
+                num_residual_evaluations);
   if (line_search_used) {
-    StringAppendF(&report, "    Line search cost evaluation    %10.6f\n",
+    StringAppendF(&report,
+                  "    Line search cost evaluation    %10.6f\n",
                   line_search_cost_evaluation_time_in_seconds);
   }
-  StringAppendF(&report, "  Jacobian & residual evaluation %12.6f (%d)\n",
-                jacobian_evaluation_time_in_seconds, num_jacobian_evaluations);
+  StringAppendF(&report,
+                "  Jacobian & residual evaluation %12.6f (%d)\n",
+                jacobian_evaluation_time_in_seconds,
+                num_jacobian_evaluations);
   if (line_search_used) {
-    StringAppendF(&report, "    Line search gradient evaluation   %6.6f\n",
+    StringAppendF(&report,
+                  "    Line search gradient evaluation   %6.6f\n",
                   line_search_gradient_evaluation_time_in_seconds);
   }
 
   if (minimizer_type == TRUST_REGION) {
-    StringAppendF(&report, "  Linear solver       %23.6f (%d)\n",
-                  linear_solver_time_in_seconds, num_linear_solves);
+    StringAppendF(&report,
+                  "  Linear solver       %23.6f (%d)\n",
+                  linear_solver_time_in_seconds,
+                  num_linear_solves);
   }
 
   if (inner_iterations_used) {
-    StringAppendF(&report, "  Inner iterations    %23.6f\n",
+    StringAppendF(&report,
+                  "  Inner iterations    %23.6f\n",
                   inner_iteration_time_in_seconds);
   }
 
   if (line_search_used) {
-    StringAppendF(&report, "  Line search polynomial minimization  %.6f\n",
+    StringAppendF(&report,
+                  "  Line search polynomial minimization  %.6f\n",
                   line_search_polynomial_minimization_time_in_seconds);
   }
 
-  StringAppendF(&report, "Minimizer           %25.6f\n\n",
-                minimizer_time_in_seconds);
+  StringAppendF(
+      &report, "Minimizer           %25.6f\n\n", minimizer_time_in_seconds);
 
-  StringAppendF(&report, "Postprocessor        %24.6f\n",
-                postprocessor_time_in_seconds);
+  StringAppendF(
+      &report, "Postprocessor        %24.6f\n", postprocessor_time_in_seconds);
 
-  StringAppendF(&report, "Total               %25.6f\n\n",
-                total_time_in_seconds);
+  StringAppendF(
+      &report, "Total               %25.6f\n\n", total_time_in_seconds);
 
-  StringAppendF(&report, "Termination:        %25s (%s)\n",
-                TerminationTypeToString(termination_type), message.c_str());
+  StringAppendF(&report,
+                "Termination:        %25s (%s)\n",
+                TerminationTypeToString(termination_type),
+                message.c_str());
   return report;
 }
 
diff --git a/internal/ceres/solver_utils.cc b/internal/ceres/solver_utils.cc
index 177a928..b6faa2a 100644
--- a/internal/ceres/solver_utils.cc
+++ b/internal/ceres/solver_utils.cc
@@ -28,22 +28,22 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/solver_utils.h"
+
 #include <string>
 
-#include "ceres/internal/config.h"
-
 #include "Eigen/Core"
+#include "ceres/internal/config.h"
 #include "ceres/internal/port.h"
-#include "ceres/solver_utils.h"
 #include "ceres/version.h"
 
 namespace ceres {
 namespace internal {
 
-#define CERES_EIGEN_VERSION                                          \
-  CERES_TO_STRING(EIGEN_WORLD_VERSION) "."                           \
-  CERES_TO_STRING(EIGEN_MAJOR_VERSION) "."                           \
-  CERES_TO_STRING(EIGEN_MINOR_VERSION)
+#define CERES_EIGEN_VERSION                                     \
+  CERES_TO_STRING(EIGEN_WORLD_VERSION)                          \
+  "." CERES_TO_STRING(EIGEN_MAJOR_VERSION) "." CERES_TO_STRING( \
+      EIGEN_MINOR_VERSION)
 
 std::string VersionString() {
   std::string value = std::string(CERES_VERSION_STRING);
diff --git a/internal/ceres/sparse_cholesky.cc b/internal/ceres/sparse_cholesky.cc
index 0639ea9..91cdf67 100644
--- a/internal/ceres/sparse_cholesky.cc
+++ b/internal/ceres/sparse_cholesky.cc
@@ -89,7 +89,8 @@
       if (options.use_mixed_precision_solves) {
         sparse_cholesky = AppleAccelerateCholesky<float>::Create(ordering_type);
       } else {
-        sparse_cholesky = AppleAccelerateCholesky<double>::Create(ordering_type);
+        sparse_cholesky =
+            AppleAccelerateCholesky<double>::Create(ordering_type);
       }
       break;
 #else
diff --git a/internal/ceres/sparse_cholesky.h b/internal/ceres/sparse_cholesky.h
index bbe4237..9be98bd 100644
--- a/internal/ceres/sparse_cholesky.h
+++ b/internal/ceres/sparse_cholesky.h
@@ -32,9 +32,12 @@
 #define CERES_INTERNAL_SPARSE_CHOLESKY_H_
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
 
 #include <memory>
+
 #include "ceres/linear_solver.h"
 #include "glog/logging.h"
 
@@ -88,8 +91,8 @@
   // Subsequent calls to Factorize will use that symbolic
   // factorization assuming that the sparsity of the matrix has
   // remained constant.
-  virtual LinearSolverTerminationType Factorize(
-      CompressedRowSparseMatrix* lhs, std::string* message) = 0;
+  virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+                                                std::string* message) = 0;
 
   // Computes the solution to the equation
   //
@@ -106,7 +109,6 @@
       const double* rhs,
       double* solution,
       std::string* message);
-
 };
 
 class IterativeRefiner;
@@ -120,8 +122,8 @@
   virtual ~RefinedSparseCholesky();
 
   virtual CompressedRowSparseMatrix::StorageType StorageType() const;
-  virtual LinearSolverTerminationType Factorize(
-      CompressedRowSparseMatrix* lhs, std::string* message);
+  virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+                                                std::string* message);
   virtual LinearSolverTerminationType Solve(const double* rhs,
                                             double* solution,
                                             std::string* message);
diff --git a/internal/ceres/sparse_matrix.cc b/internal/ceres/sparse_matrix.cc
index f95ff32..32388f5 100644
--- a/internal/ceres/sparse_matrix.cc
+++ b/internal/ceres/sparse_matrix.cc
@@ -33,8 +33,7 @@
 namespace ceres {
 namespace internal {
 
-SparseMatrix::~SparseMatrix() {
-}
+SparseMatrix::~SparseMatrix() {}
 
 }  // namespace internal
 }  // namespace ceres
diff --git a/internal/ceres/sparse_matrix.h b/internal/ceres/sparse_matrix.h
index 074d847..b8a3918 100644
--- a/internal/ceres/sparse_matrix.h
+++ b/internal/ceres/sparse_matrix.h
@@ -34,8 +34,9 @@
 #define CERES_INTERNAL_SPARSE_MATRIX_H_
 
 #include <cstdio>
-#include "ceres/linear_operator.h"
+
 #include "ceres/internal/eigen.h"
+#include "ceres/linear_operator.h"
 #include "ceres/types.h"
 
 namespace ceres {
diff --git a/internal/ceres/sparse_normal_cholesky_solver.h b/internal/ceres/sparse_normal_cholesky_solver.h
index cbff2bd..ef32743 100644
--- a/internal/ceres/sparse_normal_cholesky_solver.h
+++ b/internal/ceres/sparse_normal_cholesky_solver.h
@@ -35,9 +35,12 @@
 #define CERES_INTERNAL_SPARSE_NORMAL_CHOLESKY_SOLVER_H_
 
 // This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
 #include "ceres/internal/port.h"
+// clang-format on
 
 #include <vector>
+
 #include "ceres/linear_solver.h"
 
 namespace ceres {
@@ -58,11 +61,10 @@
   virtual ~SparseNormalCholeskySolver();
 
  private:
-  LinearSolver::Summary SolveImpl(
-      BlockSparseMatrix* A,
-      const double* b,
-      const LinearSolver::PerSolveOptions& options,
-      double* x) final;
+  LinearSolver::Summary SolveImpl(BlockSparseMatrix* A,
+                                  const double* b,
+                                  const LinearSolver::PerSolveOptions& options,
+                                  double* x) final;
 
   const LinearSolver::Options options_;
   Vector rhs_;
diff --git a/internal/ceres/sparse_normal_cholesky_solver_test.cc b/internal/ceres/sparse_normal_cholesky_solver_test.cc
index 10f898b..8acb98e 100644
--- a/internal/ceres/sparse_normal_cholesky_solver_test.cc
+++ b/internal/ceres/sparse_normal_cholesky_solver_test.cc
@@ -29,6 +29,8 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
 #include <memory>
+
+#include "Eigen/Cholesky"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/casts.h"
 #include "ceres/context_impl.h"
@@ -39,8 +41,6 @@
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
-#include "Eigen/Cholesky"
-
 namespace ceres {
 namespace internal {
 
diff --git a/internal/ceres/split.cc b/internal/ceres/split.cc
index 3a09e86..804f441 100644
--- a/internal/ceres/split.cc
+++ b/internal/ceres/split.cc
@@ -75,10 +75,9 @@
 }
 
 template <typename StringType, typename ITR>
-static inline
-void SplitStringToIteratorUsing(const StringType& full,
-                                const char* delim,
-                                ITR& result) {
+static inline void SplitStringToIteratorUsing(const StringType& full,
+                                              const char* delim,
+                                              ITR& result) {
   // Optimize the common case where delim is a single character.
   if (delim[0] != '\0' && delim[1] == '\0') {
     char c = delim[0];
diff --git a/internal/ceres/split.h b/internal/ceres/split.h
index 94b773d..f513023 100644
--- a/internal/ceres/split.h
+++ b/internal/ceres/split.h
@@ -33,6 +33,7 @@
 
 #include <string>
 #include <vector>
+
 #include "ceres/internal/port.h"
 
 namespace ceres {
@@ -41,7 +42,8 @@
 // Split a string using one or more character delimiters, presented as a
 // nul-terminated c string. Append the components to 'result'. If there are
 // consecutive delimiters, this function skips over all of them.
-void SplitStringUsing(const std::string& full, const char* delim,
+void SplitStringUsing(const std::string& full,
+                      const char* delim,
                       std::vector<std::string>* res);
 
 }  // namespace internal
diff --git a/internal/ceres/stl_util.h b/internal/ceres/stl_util.h
index 0595a4c..d3411b7 100644
--- a/internal/ceres/stl_util.h
+++ b/internal/ceres/stl_util.h
@@ -46,8 +46,7 @@
 // advanced, which could result in the hash function trying to deference a
 // stale pointer.
 template <class ForwardIterator>
-void STLDeleteContainerPointers(ForwardIterator begin,
-                                ForwardIterator end) {
+void STLDeleteContainerPointers(ForwardIterator begin, ForwardIterator end) {
   while (begin != end) {
     ForwardIterator temp = begin;
     ++begin;
@@ -80,7 +79,7 @@
 // ElementDeleter (defined below), which ensures that your container's elements
 // are deleted when the ElementDeleter goes out of scope.
 template <class T>
-void STLDeleteElements(T *container) {
+void STLDeleteElements(T* container) {
   if (!container) return;
   STLDeleteContainerPointers(container->begin(), container->end());
   container->clear();
diff --git a/internal/ceres/stringprintf.cc b/internal/ceres/stringprintf.cc
index 7a21f0e..b0e2acc 100644
--- a/internal/ceres/stringprintf.cc
+++ b/internal/ceres/stringprintf.cc
@@ -62,7 +62,7 @@
       return;
     }
 
-#if defined (_MSC_VER)
+#if defined(_MSC_VER)
     // Error or MSVC running out of space.  MSVC 8.0 and higher
     // can be asked about space needed with the special idiom below:
     va_copy(backup_ap, ap);
@@ -78,7 +78,7 @@
 
   // Increase the buffer size to the size requested by vsnprintf,
   // plus one for the closing \0.
-  int length = result+1;
+  int length = result + 1;
   char* buf = new char[length];
 
   // Restore the va_list before we use it again
@@ -93,7 +93,6 @@
   delete[] buf;
 }
 
-
 string StringPrintf(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
diff --git a/internal/ceres/stringprintf.h b/internal/ceres/stringprintf.h
index feeb9c2..98e98cd 100644
--- a/internal/ceres/stringprintf.h
+++ b/internal/ceres/stringprintf.h
@@ -55,9 +55,9 @@
 // have an implicit 'this' argument, the arguments of such methods
 // should be counted from two, not one."
 #define CERES_PRINTF_ATTRIBUTE(string_index, first_to_check) \
-    __attribute__((__format__ (__printf__, string_index, first_to_check)))
+  __attribute__((__format__(__printf__, string_index, first_to_check)))
 #define CERES_SCANF_ATTRIBUTE(string_index, first_to_check) \
-    __attribute__((__format__ (__scanf__, string_index, first_to_check)))
+  __attribute__((__format__(__scanf__, string_index, first_to_check)))
 #else
 #define CERES_PRINTF_ATTRIBUTE(string_index, first_to_check)
 #endif
@@ -68,7 +68,9 @@
     CERES_PRINTF_ATTRIBUTE(1, 2);
 
 // Store result into a supplied string and return it.
-extern const std::string& SStringPrintf(std::string* dst, const char* format, ...)
+extern const std::string& SStringPrintf(std::string* dst,
+                                        const char* format,
+                                        ...)
     // Tell the compiler to do printf format string checking.
     CERES_PRINTF_ATTRIBUTE(2, 3);
 
diff --git a/internal/ceres/subset_preconditioner.cc b/internal/ceres/subset_preconditioner.cc
index 7c24ae9..779a34a 100644
--- a/internal/ceres/subset_preconditioner.cc
+++ b/internal/ceres/subset_preconditioner.cc
@@ -32,6 +32,7 @@
 
 #include <memory>
 #include <string>
+
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/inner_product_computer.h"
 #include "ceres/linear_solver.h"
@@ -50,8 +51,7 @@
   LinearSolver::Options sparse_cholesky_options;
   sparse_cholesky_options.sparse_linear_algebra_library_type =
       options_.sparse_linear_algebra_library_type;
-  sparse_cholesky_options.use_postordering =
-      options_.use_postordering;
+  sparse_cholesky_options.use_postordering = options_.use_postordering;
   sparse_cholesky_ = SparseCholesky::Create(sparse_cholesky_options);
 }
 
diff --git a/internal/ceres/subset_preconditioner.h b/internal/ceres/subset_preconditioner.h
index 6f3c9ec..f83153c 100644
--- a/internal/ceres/subset_preconditioner.h
+++ b/internal/ceres/subset_preconditioner.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_SUBSET_PRECONDITIONER_H_
 
 #include <memory>
+
 #include "ceres/preconditioner.h"
 
 namespace ceres {
diff --git a/internal/ceres/subset_preconditioner_test.cc b/internal/ceres/subset_preconditioner_test.cc
index ec0ea9a..202110b 100644
--- a/internal/ceres/subset_preconditioner_test.cc
+++ b/internal/ceres/subset_preconditioner_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/subset_preconditioner.h"
 
 #include <memory>
+
 #include "Eigen/Dense"
 #include "Eigen/SparseCore"
 #include "ceres/block_sparse_matrix.h"
diff --git a/internal/ceres/suitesparse.cc b/internal/ceres/suitesparse.cc
index 190d175..0d6f6bd 100644
--- a/internal/ceres/suitesparse.cc
+++ b/internal/ceres/suitesparse.cc
@@ -32,13 +32,12 @@
 #include "ceres/internal/port.h"
 
 #ifndef CERES_NO_SUITESPARSE
-#include "ceres/suitesparse.h"
-
 #include <vector>
 
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/linear_solver.h"
+#include "ceres/suitesparse.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "cholmod.h"
 
@@ -353,7 +352,8 @@
 
 std::unique_ptr<SparseCholesky> SuiteSparseCholesky::Create(
     const OrderingType ordering_type) {
-  return std::unique_ptr<SparseCholesky>(new SuiteSparseCholesky(ordering_type));
+  return std::unique_ptr<SparseCholesky>(
+      new SuiteSparseCholesky(ordering_type));
 }
 
 SuiteSparseCholesky::SuiteSparseCholesky(const OrderingType ordering_type)
diff --git a/internal/ceres/suitesparse.h b/internal/ceres/suitesparse.h
index b77b296..5dcc53f 100644
--- a/internal/ceres/suitesparse.h
+++ b/internal/ceres/suitesparse.h
@@ -41,6 +41,7 @@
 #include <cstring>
 #include <string>
 #include <vector>
+
 #include "SuiteSparseQR.hpp"
 #include "ceres/linear_solver.h"
 #include "ceres/sparse_cholesky.h"
@@ -116,20 +117,23 @@
   // for symmetric scaling which scales both the rows and the columns
   // - diag(scale) * A * diag(scale).
   void Scale(cholmod_dense* scale, int mode, cholmod_sparse* A) {
-     cholmod_scale(scale, mode, A, &cc_);
+    cholmod_scale(scale, mode, A, &cc_);
   }
 
   // Create and return a matrix m = A * A'. Caller owns the
   // result. The matrix A is not modified.
   cholmod_sparse* AATranspose(cholmod_sparse* A) {
-    cholmod_sparse*m =  cholmod_aat(A, NULL, A->nrow, 1, &cc_);
+    cholmod_sparse* m = cholmod_aat(A, NULL, A->nrow, 1, &cc_);
     m->stype = 1;  // Pay attention to the upper triangular part.
     return m;
   }
 
   // y = alpha * A * x + beta * y. Only y is modified.
-  void SparseDenseMultiply(cholmod_sparse* A, double alpha, double beta,
-                           cholmod_dense* x, cholmod_dense* y) {
+  void SparseDenseMultiply(cholmod_sparse* A,
+                           double alpha,
+                           double beta,
+                           cholmod_dense* x,
+                           cholmod_dense* y) {
     double alpha_[2] = {alpha, 0};
     double beta_[2] = {beta, 0};
     cholmod_sdmult(A, 0, alpha_, beta_, x, y, &cc_);
@@ -195,7 +199,9 @@
   // NULL is returned. Caller owns the result.
   //
   // message contains an explanation of the failures if any.
-  cholmod_dense* Solve(cholmod_factor* L, cholmod_dense* b, std::string* message);
+  cholmod_dense* Solve(cholmod_factor* L,
+                       cholmod_dense* b,
+                       std::string* message);
 
   // By virtue of the modeling layer in Ceres being block oriented,
   // all the matrices used by Ceres are also block oriented. When
@@ -229,7 +235,6 @@
   // ordering.
   bool ApproximateMinimumDegreeOrdering(cholmod_sparse* matrix, int* ordering);
 
-
   // Before SuiteSparse version 4.2.0, cholmod_camd was only enabled
   // if SuiteSparse was compiled with Metis support. This makes
   // calling and linking into cholmod_camd problematic even though it
@@ -262,7 +267,7 @@
                                                    int* ordering);
 
   void Free(cholmod_sparse* m) { cholmod_free_sparse(&m, &cc_); }
-  void Free(cholmod_dense* m)  { cholmod_free_dense(&m, &cc_);  }
+  void Free(cholmod_dense* m) { cholmod_free_dense(&m, &cc_); }
   void Free(cholmod_factor* m) { cholmod_free_factor(&m, &cc_); }
 
   void Print(cholmod_sparse* m, const std::string& name) {
@@ -285,17 +290,17 @@
 
 class SuiteSparseCholesky : public SparseCholesky {
  public:
-  static std::unique_ptr<SparseCholesky> Create(
-      OrderingType ordering_type);
+  static std::unique_ptr<SparseCholesky> Create(OrderingType ordering_type);
 
   // SparseCholesky interface.
   virtual ~SuiteSparseCholesky();
   CompressedRowSparseMatrix::StorageType StorageType() const final;
-  LinearSolverTerminationType Factorize(
-      CompressedRowSparseMatrix* lhs, std::string* message) final;
+  LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+                                        std::string* message) final;
   LinearSolverTerminationType Solve(const double* rhs,
                                     double* solution,
                                     std::string* message) final;
+
  private:
   SuiteSparseCholesky(const OrderingType ordering_type);
 
diff --git a/internal/ceres/system_test.cc b/internal/ceres/system_test.cc
index 3f635d0..429973f 100644
--- a/internal/ceres/system_test.cc
+++ b/internal/ceres/system_test.cc
@@ -64,10 +64,10 @@
 class PowellsFunction {
  public:
   PowellsFunction() {
-    x_[0] =  3.0;
+    x_[0] = 3.0;
     x_[1] = -1.0;
-    x_[2] =  0.0;
-    x_[3] =  1.0;
+    x_[2] = 0.0;
+    x_[3] = 1.0;
 
     problem_.AddResidualBlock(
         new AutoDiffCostFunction<F1, 1, 1, 1>(new F1), NULL, &x_[0], &x_[1]);
@@ -94,9 +94,8 @@
   // functions.
   class F1 {
    public:
-    template <typename T> bool operator()(const T* const x1,
-                                          const T* const x2,
-                                          T* residual) const {
+    template <typename T>
+    bool operator()(const T* const x1, const T* const x2, T* residual) const {
       // f1 = x1 + 10 * x2;
       *residual = *x1 + 10.0 * *x2;
       return true;
@@ -105,9 +104,8 @@
 
   class F2 {
    public:
-    template <typename T> bool operator()(const T* const x3,
-                                          const T* const x4,
-                                          T* residual) const {
+    template <typename T>
+    bool operator()(const T* const x3, const T* const x4, T* residual) const {
       // f2 = sqrt(5) (x3 - x4)
       *residual = sqrt(5.0) * (*x3 - *x4);
       return true;
@@ -116,9 +114,8 @@
 
   class F3 {
    public:
-    template <typename T> bool operator()(const T* const x2,
-                                          const T* const x4,
-                                          T* residual) const {
+    template <typename T>
+    bool operator()(const T* const x2, const T* const x4, T* residual) const {
       // f3 = (x2 - 2 x3)^2
       residual[0] = (x2[0] - 2.0 * x4[0]) * (x2[0] - 2.0 * x4[0]);
       return true;
@@ -127,9 +124,8 @@
 
   class F4 {
    public:
-    template <typename T> bool operator()(const T* const x1,
-                                          const T* const x4,
-                                          T* residual) const {
+    template <typename T>
+    bool operator()(const T* const x1, const T* const x4, T* residual) const {
       // f4 = sqrt(10) (x1 - x4)^2
       residual[0] = sqrt(10.0) * (x1[0] - x4[0]) * (x1[0] - x4[0]);
       return true;
diff --git a/internal/ceres/thread_pool.cc b/internal/ceres/thread_pool.cc
index 5a52c9d..821431c 100644
--- a/internal/ceres/thread_pool.cc
+++ b/internal/ceres/thread_pool.cc
@@ -33,11 +33,11 @@
 
 #ifdef CERES_USE_CXX_THREADS
 
-#include "ceres/thread_pool.h"
-
 #include <cmath>
 #include <limits>
 
+#include "ceres/thread_pool.h"
+
 namespace ceres {
 namespace internal {
 namespace {
@@ -53,16 +53,13 @@
   const int num_hardware_threads = std::thread::hardware_concurrency();
   // hardware_concurrency() can return 0 if the value is not well defined or not
   // computable.
-  return num_hardware_threads == 0
-      ? std::numeric_limits<int>::max()
-      : num_hardware_threads;
+  return num_hardware_threads == 0 ? std::numeric_limits<int>::max()
+                                   : num_hardware_threads;
 }
 
-ThreadPool::ThreadPool() { }
+ThreadPool::ThreadPool() {}
 
-ThreadPool::ThreadPool(int num_threads) {
-  Resize(num_threads);
-}
+ThreadPool::ThreadPool(int num_threads) { Resize(num_threads); }
 
 ThreadPool::~ThreadPool() {
   std::lock_guard<std::mutex> lock(thread_pool_mutex_);
@@ -106,11 +103,9 @@
   }
 }
 
-void ThreadPool::Stop() {
-  task_queue_.StopWaiters();
-}
+void ThreadPool::Stop() { task_queue_.StopWaiters(); }
 
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX_THREADS
+#endif  // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_pool_test.cc b/internal/ceres/thread_pool_test.cc
index 48ba9d1..e39f673 100644
--- a/internal/ceres/thread_pool_test.cc
+++ b/internal/ceres/thread_pool_test.cc
@@ -33,16 +33,15 @@
 
 #ifdef CERES_USE_CXX_THREADS
 
-#include "ceres/thread_pool.h"
-
 #include <chrono>
 #include <condition_variable>
 #include <mutex>
 #include <thread>
 
+#include "ceres/thread_pool.h"
+#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "glog/logging.h"
 
 namespace ceres {
 namespace internal {
@@ -59,14 +58,14 @@
 
     for (int i = 0; i < num_tasks; ++i) {
       thread_pool.AddTask([&]() {
-          std::lock_guard<std::mutex> lock(mutex);
-          ++value;
-          condition.notify_all();
-        });
+        std::lock_guard<std::mutex> lock(mutex);
+        ++value;
+        condition.notify_all();
+      });
     }
 
     std::unique_lock<std::mutex> lock(mutex);
-    condition.wait(lock, [&](){return value == num_tasks;});
+    condition.wait(lock, [&]() { return value == num_tasks; });
   }
 
   EXPECT_EQ(num_tasks, value);
@@ -116,7 +115,7 @@
 
     // Unlock the mutex to unblock all of the threads and wait until all of the
     // tasks are completed.
-    condition.wait(lock, [&](){return value == num_tasks;});
+    condition.wait(lock, [&]() { return value == num_tasks; });
   }
 
   EXPECT_EQ(num_tasks, value);
@@ -197,4 +196,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX_THREADS
+#endif  // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_token_provider.cc b/internal/ceres/thread_token_provider.cc
index b04cf84..c7ec67f 100644
--- a/internal/ceres/thread_token_provider.cc
+++ b/internal/ceres/thread_token_provider.cc
@@ -44,7 +44,6 @@
     pool_.Push(i);
   }
 #endif
-
 }
 
 int ThreadTokenProvider::Acquire() {
@@ -61,7 +60,6 @@
   CHECK(pool_.Wait(&thread_id));
   return thread_id;
 #endif
-
 }
 
 void ThreadTokenProvider::Release(int thread_id) {
@@ -69,7 +67,6 @@
 #ifdef CERES_USE_CXX_THREADS
   pool_.Push(thread_id);
 #endif
-
 }
 
 }  // namespace internal
diff --git a/internal/ceres/tiny_solver_autodiff_function_test.cc b/internal/ceres/tiny_solver_autodiff_function_test.cc
index 90033fc..2598188 100644
--- a/internal/ceres/tiny_solver_autodiff_function_test.cc
+++ b/internal/ceres/tiny_solver_autodiff_function_test.cc
@@ -30,27 +30,27 @@
 // Author: mierle@gmail.com (Keir Mierle)
 
 #include "ceres/tiny_solver_autodiff_function.h"
-#include "ceres/tiny_solver.h"
-#include "ceres/tiny_solver_test_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
+#include "ceres/tiny_solver.h"
+#include "ceres/tiny_solver_test_util.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
 
 struct AutoDiffTestFunctor {
-  template<typename T>
+  template <typename T>
   bool operator()(const T* const parameters, T* residuals) const {
     // Shift the parameters so the solution is not at the origin, to prevent
     // accidentally showing "PASS".
     const T& a = parameters[0] - T(1.0);
     const T& b = parameters[1] - T(2.0);
     const T& c = parameters[2] - T(3.0);
-    residuals[0] = 2.*a + 0.*b + 1.*c;
-    residuals[1] = 0.*a + 4.*b + 6.*c;
+    residuals[0] = 2. * a + 0. * b + 1. * c;
+    residuals[1] = 0. * a + 4. * b + 6. * c;
     return true;
   }
 };
@@ -103,11 +103,9 @@
     NUM_PARAMETERS = 3,
   };
 
-  int NumResiduals() const {
-    return 2;
-  }
+  int NumResiduals() const { return 2; }
 
-  template<typename T>
+  template <typename T>
   bool operator()(const T* parameters, T* residuals) const {
     // Jacobian is not evaluated by cost function, but by autodiff.
     T* jacobian = nullptr;
@@ -115,7 +113,7 @@
   }
 };
 
-template<typename Function, typename Vector>
+template <typename Function, typename Vector>
 void TestHelper(const Function& f, const Vector& x0) {
   Vector x = x0;
   Eigen::Vector2d residuals;
@@ -133,10 +131,8 @@
   Eigen::Vector3d x0(0.76026643, -30.01799744, 0.55192142);
 
   DynamicResidualsFunctor f;
-  using AutoDiffCostFunctor =
-      ceres::TinySolverAutoDiffFunction<DynamicResidualsFunctor,
-                                        Eigen::Dynamic,
-                                        3>;
+  using AutoDiffCostFunctor = ceres::
+      TinySolverAutoDiffFunction<DynamicResidualsFunctor, Eigen::Dynamic, 3>;
   AutoDiffCostFunctor f_autodiff(f);
 
   Eigen::Vector2d residuals;
diff --git a/internal/ceres/tiny_solver_cost_function_adapter_test.cc b/internal/ceres/tiny_solver_cost_function_adapter_test.cc
index 13ad406..6f57193 100644
--- a/internal/ceres/tiny_solver_cost_function_adapter_test.cc
+++ b/internal/ceres/tiny_solver_cost_function_adapter_test.cc
@@ -40,7 +40,7 @@
 
 namespace ceres {
 
-class CostFunction2x3 : public SizedCostFunction<2,3> {
+class CostFunction2x3 : public SizedCostFunction<2, 3> {
   bool Evaluate(double const* const* parameters,
                 double* residuals,
                 double** jacobians) const final {
@@ -48,7 +48,7 @@
     double y = parameters[0][1];
     double z = parameters[0][2];
 
-    residuals[0] = x + 2*y + 4*z;
+    residuals[0] = x + 2 * y + 4 * z;
     residuals[1] = y * z;
 
     if (jacobians && jacobians[0]) {
@@ -65,10 +65,11 @@
   }
 };
 
-template<int kNumResiduals, int kNumParameters>
+template <int kNumResiduals, int kNumParameters>
 void TestHelper() {
   std::unique_ptr<CostFunction> cost_function(new CostFunction2x3);
-  typedef  TinySolverCostFunctionAdapter<kNumResiduals, kNumParameters> CostFunctionAdapter;
+  typedef TinySolverCostFunctionAdapter<kNumResiduals, kNumParameters>
+      CostFunctionAdapter;
   CostFunctionAdapter cfa(*cost_function);
   EXPECT_EQ(CostFunctionAdapter::NUM_RESIDUALS, kNumResiduals);
   EXPECT_EQ(CostFunctionAdapter::NUM_PARAMETERS, kNumParameters);
@@ -80,7 +81,7 @@
   Eigen::Matrix<double, 2, 3, Eigen::ColMajor> actual_jacobian;
   Eigen::Matrix<double, 2, 3, Eigen::RowMajor> expected_jacobian;
 
-  double xyz[3] = { 1.0, -1.0, 2.0};
+  double xyz[3] = {1.0, -1.0, 2.0};
   double* parameters[1] = {xyz};
 
   // Check that residual only evaluation works.
diff --git a/internal/ceres/tiny_solver_test.cc b/internal/ceres/tiny_solver_test.cc
index 2a8cd39..2e70694 100644
--- a/internal/ceres/tiny_solver_test.cc
+++ b/internal/ceres/tiny_solver_test.cc
@@ -30,11 +30,11 @@
 // Author: mierle@gmail.com (Keir Mierle)
 
 #include "ceres/tiny_solver.h"
-#include "ceres/tiny_solver_test_util.h"
 
 #include <algorithm>
 #include <cmath>
 
+#include "ceres/tiny_solver_test_util.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -66,9 +66,7 @@
     NUM_PARAMETERS = Eigen::Dynamic,
   };
 
-  int NumParameters() const {
-    return 3;
-  }
+  int NumParameters() const { return 3; }
 
   bool operator()(const double* parameters,
                   double* residuals,
@@ -85,9 +83,7 @@
     NUM_PARAMETERS = 3,
   };
 
-  int NumResiduals() const {
-    return 2;
-  }
+  int NumResiduals() const { return 2; }
 
   bool operator()(const double* parameters,
                   double* residuals,
@@ -104,13 +100,9 @@
     NUM_PARAMETERS = Eigen::Dynamic,
   };
 
-  int NumResiduals() const {
-    return 2;
-  }
+  int NumResiduals() const { return 2; }
 
-  int NumParameters() const {
-    return 3;
-  }
+  int NumParameters() const { return 3; }
 
   bool operator()(const double* parameters,
                   double* residuals,
@@ -119,7 +111,7 @@
   }
 };
 
-template<typename Function, typename Vector>
+template <typename Function, typename Vector>
 void TestHelper(const Function& f, const Vector& x0) {
   Vector x = x0;
   Vec2 residuals;
diff --git a/internal/ceres/tiny_solver_test_util.h b/internal/ceres/tiny_solver_test_util.h
index 48fe955..310bb35 100644
--- a/internal/ceres/tiny_solver_test_util.h
+++ b/internal/ceres/tiny_solver_test_util.h
@@ -34,7 +34,7 @@
 
 namespace ceres {
 
-template<typename T>
+template <typename T>
 bool EvaluateResidualsAndJacobians(const T* parameters,
                                    T* residuals,
                                    T* jacobian) {
diff --git a/internal/ceres/triplet_sparse_matrix.cc b/internal/ceres/triplet_sparse_matrix.cc
index 54b588b..5dbf0e7 100644
--- a/internal/ceres/triplet_sparse_matrix.cc
+++ b/internal/ceres/triplet_sparse_matrix.cc
@@ -43,11 +43,7 @@
 namespace internal {
 
 TripletSparseMatrix::TripletSparseMatrix()
-    : num_rows_(0),
-      num_cols_(0),
-      max_num_nonzeros_(0),
-      num_nonzeros_(0) {}
-
+    : num_rows_(0), num_cols_(0), max_num_nonzeros_(0), num_nonzeros_(0) {}
 
 TripletSparseMatrix::~TripletSparseMatrix() {}
 
@@ -111,9 +107,11 @@
 
 bool TripletSparseMatrix::AllTripletsWithinBounds() const {
   for (int i = 0; i < num_nonzeros_; ++i) {
+    // clang-format off
     if ((rows_[i] < 0) || (rows_[i] >= num_rows_) ||
         (cols_[i] < 0) || (cols_[i] >= num_cols_))
       return false;
+    // clang-format on
   }
   return true;
 }
@@ -123,8 +121,7 @@
       << "Reallocation will cause data loss";
 
   // Nothing to do if we have enough space already.
-  if (new_max_num_nonzeros <= max_num_nonzeros_)
-    return;
+  if (new_max_num_nonzeros <= max_num_nonzeros_) return;
 
   int* new_rows = new int[new_max_num_nonzeros];
   int* new_cols = new int[new_max_num_nonzeros];
@@ -168,15 +165,15 @@
   }
 }
 
-void TripletSparseMatrix::RightMultiply(const double* x,  double* y) const {
+void TripletSparseMatrix::RightMultiply(const double* x, double* y) const {
   for (int i = 0; i < num_nonzeros_; ++i) {
-    y[rows_[i]] += values_[i]*x[cols_[i]];
+    y[rows_[i]] += values_[i] * x[cols_[i]];
   }
 }
 
 void TripletSparseMatrix::LeftMultiply(const double* x, double* y) const {
   for (int i = 0; i < num_nonzeros_; ++i) {
-    y[cols_[i]] += values_[i]*x[rows_[i]];
+    y[cols_[i]] += values_[i] * x[rows_[i]];
   }
 }
 
@@ -226,10 +223,9 @@
   num_cols_ = num_cols_ + B.num_cols();
 }
 
-
 void TripletSparseMatrix::Resize(int new_num_rows, int new_num_cols) {
   if ((new_num_rows >= num_rows_) && (new_num_cols >= num_cols_)) {
-    num_rows_  = new_num_rows;
+    num_rows_ = new_num_rows;
     num_cols_ = new_num_cols;
     return;
   }
@@ -245,9 +241,9 @@
   for (int i = 0; i < num_nonzeros_; ++i) {
     if ((r_ptr[i] < num_rows_) && (c_ptr[i] < num_cols_)) {
       if (dropped_terms) {
-        r_ptr[i-dropped_terms] = r_ptr[i];
-        c_ptr[i-dropped_terms] = c_ptr[i];
-        v_ptr[i-dropped_terms] = v_ptr[i];
+        r_ptr[i - dropped_terms] = r_ptr[i];
+        c_ptr[i - dropped_terms] = c_ptr[i];
+        v_ptr[i - dropped_terms] = v_ptr[i];
       }
     } else {
       ++dropped_terms;
diff --git a/internal/ceres/triplet_sparse_matrix.h b/internal/ceres/triplet_sparse_matrix.h
index 2ee0fa9..cbda253 100644
--- a/internal/ceres/triplet_sparse_matrix.h
+++ b/internal/ceres/triplet_sparse_matrix.h
@@ -33,8 +33,9 @@
 
 #include <memory>
 #include <vector>
-#include "ceres/sparse_matrix.h"
+
 #include "ceres/internal/eigen.h"
+#include "ceres/sparse_matrix.h"
 #include "ceres/types.h"
 
 namespace ceres {
@@ -68,11 +69,13 @@
   void ScaleColumns(const double* scale) final;
   void ToDenseMatrix(Matrix* dense_matrix) const final;
   void ToTextFile(FILE* file) const final;
+  // clang-format off
   int num_rows()        const final   { return num_rows_;     }
   int num_cols()        const final   { return num_cols_;     }
   int num_nonzeros()    const final   { return num_nonzeros_; }
   const double* values()  const final { return values_.get(); }
   double* mutable_values() final      { return values_.get(); }
+  // clang-format on
   void set_num_nonzeros(int num_nonzeros);
 
   // Increase max_num_nonzeros and correspondingly increase the size
@@ -94,11 +97,13 @@
   // bounds are dropped and the num_non_zeros changed accordingly.
   void Resize(int new_num_rows, int new_num_cols);
 
+  // clang-format off
   int max_num_nonzeros() const { return max_num_nonzeros_; }
   const int* rows()      const { return rows_.get();       }
   const int* cols()      const { return cols_.get();       }
   int* mutable_rows()          { return rows_.get();       }
   int* mutable_cols()          { return cols_.get();       }
+  // clang-format on
 
   // Returns true if the entries of the matrix obey the row, column,
   // and column size bounds and false otherwise.
diff --git a/internal/ceres/triplet_sparse_matrix_test.cc b/internal/ceres/triplet_sparse_matrix_test.cc
index 881fabc..3af634f 100644
--- a/internal/ceres/triplet_sparse_matrix_test.cc
+++ b/internal/ceres/triplet_sparse_matrix_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/triplet_sparse_matrix.h"
 
 #include <memory>
+
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -309,15 +310,14 @@
 
 TEST(TripletSparseMatrix, CreateDiagonalMatrix) {
   std::unique_ptr<double[]> values(new double[10]);
-  for (int i = 0; i < 10; ++i)
-    values[i] = i;
+  for (int i = 0; i < 10; ++i) values[i] = i;
 
   std::unique_ptr<TripletSparseMatrix> m(
       TripletSparseMatrix::CreateSparseDiagonalMatrix(values.get(), 10));
   EXPECT_EQ(m->num_rows(), 10);
   EXPECT_EQ(m->num_cols(), 10);
   ASSERT_EQ(m->num_nonzeros(), 10);
-  for (int i = 0; i < 10 ; ++i) {
+  for (int i = 0; i < 10; ++i) {
     EXPECT_EQ(m->rows()[i], i);
     EXPECT_EQ(m->cols()[i], i);
     EXPECT_EQ(m->values()[i], i);
@@ -331,7 +331,7 @@
     for (int j = 0; j < 20; ++j) {
       m.mutable_rows()[nnz] = i;
       m.mutable_cols()[nnz] = j;
-      m.mutable_values()[nnz++] = i+j;
+      m.mutable_values()[nnz++] = i + j;
     }
   }
   m.set_num_nonzeros(nnz);
diff --git a/internal/ceres/trust_region_minimizer.h b/internal/ceres/trust_region_minimizer.h
index b5c4122..e18193c 100644
--- a/internal/ceres/trust_region_minimizer.h
+++ b/internal/ceres/trust_region_minimizer.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_TRUST_REGION_MINIMIZER_H_
 
 #include <memory>
+
 #include "ceres/internal/eigen.h"
 #include "ceres/minimizer.h"
 #include "ceres/solver.h"
diff --git a/internal/ceres/trust_region_minimizer_test.cc b/internal/ceres/trust_region_minimizer_test.cc
index 952f878..8993273 100644
--- a/internal/ceres/trust_region_minimizer_test.cc
+++ b/internal/ceres/trust_region_minimizer_test.cc
@@ -33,7 +33,10 @@
 // implementation, rather than having a test that goes through all the
 // Program and Problem machinery.
 
+#include "ceres/trust_region_minimizer.h"
+
 #include <cmath>
+
 #include "ceres/autodiff_cost_function.h"
 #include "ceres/cost_function.h"
 #include "ceres/dense_qr_solver.h"
@@ -43,7 +46,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/minimizer.h"
 #include "ceres/problem.h"
-#include "ceres/trust_region_minimizer.h"
 #include "ceres/trust_region_strategy.h"
 #include "gtest/gtest.h"
 
@@ -59,6 +61,7 @@
 template <bool col1, bool col2, bool col3, bool col4>
 class PowellEvaluator2 : public Evaluator {
  public:
+  // clang-format off
   PowellEvaluator2()
       : num_active_cols_(
           (col1 ? 1 : 0) +
@@ -71,6 +74,7 @@
             << col3 << " "
             << col4;
   }
+  // clang-format on
 
   virtual ~PowellEvaluator2() {}
 
@@ -111,7 +115,7 @@
             << "f3=" << f3 << ", "
             << "f4=" << f4 << ".";
 
-    *cost = (f1*f1 + f2*f2 + f3*f3 + f4*f4) / 2.0;
+    *cost = (f1 * f1 + f2 * f2 + f3 * f3 + f4 * f4) / 2.0;
 
     VLOG(1) << "Cost: " << *cost;
 
@@ -132,34 +136,42 @@
 
       int column_index = 0;
       if (col1) {
+        // clang-format off
         jacobian_matrix.col(column_index++) <<
             1.0,
             0.0,
             0.0,
             sqrt(10.0) * 2.0 * (x1 - x4) * (1.0 - x4);
+        // clang-format on
       }
       if (col2) {
+        // clang-format off
         jacobian_matrix.col(column_index++) <<
             10.0,
             0.0,
             2.0*(x2 - 2.0*x3)*(1.0 - 2.0*x3),
             0.0;
+        // clang-format on
       }
 
       if (col3) {
+        // clang-format off
         jacobian_matrix.col(column_index++) <<
             0.0,
             sqrt(5.0),
             2.0*(x2 - 2.0*x3)*(x2 - 2.0),
             0.0;
+        // clang-format on
       }
 
       if (col4) {
+        // clang-format off
         jacobian_matrix.col(column_index++) <<
             0.0,
             -sqrt(5.0),
             0.0,
             sqrt(10.0) * 2.0 * (x1 - x4) * (x1 - 1.0);
+        // clang-format on
       }
       VLOG(1) << "\n" << jacobian_matrix;
     }
@@ -167,7 +179,7 @@
     if (gradient != NULL) {
       int column_index = 0;
       if (col1) {
-        gradient[column_index++] = f1  + f4 * sqrt(10.0) * 2.0 * (x1 - x4);
+        gradient[column_index++] = f1 + f4 * sqrt(10.0) * 2.0 * (x1 - x4);
       }
 
       if (col2) {
@@ -192,16 +204,16 @@
             const double* delta,
             double* state_plus_delta) const final {
     int delta_index = 0;
-    state_plus_delta[0] = (col1  ? state[0] + delta[delta_index++] : state[0]);
-    state_plus_delta[1] = (col2  ? state[1] + delta[delta_index++] : state[1]);
-    state_plus_delta[2] = (col3  ? state[2] + delta[delta_index++] : state[2]);
-    state_plus_delta[3] = (col4  ? state[3] + delta[delta_index++] : state[3]);
+    state_plus_delta[0] = (col1 ? state[0] + delta[delta_index++] : state[0]);
+    state_plus_delta[1] = (col2 ? state[1] + delta[delta_index++] : state[1]);
+    state_plus_delta[2] = (col3 ? state[2] + delta[delta_index++] : state[2]);
+    state_plus_delta[3] = (col4 ? state[3] + delta[delta_index++] : state[3]);
     return true;
   }
 
   int NumEffectiveParameters() const final { return num_active_cols_; }
-  int NumParameters()          const final { return 4; }
-  int NumResiduals()           const final { return 4; }
+  int NumParameters() const final { return 4; }
+  int NumResiduals() const final { return 4; }
 
  private:
   const int num_active_cols_;
@@ -209,13 +221,13 @@
 
 // Templated function to hold a subset of the columns fixed and check
 // if the solver converges to the optimal values or not.
-template<bool col1, bool col2, bool col3, bool col4>
+template <bool col1, bool col2, bool col3, bool col4>
 void IsTrustRegionSolveSuccessful(TrustRegionStrategyType strategy_type) {
   Solver::Options solver_options;
   LinearSolver::Options linear_solver_options;
   DenseQRSolver linear_solver(linear_solver_options);
 
-  double parameters[4] = { 3, -1, 0, 1.0 };
+  double parameters[4] = {3, -1, 0, 1.0};
 
   // If the column is inactive, then set its value to the optimal
   // value.
@@ -263,6 +275,7 @@
   //   IsSolveSuccessful<true, true, false, true>();
 
   const TrustRegionStrategyType kStrategy = LEVENBERG_MARQUARDT;
+  // clang-format off
   IsTrustRegionSolveSuccessful<true,  true,  true,  true >(kStrategy);
   IsTrustRegionSolveSuccessful<true,  true,  true,  false>(kStrategy);
   IsTrustRegionSolveSuccessful<true,  false, true,  true >(kStrategy);
@@ -277,6 +290,7 @@
   IsTrustRegionSolveSuccessful<false, true,  false, false>(kStrategy);
   IsTrustRegionSolveSuccessful<false, false, true,  false>(kStrategy);
   IsTrustRegionSolveSuccessful<false, false, false, true >(kStrategy);
+  // clang-format on
 }
 
 TEST(TrustRegionMinimizer, PowellsSingularFunctionUsingDogleg) {
@@ -287,6 +301,7 @@
   //  IsTrustRegionSolveSuccessful<true,  true,  true,  true >(kStrategy);
 
   const TrustRegionStrategyType kStrategy = DOGLEG;
+  // clang-format off
   IsTrustRegionSolveSuccessful<true,  true,  true,  false>(kStrategy);
   IsTrustRegionSolveSuccessful<true,  false, true,  true >(kStrategy);
   IsTrustRegionSolveSuccessful<false, true,  true,  true >(kStrategy);
@@ -300,9 +315,9 @@
   IsTrustRegionSolveSuccessful<false, true,  false, false>(kStrategy);
   IsTrustRegionSolveSuccessful<false, false, true,  false>(kStrategy);
   IsTrustRegionSolveSuccessful<false, false, false, true >(kStrategy);
+  // clang-format on
 }
 
-
 class CurveCostFunction : public CostFunction {
  public:
   CurveCostFunction(int num_vertices, double target_length)
@@ -352,11 +367,11 @@
         for (int dim = 0; dim < 2; dim++) {
           jacobians[i][dim] = 0.;
 
-          if (norm_u > std::numeric_limits< double >::min()) {
+          if (norm_u > std::numeric_limits<double>::min()) {
             jacobians[i][dim] -= u[dim] / norm_u;
           }
 
-          if (norm_v > std::numeric_limits< double >::min()) {
+          if (norm_v > std::numeric_limits<double>::min()) {
             jacobians[i][dim] += v[dim] / norm_v;
           }
         }
@@ -367,8 +382,8 @@
   }
 
  private:
-  int     num_vertices_;
-  double  target_length_;
+  int num_vertices_;
+  double target_length_;
 };
 
 TEST(TrustRegionMinimizer, JacobiScalingTest) {
@@ -376,7 +391,7 @@
   std::vector<double*> y(N);
   const double pi = 3.1415926535897932384626433;
   for (int i = 0; i < N; i++) {
-    double theta = i * 2. * pi/ static_cast< double >(N);
+    double theta = i * 2. * pi / static_cast<double>(N);
     y[i] = new double[2];
     y[i][0] = cos(theta);
     y[i][1] = sin(theta);
@@ -391,7 +406,7 @@
   EXPECT_LE(summary.final_cost, 1e-10);
 
   for (int i = 0; i < N; i++) {
-    delete []y[i];
+    delete[] y[i];
   }
 }
 
@@ -403,8 +418,7 @@
   }
 
   static CostFunction* Create() {
-    return new AutoDiffCostFunction<ExpCostFunctor, 1, 1>(
-        new ExpCostFunctor);
+    return new AutoDiffCostFunction<ExpCostFunctor, 1, 1>(new ExpCostFunctor);
   }
 };
 
diff --git a/internal/ceres/trust_region_preprocessor_test.cc b/internal/ceres/trust_region_preprocessor_test.cc
index c344812..a2a9523 100644
--- a/internal/ceres/trust_region_preprocessor_test.cc
+++ b/internal/ceres/trust_region_preprocessor_test.cc
@@ -28,6 +28,8 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/trust_region_preprocessor.h"
+
 #include <array>
 #include <map>
 
@@ -35,7 +37,6 @@
 #include "ceres/problem_impl.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/solver.h"
-#include "ceres/trust_region_preprocessor.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -147,8 +148,10 @@
     x_ = 1.0;
     y_ = 1.0;
     z_ = 1.0;
-    problem_.AddResidualBlock(new DummyCostFunction<1, 1, 1>, nullptr, &x_, &y_);
-    problem_.AddResidualBlock(new DummyCostFunction<1, 1, 1>, nullptr, &y_, &z_);
+    problem_.AddResidualBlock(
+        new DummyCostFunction<1, 1, 1>, nullptr, &x_, &y_);
+    problem_.AddResidualBlock(
+        new DummyCostFunction<1, 1, 1>, nullptr, &y_, &z_);
   }
 
   void PreprocessForGivenLinearSolverAndVerify(
@@ -322,8 +325,7 @@
   EXPECT_TRUE(pp.inner_iteration_minimizer.get() != nullptr);
 }
 
-TEST_F(LinearSolverAndEvaluatorCreationTest,
-       InvalidInnerIterationsOrdering) {
+TEST_F(LinearSolverAndEvaluatorCreationTest, InvalidInnerIterationsOrdering) {
   Solver::Options options;
   options.use_inner_iterations = true;
   options.inner_iteration_ordering.reset(new ParameterBlockOrdering);
diff --git a/internal/ceres/trust_region_step_evaluator.cc b/internal/ceres/trust_region_step_evaluator.cc
index 33b0c41..19045ae 100644
--- a/internal/ceres/trust_region_step_evaluator.cc
+++ b/internal/ceres/trust_region_step_evaluator.cc
@@ -28,17 +28,18 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/trust_region_step_evaluator.h"
+
 #include <algorithm>
 #include <limits>
-#include "ceres/trust_region_step_evaluator.h"
+
 #include "glog/logging.h"
 
 namespace ceres {
 namespace internal {
 
 TrustRegionStepEvaluator::TrustRegionStepEvaluator(
-    const double initial_cost,
-    const int max_consecutive_nonmonotonic_steps)
+    const double initial_cost, const int max_consecutive_nonmonotonic_steps)
     : max_consecutive_nonmonotonic_steps_(max_consecutive_nonmonotonic_steps),
       minimum_cost_(initial_cost),
       current_cost_(initial_cost),
@@ -46,12 +47,10 @@
       candidate_cost_(initial_cost),
       accumulated_reference_model_cost_change_(0.0),
       accumulated_candidate_model_cost_change_(0.0),
-      num_consecutive_nonmonotonic_steps_(0){
-}
+      num_consecutive_nonmonotonic_steps_(0) {}
 
 double TrustRegionStepEvaluator::StepQuality(
-    const double cost,
-    const double model_cost_change) const {
+    const double cost, const double model_cost_change) const {
   // If the function evaluation for this step was a failure, in which
   // case the TrustRegionMinimizer would have set the cost to
   // std::numeric_limits<double>::max(). In this case, the division by
@@ -68,9 +67,8 @@
   return std::max(relative_decrease, historical_relative_decrease);
 }
 
-void TrustRegionStepEvaluator::StepAccepted(
-    const double cost,
-    const double model_cost_change) {
+void TrustRegionStepEvaluator::StepAccepted(const double cost,
+                                            const double model_cost_change) {
   // Algorithm 10.1.2 from Trust Region Methods by Conn, Gould &
   // Toint.
   //
diff --git a/internal/ceres/trust_region_strategy.cc b/internal/ceres/trust_region_strategy.cc
index 2db6a6c..7e429d5 100644
--- a/internal/ceres/trust_region_strategy.cc
+++ b/internal/ceres/trust_region_strategy.cc
@@ -31,6 +31,7 @@
 //         keir@google.com (Keir Mierle)
 
 #include "ceres/trust_region_strategy.h"
+
 #include "ceres/dogleg_strategy.h"
 #include "ceres/levenberg_marquardt_strategy.h"
 
diff --git a/internal/ceres/trust_region_strategy.h b/internal/ceres/trust_region_strategy.h
index 5751691..48e7347 100644
--- a/internal/ceres/trust_region_strategy.h
+++ b/internal/ceres/trust_region_strategy.h
@@ -32,6 +32,7 @@
 #define CERES_INTERNAL_TRUST_REGION_STRATEGY_H_
 
 #include <string>
+
 #include "ceres/internal/port.h"
 #include "ceres/linear_solver.h"
 
diff --git a/internal/ceres/types.cc b/internal/ceres/types.cc
index 93c4cfc..39bb2d8 100644
--- a/internal/ceres/types.cc
+++ b/internal/ceres/types.cc
@@ -28,18 +28,22 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 
+#include "ceres/types.h"
+
 #include <algorithm>
 #include <cctype>
 #include <string>
-#include "ceres/types.h"
+
 #include "glog/logging.h"
 
 namespace ceres {
 
 using std::string;
 
+// clang-format off
 #define CASESTR(x) case x: return #x
-#define STRENUM(x) if (value == #x) { *type = x; return true;}
+#define STRENUM(x) if (value == #x) { *type = x; return true; }
+// clang-format on
 
 static void UpperCase(string* input) {
   std::transform(input->begin(), input->end(), input->begin(), ::toupper);
@@ -109,8 +113,7 @@
 }
 
 bool StringToSparseLinearAlgebraLibraryType(
-    string value,
-    SparseLinearAlgebraLibraryType* type) {
+    string value, SparseLinearAlgebraLibraryType* type) {
   UpperCase(&value);
   STRENUM(SUITE_SPARSE);
   STRENUM(CX_SPARSE);
@@ -131,8 +134,7 @@
 }
 
 bool StringToDenseLinearAlgebraLibraryType(
-    string value,
-    DenseLinearAlgebraLibraryType* type) {
+    string value, DenseLinearAlgebraLibraryType* type) {
   UpperCase(&value);
   STRENUM(EIGEN);
   STRENUM(LAPACK);
@@ -236,9 +238,8 @@
   }
 }
 
-bool StringToLineSearchInterpolationType(
-    string value,
-    LineSearchInterpolationType* type) {
+bool StringToLineSearchInterpolationType(string value,
+                                         LineSearchInterpolationType* type) {
   UpperCase(&value);
   STRENUM(BISECTION);
   STRENUM(QUADRATIC);
@@ -258,8 +259,7 @@
 }
 
 bool StringToNonlinearConjugateGradientType(
-    string value,
-    NonlinearConjugateGradientType* type) {
+    string value, NonlinearConjugateGradientType* type) {
   UpperCase(&value);
   STRENUM(FLETCHER_REEVES);
   STRENUM(POLAK_RIBIERE);
@@ -267,8 +267,7 @@
   return false;
 }
 
-const char* CovarianceAlgorithmTypeToString(
-    CovarianceAlgorithmType type) {
+const char* CovarianceAlgorithmTypeToString(CovarianceAlgorithmType type) {
   switch (type) {
     CASESTR(DENSE_SVD);
     CASESTR(SPARSE_QR);
@@ -277,17 +276,15 @@
   }
 }
 
-bool StringToCovarianceAlgorithmType(
-    string value,
-    CovarianceAlgorithmType* type) {
+bool StringToCovarianceAlgorithmType(string value,
+                                     CovarianceAlgorithmType* type) {
   UpperCase(&value);
   STRENUM(DENSE_SVD);
   STRENUM(SPARSE_QR);
   return false;
 }
 
-const char* NumericDiffMethodTypeToString(
-    NumericDiffMethodType type) {
+const char* NumericDiffMethodTypeToString(NumericDiffMethodType type) {
   switch (type) {
     CASESTR(CENTRAL);
     CASESTR(FORWARD);
@@ -297,9 +294,7 @@
   }
 }
 
-bool StringToNumericDiffMethodType(
-    string value,
-    NumericDiffMethodType* type) {
+bool StringToNumericDiffMethodType(string value, NumericDiffMethodType* type) {
   UpperCase(&value);
   STRENUM(CENTRAL);
   STRENUM(FORWARD);
@@ -307,8 +302,7 @@
   return false;
 }
 
-const char* VisibilityClusteringTypeToString(
-    VisibilityClusteringType type) {
+const char* VisibilityClusteringTypeToString(VisibilityClusteringType type) {
   switch (type) {
     CASESTR(CANONICAL_VIEWS);
     CASESTR(SINGLE_LINKAGE);
@@ -317,9 +311,8 @@
   }
 }
 
-bool StringToVisibilityClusteringType(
-    string value,
-    VisibilityClusteringType* type) {
+bool StringToVisibilityClusteringType(string value,
+                                      VisibilityClusteringType* type) {
   UpperCase(&value);
   STRENUM(CANONICAL_VIEWS);
   STRENUM(SINGLE_LINKAGE);
@@ -354,9 +347,8 @@
   return false;
 }
 
-
 const char* DumpFormatTypeToString(DumpFormatType type) {
-   switch (type) {
+  switch (type) {
     CASESTR(CONSOLE);
     CASESTR(TEXTFILE);
     default:
@@ -375,9 +367,11 @@
 #undef STRENUM
 
 bool IsSchurType(LinearSolverType type) {
+  // clang-format off
   return ((type == SPARSE_SCHUR) ||
           (type == DENSE_SCHUR)  ||
           (type == ITERATIVE_SCHUR));
+  // clang-format on
 }
 
 bool IsSparseLinearAlgebraLibraryTypeAvailable(
diff --git a/internal/ceres/visibility.cc b/internal/ceres/visibility.cc
index 0981eed..82bf6f1 100644
--- a/internal/ceres/visibility.cc
+++ b/internal/ceres/visibility.cc
@@ -30,13 +30,14 @@
 
 #include "ceres/visibility.h"
 
+#include <algorithm>
 #include <cmath>
 #include <ctime>
-#include <algorithm>
 #include <set>
-#include <vector>
 #include <unordered_map>
 #include <utility>
+#include <vector>
+
 #include "ceres/block_structure.h"
 #include "ceres/graph.h"
 #include "ceres/pair_hash.h"
@@ -138,9 +139,10 @@
     const int count = camera_pair_count.second;
     DCHECK_NE(camera1, camera2);
     // Static cast necessary for Windows.
-    const double weight = static_cast<double>(count) /
-        (sqrt(static_cast<double>(
-                  visibility[camera1].size() * visibility[camera2].size())));
+    const double weight =
+        static_cast<double>(count) /
+        (sqrt(static_cast<double>(visibility[camera1].size() *
+                                  visibility[camera2].size())));
     graph->AddEdge(camera1, camera2, weight);
   }
 
diff --git a/internal/ceres/visibility.h b/internal/ceres/visibility.h
index 115d45f..ed25d53 100644
--- a/internal/ceres/visibility.h
+++ b/internal/ceres/visibility.h
@@ -37,6 +37,7 @@
 
 #include <set>
 #include <vector>
+
 #include "ceres/graph.h"
 
 namespace ceres {
diff --git a/internal/ceres/visibility_based_preconditioner.h b/internal/ceres/visibility_based_preconditioner.h
index aa582d5..0457b9a 100644
--- a/internal/ceres/visibility_based_preconditioner.h
+++ b/internal/ceres/visibility_based_preconditioner.h
@@ -162,8 +162,9 @@
       std::vector<std::set<int>>* cluster_visibility) const;
   WeightedGraph<int>* CreateClusterGraph(
       const std::vector<std::set<int>>& visibility) const;
-  void ForestToClusterPairs(const WeightedGraph<int>& forest,
-                            std::unordered_set<std::pair<int, int>, pair_hash>* cluster_pairs) const;
+  void ForestToClusterPairs(
+      const WeightedGraph<int>& forest,
+      std::unordered_set<std::pair<int, int>, pair_hash>* cluster_pairs) const;
   void ComputeBlockPairsInPreconditioner(const CompressedRowBlockStructure& bs);
   bool IsBlockPairInPreconditioner(int block1, int block2) const;
   bool IsBlockPairOffDiagonal(int block1, int block2) const;
diff --git a/internal/ceres/visibility_based_preconditioner_test.cc b/internal/ceres/visibility_based_preconditioner_test.cc
index a006d98..10aa619 100644
--- a/internal/ceres/visibility_based_preconditioner_test.cc
+++ b/internal/ceres/visibility_based_preconditioner_test.cc
@@ -31,6 +31,7 @@
 #include "ceres/visibility_based_preconditioner.h"
 
 #include <memory>
+
 #include "Eigen/Dense"
 #include "ceres/block_random_access_dense_matrix.h"
 #include "ceres/block_random_access_sparse_matrix.h"
diff --git a/internal/ceres/visibility_test.cc b/internal/ceres/visibility_test.cc
index 5028e01..a199963 100644
--- a/internal/ceres/visibility_test.cc
+++ b/internal/ceres/visibility_test.cc
@@ -46,8 +46,7 @@
 using std::set;
 using std::vector;
 
-class VisibilityTest : public ::testing::Test {
-};
+class VisibilityTest : public ::testing::Test {};
 
 TEST(VisibilityTest, SimpleMatrix) {
   //   A = [1 0 0 0 0 1
@@ -100,14 +99,15 @@
   }
   bs.cols.resize(num_cols);
 
-  vector< set<int>> visibility;
+  vector<set<int>> visibility;
   ComputeVisibility(bs, num_eliminate_blocks, &visibility);
   ASSERT_EQ(visibility.size(), num_cols - num_eliminate_blocks);
   for (int i = 0; i < visibility.size(); ++i) {
     ASSERT_EQ(visibility[i].size(), 1);
   }
 
-  std::unique_ptr<WeightedGraph<int> > graph(CreateSchurComplementGraph(visibility));
+  std::unique_ptr<WeightedGraph<int>> graph(
+      CreateSchurComplementGraph(visibility));
   EXPECT_EQ(graph->vertices().size(), visibility.size());
   for (int i = 0; i < visibility.size(); ++i) {
     EXPECT_EQ(graph->VertexWeight(i), 1.0);
@@ -121,14 +121,12 @@
       }
 
       EXPECT_EQ(graph->EdgeWeight(i, j), edge_weight)
-          << "Edge: " << i << " " << j
-          << " weight: " << graph->EdgeWeight(i, j)
+          << "Edge: " << i << " " << j << " weight: " << graph->EdgeWeight(i, j)
           << " expected weight: " << edge_weight;
     }
   }
 }
 
-
 TEST(VisibilityTest, NoEBlocks) {
   //   A = [1 0 0 0 0 0
   //        1 0 0 0 0 0
@@ -183,8 +181,8 @@
     ASSERT_EQ(visibility[i].size(), 0);
   }
 
-  std::unique_ptr<WeightedGraph<int> > graph(
-					     CreateSchurComplementGraph(visibility));
+  std::unique_ptr<WeightedGraph<int>> graph(
+      CreateSchurComplementGraph(visibility));
   EXPECT_EQ(graph->vertices().size(), visibility.size());
   for (int i = 0; i < visibility.size(); ++i) {
     EXPECT_EQ(graph->VertexWeight(i), 1.0);
@@ -197,8 +195,7 @@
         edge_weight = 1.0;
       }
       EXPECT_EQ(graph->EdgeWeight(i, j), edge_weight)
-          << "Edge: " << i << " " << j
-          << " weight: " << graph->EdgeWeight(i, j)
+          << "Edge: " << i << " " << j << " weight: " << graph->EdgeWeight(i, j)
           << " expected weight: " << edge_weight;
     }
   }
diff --git a/internal/ceres/wall_time.h b/internal/ceres/wall_time.h
index ed0610f..3f465e8 100644
--- a/internal/ceres/wall_time.h
+++ b/internal/ceres/wall_time.h
@@ -33,6 +33,7 @@
 
 #include <map>
 #include <string>
+
 #include "ceres/internal/port.h"
 #include "ceres/stringprintf.h"
 #include "glog/logging.h"