diff --git a/internal/ceres/cuda_dense_cholesky_test.cc b/internal/ceres/cuda_dense_cholesky_test.cc
index 4d9a889..24db09a 100644
--- a/internal/ceres/cuda_dense_cholesky_test.cc
+++ b/internal/ceres/cuda_dense_cholesky_test.cc
@@ -33,7 +33,6 @@
 #include "ceres/dense_cholesky.h"
 #include "ceres/internal/config.h"
 #include "ceres/internal/eigen.h"
-
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
@@ -53,10 +52,13 @@
 // Tests the CUDA Cholesky solver with a simple 4x4 matrix.
 TEST(CUDADenseCholesky, Cholesky4x4Matrix) {
   Eigen::Matrix4d A;
+  // clang-format off
   A <<  4,  12, -16, 0,
        12,  37, -43, 0,
       -16, -43,  98, 0,
         0,   0,   0, 1;
+  // clang-format on
+
   const Eigen::Vector4d b = Eigen::Vector4d::Ones();
   LinearSolver::Options options;
   ContextImpl context;
@@ -65,9 +67,7 @@
   auto dense_cuda_solver = CUDADenseCholesky::Create(options);
   ASSERT_NE(dense_cuda_solver, nullptr);
   std::string error_string;
-  ASSERT_EQ(dense_cuda_solver->Factorize(A.cols(),
-                                        A.data(),
-                                        &error_string),
+  ASSERT_EQ(dense_cuda_solver->Factorize(A.cols(), A.data(), &error_string),
             LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS);
   Eigen::Vector4d x = Eigen::Vector4d::Zero();
   ASSERT_EQ(dense_cuda_solver->Solve(b.data(), x.data(), &error_string),
@@ -80,9 +80,12 @@
 
 TEST(CUDADenseCholesky, SingularMatrix) {
   Eigen::Matrix3d A;
+  // clang-format off
   A <<  1, 0, 0,
         0, 1, 0,
         0, 0, 0;
+  // clang-format on
+
   const Eigen::Vector3d b = Eigen::Vector3d::Ones();
   LinearSolver::Options options;
   ContextImpl context;
@@ -91,17 +94,18 @@
   auto dense_cuda_solver = CUDADenseCholesky::Create(options);
   ASSERT_NE(dense_cuda_solver, nullptr);
   std::string error_string;
-  ASSERT_EQ(dense_cuda_solver->Factorize(A.cols(),
-                                        A.data(),
-                                        &error_string),
+  ASSERT_EQ(dense_cuda_solver->Factorize(A.cols(), A.data(), &error_string),
             LinearSolverTerminationType::LINEAR_SOLVER_FAILURE);
 }
 
 TEST(CUDADenseCholesky, NegativeMatrix) {
   Eigen::Matrix3d A;
+  // clang-format off
   A <<  1, 0, 0,
         0, 1, 0,
         0, 0, -1;
+  // clang-format on
+
   const Eigen::Vector3d b = Eigen::Vector3d::Ones();
   LinearSolver::Options options;
   ContextImpl context;
@@ -110,9 +114,7 @@
   auto dense_cuda_solver = CUDADenseCholesky::Create(options);
   ASSERT_NE(dense_cuda_solver, nullptr);
   std::string error_string;
-  ASSERT_EQ(dense_cuda_solver->Factorize(A.cols(),
-                                        A.data(),
-                                        &error_string),
+  ASSERT_EQ(dense_cuda_solver->Factorize(A.cols(), A.data(), &error_string),
             LinearSolverTerminationType::LINEAR_SOLVER_FAILURE);
 }
 
@@ -139,7 +141,8 @@
   ContextImpl context;
   options.context = &context;
   options.dense_linear_algebra_library_type = ceres::CUDA;
-  std::unique_ptr<DenseCholesky> dense_cholesky = CUDADenseCholesky::Create(options);
+  std::unique_ptr<DenseCholesky> dense_cholesky =
+      CUDADenseCholesky::Create(options);
 
   const int kNumTrials = 20;
   for (int i = 0; i < kNumTrials; ++i) {
@@ -159,15 +162,11 @@
     EXPECT_EQ(x_computed.rows(), kNumCols);
     EXPECT_EQ(x_computed.cols(), 1);
     LinearSolver::Summary summary;
-    summary.termination_type = dense_cholesky->FactorAndSolve(kNumCols,
-                                                              lhs.data(),
-                                                              rhs.data(),
-                                                              x_computed.data(),
-                                                              &summary.message);
+    summary.termination_type = dense_cholesky->FactorAndSolve(
+        kNumCols, lhs.data(), rhs.data(), x_computed.data(), &summary.message);
     ASSERT_EQ(summary.termination_type, LINEAR_SOLVER_SUCCESS);
-    ASSERT_NEAR((x_computed - x_expected).norm() / x_expected.norm(),
-                0.0,
-                1e-10);
+    ASSERT_NEAR(
+        (x_computed - x_expected).norm() / x_expected.norm(), 0.0, 1e-10);
   }
 }
 
diff --git a/internal/ceres/cuda_dense_qr_test.cc b/internal/ceres/cuda_dense_qr_test.cc
index 5d7b48c..9b4d375 100644
--- a/internal/ceres/cuda_dense_qr_test.cc
+++ b/internal/ceres/cuda_dense_qr_test.cc
@@ -32,7 +32,6 @@
 
 #include "ceres/dense_qr.h"
 #include "ceres/internal/eigen.h"
-
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
@@ -50,10 +49,12 @@
 // Tests the CUDA QR solver with a simple 4x4 matrix.
 TEST(CUDADenseQR, QR4x4Matrix) {
   Eigen::Matrix4d A;
+  // clang-format off
   A <<  4,  12, -16, 0,
        12,  37, -43, 0,
       -16, -43,  98, 0,
         0,   0,   0, 1;
+  // clang-format on
   const Eigen::Vector4d b = Eigen::Vector4d::Ones();
   LinearSolver::Options options;
   ContextImpl context;
@@ -62,11 +63,9 @@
   auto dense_cuda_solver = CUDADenseQR::Create(options);
   ASSERT_NE(dense_cuda_solver, nullptr);
   std::string error_string;
-  ASSERT_EQ(dense_cuda_solver->Factorize(A.rows(),
-                                         A.cols(),
-                                         A.data(),
-                                         &error_string),
-            LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS);
+  ASSERT_EQ(
+      dense_cuda_solver->Factorize(A.rows(), A.cols(), A.data(), &error_string),
+      LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS);
   Eigen::Vector4d x = Eigen::Vector4d::Zero();
   ASSERT_EQ(dense_cuda_solver->Solve(b.data(), x.data(), &error_string),
             LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS);
@@ -81,10 +80,13 @@
 // Tests the CUDA QR solver with a simple 4x4 matrix.
 TEST(CUDADenseQR, QR4x2Matrix) {
   Eigen::Matrix<double, 4, 2> A;
+  // clang-format off
   A <<  4,  12,
        12,  37,
       -16, -43,
         0,   0;
+  // clang-format on
+
   const std::vector<double> b(4, 1.0);
   LinearSolver::Options options;
   ContextImpl context;
@@ -93,11 +95,9 @@
   auto dense_cuda_solver = CUDADenseQR::Create(options);
   ASSERT_NE(dense_cuda_solver, nullptr);
   std::string error_string;
-  ASSERT_EQ(dense_cuda_solver->Factorize(A.rows(),
-                                         A.cols(),
-                                         A.data(),
-                                         &error_string),
-            LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS);
+  ASSERT_EQ(
+      dense_cuda_solver->Factorize(A.rows(), A.cols(), A.data(), &error_string),
+      LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS);
   std::vector<double> x(2, 0);
   ASSERT_EQ(dense_cuda_solver->Solve(b.data(), x.data(), &error_string),
             LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS);
diff --git a/internal/ceres/small_blas_gemm_benchmark.cc b/internal/ceres/small_blas_gemm_benchmark.cc
index 5248471..f146ba6 100644
--- a/internal/ceres/small_blas_gemm_benchmark.cc
+++ b/internal/ceres/small_blas_gemm_benchmark.cc
@@ -47,8 +47,8 @@
 // benchmark.
 class MatrixMatrixMultiplyData {
  public:
-  MatrixMatrixMultiplyData(int a_rows, int a_cols, int b_rows, int b_cols,
-                           int c_rows, int c_cols)
+  MatrixMatrixMultiplyData(
+      int a_rows, int a_cols, int b_rows, int b_cols, int c_rows, int c_cols)
       : num_elements_(1000),
         a_size_(num_elements_ * a_rows * a_cols),
         b_size_(b_rows * b_cols),
@@ -84,14 +84,22 @@
     const int c_cols = K;                                                   \
     const int a_rows = b_rows;                                              \
     const int a_cols = c_cols;                                              \
-    MatrixMatrixMultiplyData data(a_rows, a_cols, b_rows, b_cols, c_rows,   \
-                                  c_cols);                                  \
+    MatrixMatrixMultiplyData data(                                          \
+        a_rows, a_cols, b_rows, b_cols, c_rows, c_cols);                    \
     const int num_elements = data.num_elements();                           \
     int iter = 0;                                                           \
     for (auto _ : state) {                                                  \
-      FN<MT, KT, KT, NT, GEMM_KIND_ADD>(                                    \
-          data.GetB(iter), b_rows, b_cols, data.GetC(iter), c_rows, c_cols, \
-          data.GetA(iter), 512, 512, a_rows, a_cols);                       \
+      FN<MT, KT, KT, NT, GEMM_KIND_ADD>(data.GetB(iter),                    \
+                                        b_rows,                             \
+                                        b_cols,                             \
+                                        data.GetC(iter),                    \
+                                        c_rows,                             \
+                                        c_cols,                             \
+                                        data.GetA(iter),                    \
+                                        512,                                \
+                                        512,                                \
+                                        a_rows,                             \
+                                        a_cols);                            \
       iter = (iter + 1) % num_elements;                                     \
     }                                                                       \
   }                                                                         \
@@ -99,9 +107,9 @@
 
 #define BENCHMARK_STATIC_MM_FN(FN, M, N, K) \
   BENCHMARK_MM_FN(FN, M, N, K, Static, M, N, K)
-#define BENCHMARK_DYNAMIC_MM_FN(FN, M, N, K)                            \
-  BENCHMARK_MM_FN(FN, M, N, K, Dynamic, Eigen::Dynamic, Eigen::Dynamic, \
-                  Eigen::Dynamic)
+#define BENCHMARK_DYNAMIC_MM_FN(FN, M, N, K) \
+  BENCHMARK_MM_FN(                           \
+      FN, M, N, K, Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic)
 
 #define BENCHMARK_MTM_FN(FN, M, N, K, NAME, MT, NT, KT)                     \
   void static BM_##FN##_##NAME##_##M##x##N##x##K(benchmark::State& state) { \
@@ -111,14 +119,22 @@
     const int c_cols = K;                                                   \
     const int a_rows = b_cols;                                              \
     const int a_cols = c_cols;                                              \
-    MatrixMatrixMultiplyData data(a_rows, a_cols, b_rows, b_cols, c_rows,   \
-                                  c_cols);                                  \
+    MatrixMatrixMultiplyData data(                                          \
+        a_rows, a_cols, b_rows, b_cols, c_rows, c_cols);                    \
     const int num_elements = data.num_elements();                           \
     int iter = 0;                                                           \
     for (auto _ : state) {                                                  \
-      FN<KT, MT, KT, NT, GEMM_KIND_ADD>(                                    \
-          data.GetB(iter), b_rows, b_cols, data.GetC(iter), c_rows, c_cols, \
-          data.GetA(iter), 0, 0, a_rows, a_cols);                           \
+      FN<KT, MT, KT, NT, GEMM_KIND_ADD>(data.GetB(iter),                    \
+                                        b_rows,                             \
+                                        b_cols,                             \
+                                        data.GetC(iter),                    \
+                                        c_rows,                             \
+                                        c_cols,                             \
+                                        data.GetA(iter),                    \
+                                        0,                                  \
+                                        0,                                  \
+                                        a_rows,                             \
+                                        a_cols);                            \
       iter = (iter + 1) % num_elements;                                     \
     }                                                                       \
   }                                                                         \
@@ -126,9 +142,9 @@
 
 #define BENCHMARK_STATIC_MMT_FN(FN, M, N, K) \
   BENCHMARK_MTM_FN(FN, M, N, K, Static, M, N, K)
-#define BENCHMARK_DYNAMIC_MMT_FN(FN, M, N, K)                            \
-  BENCHMARK_MTM_FN(FN, M, N, K, Dynamic, Eigen::Dynamic, Eigen::Dynamic, \
-                   Eigen::Dynamic)
+#define BENCHMARK_DYNAMIC_MMT_FN(FN, M, N, K) \
+  BENCHMARK_MTM_FN(                           \
+      FN, M, N, K, Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic)
 
 BENCHMARK_STATIC_MM_FN(MatrixMatrixMultiplyEigen, 2, 3, 4)
 BENCHMARK_STATIC_MM_FN(MatrixMatrixMultiplyEigen, 3, 3, 3)
diff --git a/internal/ceres/small_blas_test.cc b/internal/ceres/small_blas_test.cc
index 6d02995..78fc3c3 100644
--- a/internal/ceres/small_blas_test.cc
+++ b/internal/ceres/small_blas_test.cc
@@ -45,24 +45,55 @@
 enum class DimType { Static, Dynamic };
 
 // Constructs matrix functor type.
-#define MATRIX_FUN_TY(FN)                                                      \
-  template <int kRowA, int kColA, int kRowB, int kColB, int kOperation,        \
-            DimType kDimType>                                                  \
-  struct FN##Ty {                                                              \
-    void operator()(const double *A, const int num_row_a, const int num_col_a, \
-                    const double *B, const int num_row_b, const int num_col_b, \
-                    double *C, const int start_row_c, const int start_col_c,   \
-                    const int row_stride_c, const int col_stride_c) {          \
-      if (kDimType == DimType::Static) {                                       \
-        FN<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);                          \
-      } else {                                                                 \
-        FN<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic,     \
-           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);  \
-      }                                                                        \
-    }                                                                          \
+#define MATRIX_FUN_TY(FN)                                         \
+  template <int kRowA,                                            \
+            int kColA,                                            \
+            int kRowB,                                            \
+            int kColB,                                            \
+            int kOperation,                                       \
+            DimType kDimType>                                     \
+  struct FN##Ty {                                                 \
+    void operator()(const double* A,                              \
+                    const int num_row_a,                          \
+                    const int num_col_a,                          \
+                    const double* B,                              \
+                    const int num_row_b,                          \
+                    const int num_col_b,                          \
+                    double* C,                                    \
+                    const int start_row_c,                        \
+                    const int start_col_c,                        \
+                    const int row_stride_c,                       \
+                    const int col_stride_c) {                     \
+      if (kDimType == DimType::Static) {                          \
+        FN<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); \
+      } else {                                                    \
+        FN<Eigen::Dynamic,                                        \
+           Eigen::Dynamic,                                        \
+           Eigen::Dynamic,                                        \
+           Eigen::Dynamic,                                        \
+           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);                             \
+      }                                                           \
+    }                                                             \
   };
 
 MATRIX_FUN_TY(MatrixMatrixMultiply)
