Rename LinearSolverTerminationType enums.

This increases clarity, drops redundant enums and makes things
cleaner all around.

Change-Id: I761f195ddf17ea6bd8e4e55bf5a72863660c4c3b

internal/ceres/conjugate_gradients_solver.cc

@@ -74,7 +74,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
   CHECK_EQ(A->num_rows(), A->num_cols());
 
   LinearSolver::Summary summary;
-  summary.termination_type = MAX_ITERATIONS;
+  summary.termination_type = LINEAR_SOLVER_NO_CONVERGENCE;
   summary.message = "Maximum number of iterations reached.";
   summary.num_iterations = 0;
 
@@ -85,7 +85,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
   const double norm_b = bref.norm();
   if (norm_b == 0.0) {
     xref.setZero();
-    summary.termination_type = TOLERANCE;
+    summary.termination_type = LINEAR_SOLVER_SUCCESS;
     summary.message = "Convergence. |b| = 0.";
     return summary;
   }
@@ -102,7 +102,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
   r = bref - tmp;
   double norm_r = r.norm();
   if (norm_r <= tol_r) {
-    summary.termination_type = TOLERANCE;
+    summary.termination_type = LINEAR_SOLVER_SUCCESS;
     summary.message =
         StringPrintf("Convergence. |r| = %e <= %e.", norm_r, tol_r);
     return summary;
@@ -127,7 +127,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
     double last_rho = rho;
     rho = r.dot(z);
     if (IsZeroOrInfinity(rho)) {
-      summary.termination_type = FAILURE;
+      summary.termination_type = LINEAR_SOLVER_FAILURE;
       summary.message = StringPrintf("Numerical failure. rho = r'z = %e.", rho);
       break;
     };
@@ -137,7 +137,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
     } else {
       double beta = rho / last_rho;
       if (IsZeroOrInfinity(beta)) {
-        summary.termination_type = FAILURE;
+        summary.termination_type = LINEAR_SOLVER_FAILURE;
         summary.message = StringPrintf(
             "Numerical failure. beta = rho_n / rho_{n-1} = %e.", beta);
         break;
@@ -150,14 +150,14 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
     A->RightMultiply(p.data(), q.data());
     const double pq = p.dot(q);
     if ((pq <= 0) || IsInfinite(pq))  {
-      summary.termination_type = FAILURE;
+      summary.termination_type = LINEAR_SOLVER_FAILURE;
       summary.message = StringPrintf("Numerical failure. p'q = %e.", pq);
       break;
     }
 
     const double alpha = rho / pq;
     if (IsInfinite(alpha)) {
-      summary.termination_type = FAILURE;
+      summary.termination_type = LINEAR_SOLVER_FAILURE;
       summary.message =
           StringPrintf("Numerical failure. alpha = rho / pq = %e", alpha);
       break;
@@ -208,7 +208,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
     //
     const double zeta = summary.num_iterations * (Q1 - Q0) / Q1;
     if (zeta < per_solve_options.q_tolerance) {
-      summary.termination_type = TOLERANCE;
+      summary.termination_type = LINEAR_SOLVER_SUCCESS;
       summary.message =
           StringPrintf("Convergence: zeta = %e < %e",
                        zeta,
@@ -220,7 +220,7 @@ LinearSolver::Summary ConjugateGradientsSolver::Solve(
     // Residual based termination.
     norm_r = r. norm();
     if (norm_r <= tol_r) {
-      summary.termination_type = TOLERANCE;
+      summary.termination_type = LINEAR_SOLVER_SUCCESS;
       summary.message =
           StringPrintf("Convergence. |r| = %e <= %e.", norm_r, tol_r);
       break;

internal/ceres/covariance_impl.cc

@@ -454,7 +454,7 @@ bool CovarianceImpl::ComputeCovarianceValuesUsingSparseCholesky() {
   LinearSolverTerminationType termination_type =
       ss.Cholesky(&cholmod_jacobian_view, factor, &status);
   event_logger.AddEvent("Numeric Factorization");
-  if (termination_type != TOLERANCE) {
+  if (termination_type != LINEAR_SOLVER_SUCCESS) {
     LOG(ERROR) << "Covariance estimation failed. "
                << "CHOLMOD numeric cholesky factorization returned with: "
                << status;

internal/ceres/dense_normal_cholesky_solver.cc

@@ -95,15 +95,15 @@ LinearSolver::Summary DenseNormalCholeskySolver::SolveUsingEigen(
 
   LinearSolver::Summary summary;
   summary.num_iterations = 1;
-  summary.termination_type = TOLERANCE;
+  summary.termination_type = LINEAR_SOLVER_SUCCESS;
   Eigen::LLT<Matrix, Eigen::Upper> llt =
       lhs.selfadjointView<Eigen::Upper>().llt();
 
   if (llt.info() != Eigen::Success) {
-    summary.termination_type = FAILURE;
+    summary.termination_type = LINEAR_SOLVER_FAILURE;
     summary.message = "Eigen LLT decomposition failed.";
   } else {
-    summary.termination_type = TOLERANCE;
+    summary.termination_type = LINEAR_SOLVER_SUCCESS;
     summary.message = "Success.";
   }
 

internal/ceres/dense_qr_solver.cc

@@ -111,7 +111,7 @@ LinearSolver::Summary DenseQRSolver::SolveUsingLAPACK(
                                                          rhs_.data(),
                                                          &summary.message);
   event_logger.AddEvent("Solve");
-  if (summary.termination_type == TOLERANCE) {
+  if (summary.termination_type == LINEAR_SOLVER_SUCCESS) {
     VectorRef(x, num_cols) = rhs_.head(num_cols);
   }
 
@@ -159,7 +159,7 @@ LinearSolver::Summary DenseQRSolver::SolveUsingEigen(
   // is good enough or not.
   LinearSolver::Summary summary;
   summary.num_iterations = 1;
-  summary.termination_type = TOLERANCE;
+  summary.termination_type = LINEAR_SOLVER_SUCCESS;
   summary.message = "Success.";
 
   event_logger.AddEvent("TearDown");

internal/ceres/dogleg_strategy.cc

@@ -99,7 +99,7 @@ TrustRegionStrategy::Summary DoglegStrategy::ComputeStep(
     }
     TrustRegionStrategy::Summary summary;
     summary.num_iterations = 0;
-    summary.termination_type = TOLERANCE;
+    summary.termination_type = LINEAR_SOLVER_SUCCESS;
     return summary;
   }
 
@@ -135,11 +135,11 @@ TrustRegionStrategy::Summary DoglegStrategy::ComputeStep(
   summary.num_iterations = linear_solver_summary.num_iterations;
   summary.termination_type = linear_solver_summary.termination_type;
 
-  if (linear_solver_summary.termination_type == FATAL_ERROR) {
+  if (linear_solver_summary.termination_type == LINEAR_SOLVER_FATAL_ERROR) {
     return summary;
   }
 
-  if (linear_solver_summary.termination_type != FAILURE) {
+  if (linear_solver_summary.termination_type != LINEAR_SOLVER_FAILURE) {
     switch (dogleg_type_) {
       // Interpolate the Cauchy point and the Gauss-Newton step.
       case TRADITIONAL_DOGLEG:
@@ -150,7 +150,7 @@ TrustRegionStrategy::Summary DoglegStrategy::ComputeStep(
       // Cauchy point and the (Gauss-)Newton step.
       case SUBSPACE_DOGLEG:
         if (!ComputeSubspaceModel(jacobian)) {
-          summary.termination_type = FAILURE;
+          summary.termination_type = LINEAR_SOLVER_FAILURE;
           break;
         }
         ComputeSubspaceDoglegStep(step);
@@ -517,7 +517,7 @@ LinearSolver::Summary DoglegStrategy::ComputeGaussNewtonStep(
     const double* residuals) {
   const int n = jacobian->num_cols();
   LinearSolver::Summary linear_solver_summary;
-  linear_solver_summary.termination_type = FAILURE;
+  linear_solver_summary.termination_type = LINEAR_SOLVER_FAILURE;
 
   // The Jacobian matrix is often quite poorly conditioned. Thus it is
   // necessary to add a diagonal matrix at the bottom to prevent the
@@ -530,7 +530,7 @@ LinearSolver::Summary DoglegStrategy::ComputeGaussNewtonStep(
   // If the solve fails, the multiplier to the diagonal is increased
   // up to max_mu_ by a factor of mu_increase_factor_ every time. If
   // the linear solver is still not successful, the strategy returns
-  // with FAILURE.
+  // with LINEAR_SOLVER_FAILURE.
   //
   // Next time when a new Gauss-Newton step is requested, the
   // multiplier starts out from the last successful solve.
@@ -583,21 +583,21 @@ LinearSolver::Summary DoglegStrategy::ComputeGaussNewtonStep(
       }
     }
 
-    if (linear_solver_summary.termination_type == FATAL_ERROR) {
+    if (linear_solver_summary.termination_type == LINEAR_SOLVER_FATAL_ERROR) {
       return linear_solver_summary;
     }
 
-    if (linear_solver_summary.termination_type == FAILURE ||
+    if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE ||
         !IsArrayValid(n, gauss_newton_step_.data())) {
       mu_ *= mu_increase_factor_;
       VLOG(2) << "Increasing mu " << mu_;
-      linear_solver_summary.termination_type = FAILURE;
+      linear_solver_summary.termination_type = LINEAR_SOLVER_FAILURE;
       continue;
     }
     break;
   }
 
-  if (linear_solver_summary.termination_type != FAILURE) {
+  if (linear_solver_summary.termination_type != LINEAR_SOLVER_FAILURE) {
     // The scaled Gauss-Newton step is D * GN:
     //
     //     - (D^-1 J^T J D^-1)^-1 (D^-1 g)

internal/ceres/dogleg_strategy_test.cc

@@ -144,7 +144,7 @@ TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedTraditional) {
                                                               residual_.data(),
                                                               x_.data());
 
-  EXPECT_NE(summary.termination_type, FAILURE);
+  EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_LE(x_.norm(), options_.initial_radius * (1.0 + 4.0 * kEpsilon));
 }
 
@@ -164,7 +164,7 @@ TEST_F(DoglegStrategyFixtureEllipse, TrustRegionObeyedSubspace) {
                                                               residual_.data(),
                                                               x_.data());
 
-  EXPECT_NE(summary.termination_type, FAILURE);
+  EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_LE(x_.norm(), options_.initial_radius * (1.0 + 4.0 * kEpsilon));
 }
 
@@ -184,7 +184,7 @@ TEST_F(DoglegStrategyFixtureEllipse, CorrectGaussNewtonStep) {
                                                               residual_.data(),
                                                               x_.data());
 
-  EXPECT_NE(summary.termination_type, FAILURE);
+  EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_NEAR(x_(0), 1.0, kToleranceLoose);
   EXPECT_NEAR(x_(1), 1.0, kToleranceLoose);
   EXPECT_NEAR(x_(2), 1.0, kToleranceLoose);
@@ -246,7 +246,7 @@ TEST_F(DoglegStrategyFixtureValley, CorrectStepLocalOptimumAlongGradient) {
                                                               residual_.data(),
                                                               x_.data());
 
-  EXPECT_NE(summary.termination_type, FAILURE);
+  EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_NEAR(x_(0), 0.0, kToleranceLoose);
   EXPECT_NEAR(x_(1), 0.0, kToleranceLoose);
   EXPECT_NEAR(x_(2), options_.initial_radius, kToleranceLoose);
@@ -274,7 +274,7 @@ TEST_F(DoglegStrategyFixtureValley, CorrectStepGlobalOptimumAlongGradient) {
                                                               residual_.data(),
                                                               x_.data());
 
-  EXPECT_NE(summary.termination_type, FAILURE);
+  EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
   EXPECT_NEAR(x_(0), 0.0, kToleranceLoose);
   EXPECT_NEAR(x_(1), 0.0, kToleranceLoose);
   EXPECT_NEAR(x_(2), 1.0, kToleranceLoose);

internal/ceres/gmock_gtest_all.cc

@@ -4364,7 +4364,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
   int num_disabled = unit_test.reportable_disabled_test_count();
   if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
     if (!num_failures) {
-      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+      printf("\n");  // Add a spacer if no LINEAR_SOLVER_FAILURE banner is displayed.
     }
     ColoredPrintf(COLOR_YELLOW,
                   "  YOU HAVE %d DISABLED %s\n\n",

internal/ceres/iterative_schur_complement_solver.cc

@@ -88,7 +88,7 @@ LinearSolver::Summary IterativeSchurComplementSolver::SolveImpl(
     VLOG(2) << "No parameter blocks left in the schur complement.";
     LinearSolver::Summary cg_summary;
     cg_summary.num_iterations = 0;
-    cg_summary.termination_type = TOLERANCE;
+    cg_summary.termination_type = LINEAR_SOLVER_SUCCESS;
     schur_complement_->BackSubstitute(NULL, x);
     return cg_summary;
   }
@@ -157,7 +157,7 @@ LinearSolver::Summary IterativeSchurComplementSolver::SolveImpl(
 
   LinearSolver::Summary cg_summary;
   cg_summary.num_iterations = 0;
-  cg_summary.termination_type = FAILURE;
+  cg_summary.termination_type = LINEAR_SOLVER_FAILURE;
 
   // TODO(sameeragarwal): Refactor preconditioners to return a more
   // sane message.
@@ -167,8 +167,8 @@ LinearSolver::Summary IterativeSchurComplementSolver::SolveImpl(
                                  schur_complement_->rhs().data(),
                                  cg_per_solve_options,
                                  reduced_linear_system_solution_.data());
-    if (cg_summary.termination_type != FAILURE &&
-        cg_summary.termination_type != FATAL_ERROR) {
+    if (cg_summary.termination_type != LINEAR_SOLVER_FAILURE &&
+        cg_summary.termination_type != LINEAR_SOLVER_FATAL_ERROR) {
       schur_complement_->BackSubstitute(
           reduced_linear_system_solution_.data(), x);
     }

internal/ceres/lapack.cc

@@ -73,7 +73,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingCholesky(
     string* status) {
 #ifdef CERES_NO_LAPACK
   LOG(FATAL) << "Ceres was built without a BLAS library.";
-  return FATAL_ERROR;
+  return LINEAR_SOLVER_FATAL_ERROR;
 #else
   char uplo = 'L';
   int n = num_rows;
@@ -87,7 +87,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingCholesky(
                << "Please report it."
                << "LAPACK::dpotrf fatal error."
                << "Argument: " << -info << " is invalid.";
-    return FATAL_ERROR;
+    return LINEAR_SOLVER_FATAL_ERROR;
   }
 
   if (info > 0) {
@@ -95,7 +95,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingCholesky(
         StringPrintf(
             "LAPACK::dpotrf numerical failure. "
              "The leading minor of order %d  is not positive definite.", info);
-    return FAILURE;
+    return LINEAR_SOLVER_FAILURE;
   }
 
   dpotrs_(&uplo, &n, &nrhs, lhs, &n, rhs_and_solution, &n, &info);
@@ -104,11 +104,11 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingCholesky(
                << "Please report it."
                << "LAPACK::dpotrs fatal error."
                << "Argument: " << -info << " is invalid.";
-    return FATAL_ERROR;
+    return LINEAR_SOLVER_FATAL_ERROR;
   }
 
   *status = "Success";
-  return TOLERANCE;
+  return LINEAR_SOLVER_SUCCESS;
 #endif
 };
 
@@ -154,7 +154,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingQR(
     string* status) {
 #ifdef CERES_NO_LAPACK
   LOG(FATAL) << "Ceres was built without a LAPACK library.";
-  return FATAL_ERROR;
+  return LINEAR_SOLVER_FATAL_ERROR;
 #else
   char trans = 'N';
   int m = num_rows;
@@ -185,7 +185,7 @@ LinearSolverTerminationType LAPACK::SolveInPlaceUsingQR(
   }
 
   *status = "Success.";
-  return TOLERANCE;
+  return LINEAR_SOLVER_SUCCESS;
 #endif
 }
 

internal/ceres/levenberg_marquardt_strategy.cc

@@ -106,12 +106,12 @@ TrustRegionStrategy::Summary LevenbergMarquardtStrategy::ComputeStep(
   LinearSolver::Summary linear_solver_summary =
       linear_solver_->Solve(jacobian, residuals, solve_options, step);
 
-  if (linear_solver_summary.termination_type == FATAL_ERROR) {
+  if (linear_solver_summary.termination_type == LINEAR_SOLVER_FATAL_ERROR) {
     LOG(WARNING) << "Linear solver fatal error.";
-  } else if (linear_solver_summary.termination_type == FAILURE ||
+  } else if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE ||
              !IsArrayValid(num_parameters, step)) {
     LOG(WARNING) << "Linear solver failure. Failed to compute a finite step.";
-    linear_solver_summary.termination_type = FAILURE;
+    linear_solver_summary.termination_type = LINEAR_SOLVER_FAILURE;
   } else {
     VectorRef(step, num_parameters) *= -1.0;
   }

internal/ceres/levenberg_marquardt_strategy_test.cc

@@ -150,7 +150,7 @@ TEST(LevenbergMarquardtStrategy, CorrectDiagonalToLinearSolver) {
 
     TrustRegionStrategy::Summary summary =
         lms.ComputeStep(pso, &dsm, &residual, x);
-    EXPECT_EQ(summary.termination_type, FAILURE);
+    EXPECT_EQ(summary.termination_type, LINEAR_SOLVER_FAILURE);
   }
 }
 

internal/ceres/linear_solver.h

@@ -51,26 +51,19 @@ namespace ceres {
 namespace internal {
 
 enum LinearSolverTerminationType {
-  // Termination criterion was met. For factorization based solvers
-  // the tolerance is assumed to be zero. Any user provided values are
-  // ignored.
-  TOLERANCE,
+  // Termination criterion was met.
+  LINEAR_SOLVER_SUCCESS,
 
   // Solver ran for max_num_iterations and terminated before the
-  // termination tolerance could be satified.
-  MAX_ITERATIONS,
+  // termination tolerance could be satisfied.
+  LINEAR_SOLVER_NO_CONVERGENCE,
 
-  // Solver is stuck and further iterations will not result in any
-  // measurable progress.
-  STAGNATION,
-
-  // Solver failed. Solver was terminated due to numerical errors. The
-  // exact cause of failure depends on the particular solver being
-  // used.
-  FAILURE,
+  // Solver was terminated due to numerical problems, generally due to
+  // the linear system being poorly conditioned.
+  LINEAR_SOLVER_FAILURE,
 
   // Solver failed with a fatal error that cannot be recovered from.
-  FATAL_ERROR
+  LINEAR_SOLVER_FATAL_ERROR
 };
 
 
@@ -267,7 +260,7 @@ class LinearSolver {
     Summary()
         : residual_norm(0.0),
           num_iterations(-1),
-          termination_type(FAILURE) {
+          termination_type(LINEAR_SOLVER_FAILURE) {
     }
 
     double residual_norm;

internal/ceres/schur_complement_solver.cc

@@ -83,7 +83,7 @@ LinearSolver::Summary SchurComplementSolver::SolveImpl(
       SolveReducedLinearSystem(reduced_solution);
   event_logger.AddEvent("ReducedSolve");
 
-  if (summary.termination_type == TOLERANCE) {
+  if (summary.termination_type == LINEAR_SOLVER_SUCCESS) {
     eliminator_->BackSubstitute(A, b, per_solve_options.D, reduced_solution, x);
     event_logger.AddEvent("BackSubstitute");
   }
@@ -116,7 +116,7 @@ LinearSolver::Summary
 DenseSchurComplementSolver::SolveReducedLinearSystem(double* solution) {
   LinearSolver::Summary summary;
   summary.num_iterations = 0;
-  summary.termination_type = TOLERANCE;
+  summary.termination_type = LINEAR_SOLVER_SUCCESS;
   summary.message = "Success.";
 
   const BlockRandomAccessDenseMatrix* m =
@@ -137,7 +137,7 @@ DenseSchurComplementSolver::SolveReducedLinearSystem(double* solution) {
         .selfadjointView<Eigen::Upper>()
         .llt();
     if (llt.info() != Eigen::Success) {
-      summary.termination_type = FAILURE;
+      summary.termination_type = LINEAR_SOLVER_FAILURE;
       summary.message = "Eigen LLT decomposition failed.";
       return summary;
     }
@@ -275,7 +275,7 @@ SparseSchurComplementSolver::SolveReducedLinearSystemUsingSuiteSparse(
     double* solution) {
   LinearSolver::Summary summary;
   summary.num_iterations = 0;
-  summary.termination_type = TOLERANCE;
+  summary.termination_type = LINEAR_SOLVER_SUCCESS;
   summary.message = "Success.";
 
   TripletSparseMatrix* tsm =
@@ -325,13 +325,13 @@ SparseSchurComplementSolver::SolveReducedLinearSystemUsingSuiteSparse(
 
   if (factor_ == NULL) {
     ss_.Free(cholmod_lhs);
-    summary.termination_type = FATAL_ERROR;
+    summary.termination_type = LINEAR_SOLVER_FATAL_ERROR;
     return summary;
   }
 
   summary.termination_type =
       ss_.Cholesky(cholmod_lhs, factor_, &summary.message);
-  if (summary.termination_type != TOLERANCE) {
+  if (summary.termination_type != LINEAR_SOLVER_SUCCESS) {
     return summary;
   }
 
@@ -344,7 +344,7 @@ SparseSchurComplementSolver::SolveReducedLinearSystemUsingSuiteSparse(
   ss_.Free(cholmod_rhs);
 
   if (cholmod_solution == NULL) {
-    summary.termination_type = FAILURE;
+    summary.termination_type = LINEAR_SOLVER_FAILURE;
     return summary;
   }
 
@@ -371,7 +371,7 @@ SparseSchurComplementSolver::SolveReducedLinearSystemUsingCXSparse(
     double* solution) {
   LinearSolver::Summary summary;
   summary.num_iterations = 0;
-  summary.termination_type = TOLERANCE;
+  summary.termination_type = LINEAR_SOLVER_SUCCESS;
   summary.message = "Success.";
 
   // Extract the TripletSparseMatrix that is used for actually storing S.
@@ -395,11 +395,11 @@ SparseSchurComplementSolver::SolveReducedLinearSystemUsingCXSparse(
   }
 
   if (cxsparse_factor_ == NULL) {
-    summary.termination_type = FATAL_ERROR;
+    summary.termination_type = LINEAR_SOLVER_FATAL_ERROR;
     summary.message =
         "CXSparse failure. Unable to find symbolic factorization.";
   } else if (!cxsparse_.SolveCholesky(lhs, cxsparse_factor_, solution)) {
-    summary.termination_type = FAILURE;
+    summary.termination_type = LINEAR_SOLVER_FAILURE;
     summary.message = "CXSparse::SolveCholesky failed.";
   }
 

internal/ceres/sparse_normal_cholesky_solver.cc

@@ -102,7 +102,7 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse(
 
   LinearSolver::Summary summary;
   summary.num_iterations = 1;
-  summary.termination_type = TOLERANCE;
+  summary.termination_type = LINEAR_SOLVER_SUCCESS;
   summary.message = "Success.";
 
   const int num_cols = A->num_cols();
@@ -150,13 +150,13 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingCXSparse(
   event_logger.AddEvent("Analysis");
 
   if (cxsparse_factor_ == NULL) {
-    summary.termination_type = FATAL_ERROR;
+    summary.termination_type = LINEAR_SOLVER_FATAL_ERROR;
     summary.message =
         "CXSparse failure. Unable to find symbolic factorization.";
   } else if (cxsparse_.SolveCholesky(AtA, cxsparse_factor_, Atb.data())) {
     VectorRef(x, Atb.rows()) = Atb;
   } else {
-    summary.termination_type = FAILURE;
+    summary.termination_type = LINEAR_SOLVER_FAILURE;
   }
   event_logger.AddEvent("Solve");
 
@@ -185,7 +185,7 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingSuiteSparse(
     double * x) {
   EventLogger event_logger("SparseNormalCholeskySolver::SuiteSparse::Solve");
   LinearSolver::Summary summary;
-  summary.termination_type = TOLERANCE;
+  summary.termination_type = LINEAR_SOLVER_SUCCESS;
   summary.num_iterations = 1;
   summary.message = "Success.";
 
@@ -220,12 +220,12 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingSuiteSparse(
     if (per_solve_options.D != NULL) {
       A->DeleteRows(num_cols);
     }
-    summary.termination_type = FATAL_ERROR;
+    summary.termination_type = LINEAR_SOLVER_FATAL_ERROR;
     return summary;
   }
 
   summary.termination_type = ss_.Cholesky(&lhs, factor_, &summary.message);
-  if (summary.termination_type != TOLERANCE) {
+  if (summary.termination_type != LINEAR_SOLVER_SUCCESS) {
     if (per_solve_options.D != NULL) {
       A->DeleteRows(num_cols);
     }
@@ -245,7 +245,7 @@ LinearSolver::Summary SparseNormalCholeskySolver::SolveImplUsingSuiteSparse(
     memcpy(x, sol->x, num_cols * sizeof(*x));
     ss_.Free(sol);
   } else {
-    summary.termination_type = FAILURE;
+    summary.termination_type = LINEAR_SOLVER_FAILURE;
   }
 
   event_logger.AddEvent("Teardown");

internal/ceres/suitesparse.cc

@@ -269,41 +269,41 @@ LinearSolverTerminationType SuiteSparse::Cholesky(cholmod_sparse* A,
   switch (cc_.status) {
     case CHOLMOD_NOT_INSTALLED:
       *status = "CHOLMOD failure: Method not installed.";
-      return FATAL_ERROR;
+      return LINEAR_SOLVER_FATAL_ERROR;
     case CHOLMOD_OUT_OF_MEMORY:
       *status = "CHOLMOD failure: Out of memory.";
-      return FATAL_ERROR;
+      return LINEAR_SOLVER_FATAL_ERROR;
     case CHOLMOD_TOO_LARGE:
       *status = "CHOLMOD failure: Integer overflow occured.";
-      return FATAL_ERROR;
+      return LINEAR_SOLVER_FATAL_ERROR;
     case CHOLMOD_INVALID:
       *status = "CHOLMOD failure: Invalid input.";
-      return FATAL_ERROR;
+      return LINEAR_SOLVER_FATAL_ERROR;
     case CHOLMOD_NOT_POSDEF:
       *status = "CHOLMOD warning: Matrix not positive definite.";
-      return FAILURE;
+      return LINEAR_SOLVER_FAILURE;
     case CHOLMOD_DSMALL:
       *status = "CHOLMOD warning: D for LDL' or diag(L) or "
                 "LL' has tiny absolute value.";
-      return FAILURE;
+      return LINEAR_SOLVER_FAILURE;
     case CHOLMOD_OK:
       if (cholmod_status != 0) {
-        return TOLERANCE;
+        return LINEAR_SOLVER_SUCCESS;
       }
 
       *status = "CHOLMOD failure: cholmod_factorize returned false "
                 "but cholmod_common::status is CHOLMOD_OK."
                 "Please report this to ceres-solver@googlegroups.com.";
-      return FATAL_ERROR;
+      return LINEAR_SOLVER_FATAL_ERROR;
     default:
       *status =
           StringPrintf("Unknown cholmod return code: %d. "
                        "Please report this to ceres-solver@googlegroups.com.",
                        cc_.status);
-      return FATAL_ERROR;
+      return LINEAR_SOLVER_FATAL_ERROR;
   }
 
-  return FATAL_ERROR;
+  return LINEAR_SOLVER_FATAL_ERROR;
 }
 
 cholmod_dense* SuiteSparse::Solve(cholmod_factor* L,

internal/ceres/symmetric_linear_solver_test.cc

@@ -71,7 +71,7 @@ TEST(ConjugateGradientTest, Solves3x3IdentitySystem) {
   LinearSolver::Summary summary =
       solver.Solve(A.get(), b.data(), per_solve_options, x.data());
 
-  EXPECT_EQ(summary.termination_type, TOLERANCE);
+  EXPECT_EQ(summary.termination_type, LINEAR_SOLVER_SUCCESS);
   ASSERT_EQ(summary.num_iterations, 1);
 
   ASSERT_DOUBLE_EQ(1, x(0));
@@ -128,7 +128,7 @@ TEST(ConjuateGradientTest, Solves3x3SymmetricSystem) {
   LinearSolver::Summary summary =
       solver.Solve(A.get(), b.data(), per_solve_options, x.data());
 
-  EXPECT_EQ(summary.termination_type, TOLERANCE);
+  EXPECT_EQ(summary.termination_type, LINEAR_SOLVER_SUCCESS);
 
   ASSERT_DOUBLE_EQ(0, x(0));
   ASSERT_DOUBLE_EQ(1, x(1));

internal/ceres/trust_region_minimizer.cc

@@ -227,6 +227,15 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options,
                               residuals.data(),
                               trust_region_step.data());
 
+    if (strategy_summary.termination_type == LINEAR_SOLVER_FATAL_ERROR) {
+      summary->error =
+          "Terminating. Linear solver failed due to unrecoverable "
+          "non-numeric causes. Please see the error log for clues. ";
+      summary->termination_type = NUMERICAL_FAILURE;
+      LOG_IF(WARNING, is_not_silent) << summary->error;
+      return;
+    }
+
     iteration_summary = IterationSummary();
     iteration_summary.iteration = summary->iterations.back().iteration + 1;
     iteration_summary.step_solver_time_in_seconds =
@@ -246,7 +255,7 @@ void TrustRegionMinimizer::Minimize(const Minimizer::Options& options,
     }
 
     double model_cost_change = 0.0;
-    if (strategy_summary.termination_type != FAILURE) {
+    if (strategy_summary.termination_type != LINEAR_SOLVER_FAILURE) {
       // new_model_cost
       //  = 1/2 [f + J * step]^2
       //  = 1/2 [ f'f + 2f'J * step + step' * J' * J * step ]

internal/ceres/trust_region_strategy.h

@@ -106,7 +106,7 @@ class TrustRegionStrategy {
     Summary()
         : residual_norm(0.0),
           num_iterations(-1),
-          termination_type(FAILURE) {
+          termination_type(LINEAR_SOLVER_FAILURE) {
     }
 
     // If the trust region problem is,

internal/ceres/unsymmetric_linear_solver_test.cc

@@ -99,13 +99,13 @@ class UnsymmetricLinearSolverTest : public ::testing::Test {
                       per_solve_options,
                       x_regularized.data());
 
-    EXPECT_EQ(unregularized_solve_summary.termination_type, TOLERANCE);
+    EXPECT_EQ(unregularized_solve_summary.termination_type, LINEAR_SOLVER_SUCCESS);
 
     for (int i = 0; i < A_->num_cols(); ++i) {
       EXPECT_NEAR(sol_unregularized_[i], x_unregularized[i], 1e-8);
     }
 
-    EXPECT_EQ(regularized_solve_summary.termination_type, TOLERANCE);
+    EXPECT_EQ(regularized_solve_summary.termination_type, LINEAR_SOLVER_SUCCESS);
     for (int i = 0; i < A_->num_cols(); ++i) {
       EXPECT_NEAR(sol_regularized_[i], x_regularized[i], 1e-8);
     }

internal/ceres/visibility_based_preconditioner.cc

@@ -370,7 +370,7 @@ bool VisibilityBasedPreconditioner::UpdateImpl(const BlockSparseMatrix& A,
   // scaling is not needed, which is quite often in our experience.
   LinearSolverTerminationType status = Factorize();
 
-  if (status == FATAL_ERROR) {
+  if (status == LINEAR_SOLVER_FATAL_ERROR) {
     return false;
   }
 
@@ -379,7 +379,7 @@ bool VisibilityBasedPreconditioner::UpdateImpl(const BlockSparseMatrix& A,
   // belong to the edges of the degree-2 forest. In the CLUSTER_JACOBI
   // case, the preconditioner is guaranteed to be positive
   // semidefinite.
-  if (status == FAILURE && options_.type == CLUSTER_TRIDIAGONAL) {
+  if (status == LINEAR_SOLVER_FAILURE && options_.type == CLUSTER_TRIDIAGONAL) {
     VLOG(1) << "Unscaled factorization failed. Retrying with off-diagonal "
             << "scaling";
     ScaleOffDiagonalCells();
@@ -387,7 +387,7 @@ bool VisibilityBasedPreconditioner::UpdateImpl(const BlockSparseMatrix& A,
   }
 
   VLOG(2) << "Compute time: " << time(NULL) - start_time;
-  return (status == TOLERANCE);
+  return (status == LINEAR_SOLVER_SUCCESS);
 }
 
 // Consider the preconditioner matrix as meta-block matrix, whose
@@ -444,7 +444,9 @@ LinearSolverTerminationType VisibilityBasedPreconditioner::Factorize() {
   }
 
   const LinearSolverTerminationType termination_type =
-      (factor_ != NULL) ? ss_.Cholesky(lhs, factor_, &status) : FATAL_ERROR;
+      (factor_ != NULL)
+      ? ss_.Cholesky(lhs, factor_, &status)
+      : LINEAR_SOLVER_FATAL_ERROR;
 
   ss_.Free(lhs);
   return termination_type;