diff --git a/internal/ceres/line_search_minimizer.cc b/internal/ceres/line_search_minimizer.cc
index f57c047..931f56c 100644
--- a/internal/ceres/line_search_minimizer.cc
+++ b/internal/ceres/line_search_minimizer.cc
@@ -118,9 +118,9 @@
   // Do initial cost and gradient evaluation.
   if (!evaluator->Evaluate(x.data(),
                            &(current_state.cost),
-                           NULL,
+                           nullptr,
                            current_state.gradient.data(),
-                           NULL)) {
+                           nullptr)) {
     summary->termination_type = FAILURE;
     summary->message = "Initial cost and jacobian evaluation failed.";
     LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
@@ -193,7 +193,7 @@
       line_search(LineSearch::Create(options.line_search_type,
                                      line_search_options,
                                      &summary->message));
-  if (line_search.get() == NULL) {
+  if (line_search.get() == nullptr) {
     summary->termination_type = FAILURE;
     LOG_IF(ERROR, is_not_silent) << "Terminating: " << summary->message;
     return;
@@ -338,9 +338,9 @@
       if (!evaluator->Evaluate(evaluate_options,
                                optimal_point.vector_x.data(),
                                &(current_state.cost),
-                               NULL,
+                               nullptr,
                                current_state.gradient.data(),
-                               NULL)) {
+                               nullptr)) {
         summary->termination_type = FAILURE;
         summary->message = "Cost and jacobian evaluation failed.";
         LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
diff --git a/internal/ceres/program_evaluator.h b/internal/ceres/program_evaluator.h
index 4e174eb..5daface 100644
--- a/internal/ceres/program_evaluator.h
+++ b/internal/ceres/program_evaluator.h
@@ -104,12 +104,12 @@
   void operator()(SparseMatrix* jacobian, int num_parameters) {}
 };
 
-template<typename EvaluatePreparer,
-         typename JacobianWriter,
-         typename JacobianFinalizer = NullJacobianFinalizer>
+template <typename EvaluatePreparer,
+          typename JacobianWriter,
+          typename JacobianFinalizer = NullJacobianFinalizer>
 class ProgramEvaluator : public Evaluator {
  public:
-  ProgramEvaluator(const Evaluator::Options &options, Program* program)
+  ProgramEvaluator(const Evaluator::Options& options, Program* program)
       : options_(options),
         program_(program),
         jacobian_writer_(options, program),
@@ -117,17 +117,16 @@
             jacobian_writer_.CreateEvaluatePreparers(options.num_threads)) {
 #ifdef CERES_NO_THREADS
     if (options_.num_threads > 1) {
-      LOG(WARNING)
-          << "No threading support is compiled into this binary; "
-          << "only options.num_threads = 1 is supported. Switching "
-          << "to single threaded mode.";
+      LOG(WARNING) << "No threading support is compiled into this binary; "
+                   << "only options.num_threads = 1 is supported. Switching "
+                   << "to single threaded mode.";
       options_.num_threads = 1;
     }
-#endif // CERES_NO_THREADS
+#endif  // CERES_NO_THREADS
 
     BuildResidualLayout(*program, &residual_layout_);
-    evaluate_scratch_.reset(CreateEvaluatorScratch(*program,
-                                                   options.num_threads));
+    evaluate_scratch_.reset(
+        CreateEvaluatorScratch(*program, options.num_threads));
   }
 
   // Implementation of Evaluator interface.
@@ -142,10 +141,10 @@
                 double* gradient,
                 SparseMatrix* jacobian) final {
     ScopedExecutionTimer total_timer("Evaluator::Total", &execution_summary_);
-    ScopedExecutionTimer call_type_timer(gradient == NULL && jacobian == NULL
-                                         ? "Evaluator::Residual"
-                                         : "Evaluator::Jacobian",
-                                         &execution_summary_);
+    ScopedExecutionTimer call_type_timer(
+        gradient == nullptr && jacobian == nullptr ? "Evaluator::Residual"
+                                                   : "Evaluator::Jacobian",
+        &execution_summary_);
 
     // The parameters are stateful, so set the state before evaluating.
     if (!program_->StateVectorToParameterBlocks(state)) {
@@ -153,27 +152,28 @@
     }
 
     // Notify the user about a new evaluation point if they are interested.
-    if (options_.evaluation_callback != NULL) {
+    if (options_.evaluation_callback != nullptr) {
       program_->CopyParameterBlockStateToUserState();
       options_.evaluation_callback->PrepareForEvaluation(
-          /*jacobians=*/(gradient != NULL || jacobian != NULL),
+          /*jacobians=*/(gradient != nullptr || jacobian != nullptr),
           evaluate_options.new_evaluation_point);
     }
 
-    if (residuals != NULL) {
+    if (residuals != nullptr) {
       VectorRef(residuals, program_->NumResiduals()).setZero();
     }
 
-    if (jacobian != NULL) {
+    if (jacobian != nullptr) {
       jacobian->SetZero();
     }
 
     // Each thread gets it's own cost and evaluate scratch space.
     for (int i = 0; i < options_.num_threads; ++i) {
       evaluate_scratch_[i].cost = 0.0;
-      if (gradient != NULL) {
+      if (gradient != nullptr) {
         VectorRef(evaluate_scratch_[i].gradient.get(),
-                  program_->NumEffectiveParameters()).setZero();
+                  program_->NumEffectiveParameters())
+            .setZero();
       }
     }
 
@@ -197,16 +197,16 @@
 
           // Prepare block residuals if requested.
           const ResidualBlock* residual_block = program_->residual_blocks()[i];
-          double* block_residuals = NULL;
-          if (residuals != NULL) {
+          double* block_residuals = nullptr;
+          if (residuals != nullptr) {
             block_residuals = residuals + residual_layout_[i];
-          } else if (gradient != NULL) {
+          } else if (gradient != nullptr) {
             block_residuals = scratch->residual_block_residuals.get();
           }
 
           // Prepare block jacobians if requested.
-          double** block_jacobians = NULL;
-          if (jacobian != NULL || gradient != NULL) {
+          double** block_jacobians = nullptr;
+          if (jacobian != nullptr || gradient != nullptr) {
             preparer->Prepare(residual_block,
                               i,
                               jacobian,
@@ -229,15 +229,13 @@
           scratch->cost += block_cost;
 
           // Store the jacobians, if they were requested.
-          if (jacobian != NULL) {
-            jacobian_writer_.Write(i,
-                                   residual_layout_[i],
-                                   block_jacobians,
-                                   jacobian);
+          if (jacobian != nullptr) {
+            jacobian_writer_.Write(
+                i, residual_layout_[i], block_jacobians, jacobian);
           }
 
           // Compute and store the gradient, if it was requested.
-          if (gradient != NULL) {
+          if (gradient != nullptr) {
             int num_residuals = residual_block->NumResiduals();
             int num_parameter_blocks = residual_block->NumParameterBlocks();
             for (int j = 0; j < num_parameter_blocks; ++j) {
@@ -262,12 +260,12 @@
 
       // Sum the cost and gradient (if requested) from each thread.
       (*cost) = 0.0;
-      if (gradient != NULL) {
+      if (gradient != nullptr) {
         VectorRef(gradient, num_parameters).setZero();
       }
       for (int i = 0; i < options_.num_threads; ++i) {
         (*cost) += evaluate_scratch_[i].cost;
-        if (gradient != NULL) {
+        if (gradient != nullptr) {
           VectorRef(gradient, num_parameters) +=
               VectorRef(evaluate_scratch_[i].gradient.get(), num_parameters);
         }
@@ -277,7 +275,7 @@
       // `num_parameters` is passed to the finalizer so that additional
       // storage can be reserved for additional diagonal elements if
       // necessary.
-      if (jacobian != NULL) {
+      if (jacobian != nullptr) {
         JacobianFinalizer f;
         f(jacobian, num_parameters);
       }
@@ -291,16 +289,12 @@
     return program_->Plus(state, delta, state_plus_delta);
   }
 
-  int NumParameters() const final {
-    return program_->NumParameters();
-  }
+  int NumParameters() const final { return program_->NumParameters(); }
   int NumEffectiveParameters() const final {
     return program_->NumEffectiveParameters();
   }
 
-  int NumResiduals() const final {
-    return program_->NumResiduals();
-  }
+  int NumResiduals() const final { return program_->NumResiduals(); }
 
   std::map<std::string, CallStatistics> Statistics() const final {
     return execution_summary_.statistics();
@@ -319,8 +313,7 @@
       VectorRef(gradient.get(), num_parameters).setZero();
       residual_block_residuals.reset(
           new double[max_residuals_per_residual_block]);
-      jacobian_block_ptrs.reset(
-          new double*[max_parameters_per_residual_block]);
+      jacobian_block_ptrs.reset(new double*[max_parameters_per_residual_block]);
     }
 
     double cost;
diff --git a/internal/ceres/trust_region_minimizer.cc b/internal/ceres/trust_region_minimizer.cc
index aacd991..7065977 100644
--- a/internal/ceres/trust_region_minimizer.cc
+++ b/internal/ceres/trust_region_minimizer.cc
@@ -34,8 +34,8 @@
 #include <cmath>
 #include <cstdlib>
 #include <cstring>
-#include <memory>
 #include <limits>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -146,7 +146,7 @@
 
   is_not_silent_ = !options.is_silent;
   inner_iterations_are_enabled_ =
-      options.inner_iteration_minimizer.get() != NULL;
+      options.inner_iteration_minimizer.get() != nullptr;
   inner_iterations_were_useful_ = false;
 
   num_parameters_ = evaluator_->NumParameters();
@@ -491,8 +491,11 @@
   options_.inner_iteration_minimizer->Minimize(
       options_, inner_iteration_x_.data(), &inner_iteration_summary);
   double inner_iteration_cost;
-  if (!evaluator_->Evaluate(
-          inner_iteration_x_.data(), &inner_iteration_cost, NULL, NULL, NULL)) {
+  if (!evaluator_->Evaluate(inner_iteration_x_.data(),
+                            &inner_iteration_cost,
+                            nullptr,
+                            nullptr,
+                            nullptr)) {
     VLOG_IF(2, is_not_silent_) << "Inner iteration failed.";
     return;
   }
@@ -610,10 +613,11 @@
     return false;
   }
 
-  solver_summary_->message = StringPrintf("Maximum solver time reached. "
-                                          "Total solver time: %e >= %e.",
-                                          total_solver_time,
-                                          options_.max_solver_time_in_seconds);
+  solver_summary_->message = StringPrintf(
+      "Maximum solver time reached. "
+      "Total solver time: %e >= %e.",
+      total_solver_time,
+      options_.max_solver_time_in_seconds);
   solver_summary_->termination_type = NO_CONVERGENCE;
   VLOG_IF(1, is_not_silent_) << "Terminating: " << solver_summary_->message;
   return true;
@@ -627,10 +631,10 @@
     return false;
   }
 
-  solver_summary_->message =
-      StringPrintf("Maximum number of iterations reached. "
-                   "Number of iterations: %d.",
-                   iteration_summary_.iteration);
+  solver_summary_->message = StringPrintf(
+      "Maximum number of iterations reached. "
+      "Number of iterations: %d.",
+      iteration_summary_.iteration);
 
   solver_summary_->termination_type = NO_CONVERGENCE;
   VLOG_IF(1, is_not_silent_) << "Terminating: " << solver_summary_->message;
@@ -662,11 +666,11 @@
     return false;
   }
 
-  solver_summary_->message =
-      StringPrintf("Minimum trust region radius reached. "
-                   "Trust region radius: %e <= %e",
-                   iteration_summary_.trust_region_radius,
-                   options_.min_trust_region_radius);
+  solver_summary_->message = StringPrintf(
+      "Minimum trust region radius reached. "
+      "Trust region radius: %e <= %e",
+      iteration_summary_.trust_region_radius,
+      options_.min_trust_region_radius);
   solver_summary_->termination_type = CONVERGENCE;
   VLOG_IF(1, is_not_silent_) << "Terminating: " << solver_summary_->message;
   return true;
@@ -734,7 +738,7 @@
   }
 
   if (!evaluator_->Evaluate(
-          candidate_x_.data(), &candidate_cost_, NULL, NULL, NULL)) {
+          candidate_x_.data(), &candidate_cost_, nullptr, nullptr, nullptr)) {
     LOG_IF(WARNING, is_not_silent_)
         << "Step failed to evaluate. "
         << "Treating it as a step with infinite cost";