@@ -73,7 +104,7 @@
 #undef MATRIX_FUN_TY
 
 // Initializes matrix entires.
-static void initMatrix(Matrix &mat) {
+static void initMatrix(Matrix& mat) {
   for (int i = 0; i < mat.rows(); ++i) {
     for (int j = 0; j < mat.cols(); ++j) {
       mat(i, j) = i + j + 1;
@@ -81,8 +112,12 @@
   }
 }
 
-template <int kRowA, int kColA, int kColB, DimType kDimType,
-          template <int, int, int, int, int, DimType> class FunctorTy>
+template <int kRowA,
+          int kColA,
+          int kColB,
+          DimType kDimType,
+          template <int, int, int, int, int, DimType>
+          class FunctorTy>
 struct TestMatrixFunctions {
   void operator()() {
     Matrix A(kRowA, kColA);
@@ -109,9 +144,17 @@
           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) += A * B;
-            FunctorTy<kRowA, kColA, kRowB, kColB, 1, kDimType>()(
-                A.data(), kRowA, kColA, B.data(), kRowB, kColB, C_plus.data(),
-                start_row_c, start_col_c, row_stride_c, col_stride_c);
+            FunctorTy<kRowA, kColA, kRowB, kColB, 1, kDimType>()(A.data(),
+                                                                 kRowA,
+                                                                 kColA,
+                                                                 B.data(),
+                                                                 kRowB,
+                                                                 kColB,
+                                                                 C_plus.data(),
+                                                                 start_row_c,
+                                                                 start_col_c,
+                                                                 row_stride_c,
+                                                                 col_stride_c);
 
             EXPECT_NEAR((C_plus_ref - C_plus).norm(), 0.0, kTolerance)
                 << "C += A * B \n"
@@ -126,8 +169,17 @@
 
             C_minus_ref.block(start_row_c, start_col_c, kRowA, kColB) -= A * B;
             FunctorTy<kRowA, kColA, kRowB, kColB, -1, kDimType>()(
-                A.data(), kRowA, kColA, B.data(), kRowB, kColB, C_minus.data(),
-                start_row_c, start_col_c, row_stride_c, col_stride_c);
+                A.data(),
+                kRowA,
+                kColA,
+                B.data(),
+                kRowB,
+                kColB,
+                C_minus.data(),
+                start_row_c,
+                start_col_c,
+                row_stride_c,
+                col_stride_c);
 
             EXPECT_NEAR((C_minus_ref - C_minus).norm(), 0.0, kTolerance)
                 << "C -= A * B \n"
@@ -143,8 +195,17 @@
             C_assign_ref.block(start_row_c, start_col_c, kRowA, kColB) = A * B;
 
             FunctorTy<kRowA, kColA, kRowB, kColB, 0, kDimType>()(
-                A.data(), kRowA, kColA, B.data(), kRowB, kColB, C_assign.data(),
-                start_row_c, start_col_c, row_stride_c, col_stride_c);
+                A.data(),
+                kRowA,
+                kColA,
+                B.data(),
+                kRowB,
+                kColB,
+                C_assign.data(),
+                start_row_c,
+                start_col_c,
+                row_stride_c,
+                col_stride_c);
 
             EXPECT_NEAR((C_assign_ref - C_assign).norm(), 0.0, kTolerance)
                 << "C = A * B \n"
@@ -163,8 +224,12 @@
   }
 };
 
-template <int kRowA, int kColA, int kColB, DimType kDimType,
-          template <int, int, int, int, int, DimType> class FunctorTy>
+template <int kRowA,
+          int kColA,
+          int kColB,
+          DimType kDimType,
+          template <int, int, int, int, int, DimType>
+          class FunctorTy>
 struct TestMatrixTransposeFunctions {
   void operator()() {
     Matrix A(kRowA, kColA);
@@ -192,9 +257,17 @@
             C_plus_ref.block(start_row_c, start_col_c, kColA, kColB) +=
                 A.transpose() * B;
 
-            FunctorTy<kRowA, kColA, kRowB, kColB, 1, kDimType>()(
-                A.data(), kRowA, kColA, B.data(), kRowB, kColB, C_plus.data(),
-                start_row_c, start_col_c, row_stride_c, col_stride_c);
+            FunctorTy<kRowA, kColA, kRowB, kColB, 1, kDimType>()(A.data(),
+                                                                 kRowA,
+                                                                 kColA,
+                                                                 B.data(),
+                                                                 kRowB,
+                                                                 kColB,
+                                                                 C_plus.data(),
+                                                                 start_row_c,
+                                                                 start_col_c,
+                                                                 row_stride_c,
+                                                                 col_stride_c);
 
             EXPECT_NEAR((C_plus_ref - C_plus).norm(), 0.0, kTolerance)
                 << "C += A' * B \n"
@@ -211,8 +284,17 @@
                 A.transpose() * B;
 
             FunctorTy<kRowA, kColA, kRowB, kColB, -1, kDimType>()(
-                A.data(), kRowA, kColA, B.data(), kRowB, kColB, C_minus.data(),
-                start_row_c, start_col_c, row_stride_c, col_stride_c);
+                A.data(),
+                kRowA,
+                kColA,
+                B.data(),
+                kRowB,
+                kColB,
+                C_minus.data(),
+                start_row_c,
+                start_col_c,
+                row_stride_c,
+                col_stride_c);
 
             EXPECT_NEAR((C_minus_ref - C_minus).norm(), 0.0, kTolerance)
                 << "C -= A' * B \n"
@@ -229,8 +311,17 @@
                 A.transpose() * B;
 
             FunctorTy<kRowA, kColA, kRowB, kColB, 0, kDimType>()(
-                A.data(), kRowA, kColA, B.data(), kRowB, kColB, C_assign.data(),
-                start_row_c, start_col_c, row_stride_c, col_stride_c);
+                A.data(),
+                kRowA,
+                kColA,
+                B.data(),
+                kRowB,
+                kColB,
+                C_assign.data(),
+                start_row_c,
+                start_col_c,
+                row_stride_c,
+                col_stride_c);
 
             EXPECT_NEAR((C_assign_ref - C_assign).norm(), 0.0, kTolerance)
                 << "C = A' * B \n"
@@ -274,92 +365,146 @@
 }
 
 TEST(BLAS, MatrixMatrixMultiplyNaive_5_3_7) {
-  TestMatrixFunctions<5, 3, 7, DimType::Static,
+  TestMatrixFunctions<5,
+                      3,
+                      7,
+                      DimType::Static,
                       MatrixMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixMatrixMultiplyNaive_5_3_7_Dynamic) {
-  TestMatrixFunctions<5, 3, 7, DimType::Dynamic,
+  TestMatrixFunctions<5,
+                      3,
+                      7,
+                      DimType::Dynamic,
                       MatrixMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixMatrixMultiplyNaive_1_1_1) {
-  TestMatrixFunctions<1, 1, 1, DimType::Static,
+  TestMatrixFunctions<1,
+                      1,
+                      1,
+                      DimType::Static,
                       MatrixMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixMatrixMultiplyNaive_1_1_1_Dynamic) {
-  TestMatrixFunctions<1, 1, 1, DimType::Dynamic,
+  TestMatrixFunctions<1,
+                      1,
+                      1,
+                      DimType::Dynamic,
                       MatrixMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixMatrixMultiplyNaive_9_9_9) {
-  TestMatrixFunctions<9, 9, 9, DimType::Static,
+  TestMatrixFunctions<9,
+                      9,
+                      9,
+                      DimType::Static,
                       MatrixMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixMatrixMultiplyNaive_9_9_9_Dynamic) {
-  TestMatrixFunctions<9, 9, 9, DimType::Dynamic,
+  TestMatrixFunctions<9,
+                      9,
+                      9,
+                      DimType::Dynamic,
                       MatrixMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiply_5_3_7) {
-  TestMatrixTransposeFunctions<5, 3, 7, DimType::Static,
+  TestMatrixTransposeFunctions<5,
+                               3,
+                               7,
+                               DimType::Static,
                                MatrixTransposeMatrixMultiplyTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiply_5_3_7_Dynamic) {
-  TestMatrixTransposeFunctions<5, 3, 7, DimType::Dynamic,
+  TestMatrixTransposeFunctions<5,
+                               3,
+                               7,
+                               DimType::Dynamic,
                                MatrixTransposeMatrixMultiplyTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiply_1_1_1) {
-  TestMatrixTransposeFunctions<1, 1, 1, DimType::Static,
+  TestMatrixTransposeFunctions<1,
+                               1,
+                               1,
+                               DimType::Static,
                                MatrixTransposeMatrixMultiplyTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiply_1_1_1_Dynamic) {
-  TestMatrixTransposeFunctions<1, 1, 1, DimType::Dynamic,
+  TestMatrixTransposeFunctions<1,
+                               1,
+                               1,
+                               DimType::Dynamic,
                                MatrixTransposeMatrixMultiplyTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiply_9_9_9) {
-  TestMatrixTransposeFunctions<9, 9, 9, DimType::Static,
+  TestMatrixTransposeFunctions<9,
+                               9,
+                               9,
+                               DimType::Static,
                                MatrixTransposeMatrixMultiplyTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiply_9_9_9_Dynamic) {
-  TestMatrixTransposeFunctions<9, 9, 9, DimType::Dynamic,
+  TestMatrixTransposeFunctions<9,
+                               9,
+                               9,
+                               DimType::Dynamic,
                                MatrixTransposeMatrixMultiplyTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_5_3_7) {
-  TestMatrixTransposeFunctions<5, 3, 7, DimType::Static,
+  TestMatrixTransposeFunctions<5,
+                               3,
+                               7,
+                               DimType::Static,
                                MatrixTransposeMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_5_3_7_Dynamic) {
-  TestMatrixTransposeFunctions<5, 3, 7, DimType::Dynamic,
+  TestMatrixTransposeFunctions<5,
+                               3,
+                               7,
+                               DimType::Dynamic,
                                MatrixTransposeMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_1_1_1) {
-  TestMatrixTransposeFunctions<1, 1, 1, DimType::Static,
+  TestMatrixTransposeFunctions<1,
+                               1,
+                               1,
+                               DimType::Static,
                                MatrixTransposeMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_1_1_1_Dynamic) {
-  TestMatrixTransposeFunctions<1, 1, 1, DimType::Dynamic,
+  TestMatrixTransposeFunctions<1,
+                               1,
+                               1,
+                               DimType::Dynamic,
                                MatrixTransposeMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_9_9_9) {
-  TestMatrixTransposeFunctions<9, 9, 9, DimType::Static,
+  TestMatrixTransposeFunctions<9,
+                               9,
+                               9,
+                               DimType::Static,
                                MatrixTransposeMatrixMultiplyNaiveTy>()();
 }
 
 TEST(BLAS, MatrixTransposeMatrixMultiplyNaive_9_9_9_Dynamic) {
-  TestMatrixTransposeFunctions<9, 9, 9, DimType::Dynamic,
+  TestMatrixTransposeFunctions<9,
+                               9,
+                               9,
+                               DimType::Dynamic,
                                MatrixTransposeMatrixMultiplyNaiveTy>()();
 }
 
@@ -473,5 +618,5 @@
   }
 }
 
-} // namespace internal
-} // namespace ceres
+}  // namespace internal
+}  // namespace ceres