diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 229173f..40d9b0e 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -1,5 +1,5 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2015 Google Inc. All rights reserved.
+// Copyright 2023 Google Inc. All rights reserved.
 // http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
@@ -36,12 +36,14 @@
 #include <map>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "ceres/autodiff_cost_function.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/cost_function.h"
 #include "ceres/covariance_impl.h"
-#include "ceres/local_parameterization.h"
+#include "ceres/internal/config.h"
+#include "ceres/manifold.h"
 #include "ceres/map_util.h"
 #include "ceres/problem_impl.h"
 #include "gtest/gtest.h"
@@ -49,11 +51,6 @@
 namespace ceres {
 namespace internal {
 
-using std::make_pair;
-using std::map;
-using std::pair;
-using std::vector;
-
 class UnaryCostFunction : public CostFunction {
  public:
   UnaryCostFunction(const int num_residuals,
@@ -71,19 +68,19 @@
       residuals[i] = 1;
     }
 
-    if (jacobians == NULL) {
+    if (jacobians == nullptr) {
       return true;
     }
 
-    if (jacobians[0] != NULL) {
-      copy(jacobian_.begin(), jacobian_.end(), jacobians[0]);
+    if (jacobians[0] != nullptr) {
+      std::copy(jacobian_.begin(), jacobian_.end(), jacobians[0]);
     }
 
     return true;
   }
 
  private:
-  vector<double> jacobian_;
+  std::vector<double> jacobian_;
 };
 
 class BinaryCostFunction : public CostFunction {
@@ -109,47 +106,24 @@
       residuals[i] = 2;
     }
 
-    if (jacobians == NULL) {
+    if (jacobians == nullptr) {
       return true;
     }
 
-    if (jacobians[0] != NULL) {
-      copy(jacobian1_.begin(), jacobian1_.end(), jacobians[0]);
+    if (jacobians[0] != nullptr) {
+      std::copy(jacobian1_.begin(), jacobian1_.end(), jacobians[0]);
     }
 
-    if (jacobians[1] != NULL) {
-      copy(jacobian2_.begin(), jacobian2_.end(), jacobians[1]);
+    if (jacobians[1] != nullptr) {
+      std::copy(jacobian2_.begin(), jacobian2_.end(), jacobians[1]);
     }
 
     return true;
   }
 
  private:
-  vector<double> jacobian1_;
-  vector<double> jacobian2_;
-};
-
-// x_plus_delta = delta * x;
-class PolynomialParameterization : public LocalParameterization {
- public:
-  virtual ~PolynomialParameterization() {}
-
-  bool Plus(const double* x,
-            const double* delta,
-            double* x_plus_delta) const final {
-    x_plus_delta[0] = delta[0] * x[0];
-    x_plus_delta[1] = delta[0] * x[1];
-    return true;
-  }
-
-  bool ComputeJacobian(const double* x, double* jacobian) const final {
-    jacobian[0] = x[0];
-    jacobian[1] = x[1];
-    return true;
-  }
-
-  int GlobalSize() const final { return 2; }
-  int LocalSize() const final { return 1; }
+  std::vector<double> jacobian1_;
+  std::vector<double> jacobian2_;
 };
 
 TEST(CovarianceImpl, ComputeCovarianceSparsity) {
@@ -165,13 +139,13 @@
   // Add in random order
   Vector junk_jacobian = Vector::Zero(10);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 1, junk_jacobian.data()), NULL, block1);
+      new UnaryCostFunction(1, 1, junk_jacobian.data()), nullptr, block1);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 4, junk_jacobian.data()), NULL, block4);
+      new UnaryCostFunction(1, 4, junk_jacobian.data()), nullptr, block4);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 3, junk_jacobian.data()), NULL, block3);
+      new UnaryCostFunction(1, 3, junk_jacobian.data()), nullptr, block3);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 2, junk_jacobian.data()), NULL, block2);
+      new UnaryCostFunction(1, 2, junk_jacobian.data()), nullptr, block2);
 
   // Sparsity pattern
   //
@@ -206,13 +180,13 @@
                          6, 7, 8, 9};
   // clang-format on
 
-  vector<pair<const double*, const double*>> covariance_blocks;
-  covariance_blocks.push_back(make_pair(block1, block1));
-  covariance_blocks.push_back(make_pair(block4, block4));
-  covariance_blocks.push_back(make_pair(block2, block2));
-  covariance_blocks.push_back(make_pair(block3, block3));
-  covariance_blocks.push_back(make_pair(block2, block3));
-  covariance_blocks.push_back(make_pair(block4, block1));  // reversed
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
+  covariance_blocks.emplace_back(block1, block1);
+  covariance_blocks.emplace_back(block4, block4);
+  covariance_blocks.emplace_back(block2, block2);
+  covariance_blocks.emplace_back(block3, block3);
+  covariance_blocks.emplace_back(block2, block3);
+  covariance_blocks.emplace_back(block4, block1);  // reversed
 
   Covariance::Options options;
   CovarianceImpl covariance_impl(options);
@@ -251,13 +225,13 @@
   // Add in random order
   Vector junk_jacobian = Vector::Zero(10);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 1, junk_jacobian.data()), NULL, block1);
+      new UnaryCostFunction(1, 1, junk_jacobian.data()), nullptr, block1);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 4, junk_jacobian.data()), NULL, block4);
+      new UnaryCostFunction(1, 4, junk_jacobian.data()), nullptr, block4);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 3, junk_jacobian.data()), NULL, block3);
+      new UnaryCostFunction(1, 3, junk_jacobian.data()), nullptr, block3);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 2, junk_jacobian.data()), NULL, block2);
+      new UnaryCostFunction(1, 2, junk_jacobian.data()), nullptr, block2);
   problem.SetParameterBlockConstant(block3);
 
   // Sparsity pattern
@@ -287,13 +261,13 @@
                          3, 4, 5, 6};
   // clang-format on
 
-  vector<pair<const double*, const double*>> covariance_blocks;
-  covariance_blocks.push_back(make_pair(block1, block1));
-  covariance_blocks.push_back(make_pair(block4, block4));
-  covariance_blocks.push_back(make_pair(block2, block2));
-  covariance_blocks.push_back(make_pair(block3, block3));
-  covariance_blocks.push_back(make_pair(block2, block3));
-  covariance_blocks.push_back(make_pair(block4, block1));  // reversed
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
+  covariance_blocks.emplace_back(block1, block1);
+  covariance_blocks.emplace_back(block4, block4);
+  covariance_blocks.emplace_back(block2, block2);
+  covariance_blocks.emplace_back(block3, block3);
+  covariance_blocks.emplace_back(block2, block3);
+  covariance_blocks.emplace_back(block4, block1);  // reversed
 
   Covariance::Options options;
   CovarianceImpl covariance_impl(options);
@@ -332,12 +306,12 @@
   // Add in random order
   Vector junk_jacobian = Vector::Zero(10);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 1, junk_jacobian.data()), NULL, block1);
+      new UnaryCostFunction(1, 1, junk_jacobian.data()), nullptr, block1);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 4, junk_jacobian.data()), NULL, block4);
+      new UnaryCostFunction(1, 4, junk_jacobian.data()), nullptr, block4);
   problem.AddParameterBlock(block3, 3);
   problem.AddResidualBlock(
-      new UnaryCostFunction(1, 2, junk_jacobian.data()), NULL, block2);
+      new UnaryCostFunction(1, 2, junk_jacobian.data()), nullptr, block2);
 
   // Sparsity pattern
   //
@@ -366,13 +340,13 @@
                          3, 4, 5, 6};
   // clang-format on
 
-  vector<pair<const double*, const double*>> covariance_blocks;
-  covariance_blocks.push_back(make_pair(block1, block1));
-  covariance_blocks.push_back(make_pair(block4, block4));
-  covariance_blocks.push_back(make_pair(block2, block2));
-  covariance_blocks.push_back(make_pair(block3, block3));
-  covariance_blocks.push_back(make_pair(block2, block3));
-  covariance_blocks.push_back(make_pair(block4, block1));  // reversed
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
+  covariance_blocks.emplace_back(block1, block1);
+  covariance_blocks.emplace_back(block4, block4);
+  covariance_blocks.emplace_back(block2, block2);
+  covariance_blocks.emplace_back(block3, block3);
+  covariance_blocks.emplace_back(block2, block3);
+  covariance_blocks.emplace_back(block4, block1);  // reversed
 
   Covariance::Options options;
   CovarianceImpl covariance_impl(options);
@@ -398,9 +372,42 @@
   }
 }
 
+// x_plus_delta = delta * x;
+class PolynomialManifold : public Manifold {
+ public:
+  bool Plus(const double* x,
+            const double* delta,
+            double* x_plus_delta) const final {
+    x_plus_delta[0] = delta[0] * x[0];
+    x_plus_delta[1] = delta[0] * x[1];
+    return true;
+  }
+
+  bool Minus(const double* y, const double* x, double* y_minus_x) const final {
+    LOG(FATAL) << "Should not be called";
+    return true;
+  }
+
+  bool PlusJacobian(const double* x, double* jacobian) const final {
+    jacobian[0] = x[0];
+    jacobian[1] = x[1];
+    return true;
+  }
+
+  bool MinusJacobian(const double* x, double* jacobian) const final {
+    LOG(FATAL) << "Should not be called";
+    return true;
+  }
+
+  int AmbientSize() const final { return 2; }
+  int TangentSize() const final { return 1; }
+};
+
 class CovarianceTest : public ::testing::Test {
  protected:
-  typedef map<const double*, pair<int, int>> BoundsMap;
+  // TODO(sameeragarwal): Investigate if this should be an ordered or an
+  // unordered map.
+  using BoundsMap = std::map<const double*, std::pair<int, int>>;
 
   void SetUp() override {
     double* x = parameters_;
@@ -416,44 +423,46 @@
 
     {
       double jacobian[] = {1.0, 0.0, 0.0, 1.0};
-      problem_.AddResidualBlock(new UnaryCostFunction(2, 2, jacobian), NULL, x);
+      problem_.AddResidualBlock(
+          new UnaryCostFunction(2, 2, jacobian), nullptr, x);
     }
 
     {
       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);
+      problem_.AddResidualBlock(
+          new UnaryCostFunction(3, 3, jacobian), nullptr, y);
     }
 
     {
       double jacobian = 5.0;
       problem_.AddResidualBlock(
-          new UnaryCostFunction(1, 1, &jacobian), NULL, z);
+          new UnaryCostFunction(1, 1, &jacobian), nullptr, z);
     }
 
     {
       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), nullptr, y, x);
     }
 
     {
       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), nullptr, z, x);
     }
 
-    all_covariance_blocks_.push_back(make_pair(x, x));
-    all_covariance_blocks_.push_back(make_pair(y, y));
-    all_covariance_blocks_.push_back(make_pair(z, z));
-    all_covariance_blocks_.push_back(make_pair(x, y));
-    all_covariance_blocks_.push_back(make_pair(x, z));
-    all_covariance_blocks_.push_back(make_pair(y, z));
+    all_covariance_blocks_.emplace_back(x, x);
+    all_covariance_blocks_.emplace_back(y, y);
+    all_covariance_blocks_.emplace_back(z, z);
+    all_covariance_blocks_.emplace_back(x, y);
+    all_covariance_blocks_.emplace_back(x, z);
+    all_covariance_blocks_.emplace_back(y, z);
 
-    column_bounds_[x] = make_pair(0, 2);
-    column_bounds_[y] = make_pair(2, 5);
-    column_bounds_[z] = make_pair(5, 6);
+    column_bounds_[x] = std::make_pair(0, 2);
+    column_bounds_[y] = std::make_pair(2, 5);
+    column_bounds_[z] = std::make_pair(5, 6);
   }
 
   // Computes covariance in ambient space.
@@ -481,7 +490,7 @@
     // Generate all possible combination of block pairs and check if the
     // covariance computation is correct.
     for (int i = 0; i <= 64; ++i) {
-      vector<pair<const double*, const double*>> covariance_blocks;
+      std::vector<std::pair<const double*, const double*>> covariance_blocks;
       if (i & 1) {
         covariance_blocks.push_back(all_covariance_blocks_[0]);
       }
@@ -509,9 +518,9 @@
       Covariance covariance(options);
       EXPECT_TRUE(covariance.Compute(covariance_blocks, &problem_));
 
-      for (int i = 0; i < covariance_blocks.size(); ++i) {
-        const double* block1 = covariance_blocks[i].first;
-        const double* block2 = covariance_blocks[i].second;
+      for (auto& covariance_block : covariance_blocks) {
+        const double* block1 = covariance_block.first;
+        const double* block2 = covariance_block.second;
         // block1, block2
         GetCovarianceBlockAndCompare(block1,
                                      block2,
@@ -574,7 +583,7 @@
 
   double parameters_[6];
   Problem problem_;
-  vector<pair<const double*, const double*>> all_covariance_blocks_;
+  std::vector<std::pair<const double*, const double*>> all_covariance_blocks_;
   BoundsMap column_bounds_;
   BoundsMap local_column_bounds_;
 };
@@ -628,8 +637,6 @@
   ComputeAndCompareCovarianceBlocks(options, expected_covariance);
 }
 
-#ifdef CERES_USE_OPENMP
-
 TEST_F(CovarianceTest, ThreadedNormalBehavior) {
   // J
   //
@@ -680,8 +687,6 @@
   ComputeAndCompareCovarianceBlocks(options, expected_covariance);
 }
 
-#endif  // CERES_USE_OPENMP
-
 TEST_F(CovarianceTest, ConstantParameterBlock) {
   problem_.SetParameterBlockConstant(parameters_);
 
@@ -733,15 +738,15 @@
   ComputeAndCompareCovarianceBlocks(options, expected_covariance);
 }
 
-TEST_F(CovarianceTest, LocalParameterization) {
+TEST_F(CovarianceTest, Manifold) {
   double* x = parameters_;
   double* y = x + 2;
 
-  problem_.SetParameterization(x, new PolynomialParameterization);
+  problem_.SetManifold(x, new PolynomialManifold);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
-  problem_.SetParameterization(y, new SubsetParameterization(3, subset));
+  problem_.SetManifold(y, new SubsetManifold(3, subset));
 
   // Raw Jacobian: J
   //
@@ -792,20 +797,20 @@
   ComputeAndCompareCovarianceBlocks(options, expected_covariance);
 }
 
-TEST_F(CovarianceTest, LocalParameterizationInTangentSpace) {
+TEST_F(CovarianceTest, ManifoldInTangentSpace) {
   double* x = parameters_;
   double* y = x + 2;
   double* z = y + 3;
 
-  problem_.SetParameterization(x, new PolynomialParameterization);
+  problem_.SetManifold(x, new PolynomialManifold);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
-  problem_.SetParameterization(y, new SubsetParameterization(3, subset));
+  problem_.SetManifold(y, new SubsetManifold(3, subset));
 
-  local_column_bounds_[x] = make_pair(0, 1);
-  local_column_bounds_[y] = make_pair(1, 3);
-  local_column_bounds_[z] = make_pair(3, 4);
+  local_column_bounds_[x] = std::make_pair(0, 1);
+  local_column_bounds_[y] = std::make_pair(1, 3);
+  local_column_bounds_[z] = std::make_pair(3, 4);
 
   // Raw Jacobian: J
   //
@@ -855,22 +860,22 @@
   ComputeAndCompareCovarianceBlocksInTangentSpace(options, expected_covariance);
 }
 
-TEST_F(CovarianceTest, LocalParameterizationInTangentSpaceWithConstantBlocks) {
+TEST_F(CovarianceTest, ManifoldInTangentSpaceWithConstantBlocks) {
   double* x = parameters_;
   double* y = x + 2;
   double* z = y + 3;
 
-  problem_.SetParameterization(x, new PolynomialParameterization);
+  problem_.SetManifold(x, new PolynomialManifold);
   problem_.SetParameterBlockConstant(x);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
-  problem_.SetParameterization(y, new SubsetParameterization(3, subset));
+  problem_.SetManifold(y, new SubsetManifold(3, subset));
   problem_.SetParameterBlockConstant(y);
 
-  local_column_bounds_[x] = make_pair(0, 1);
-  local_column_bounds_[y] = make_pair(1, 3);
-  local_column_bounds_[z] = make_pair(3, 4);
+  local_column_bounds_[x] = std::make_pair(0, 1);
+  local_column_bounds_[y] = std::make_pair(1, 3);
+  local_column_bounds_[z] = std::make_pair(3, 4);
 
   // Raw Jacobian: J
   //
@@ -941,7 +946,7 @@
   //  -15 -18  3   6  13  0
   //    6  -4  0   0   0 29
 
-  // 3.4142 is the smallest eigen value of J'J. The following matrix
+  // 3.4142 is the smallest eigenvalue of J'J. The following matrix
   // was obtained by dropping the eigenvector corresponding to this
   // eigenvalue.
   // clang-format off
@@ -980,7 +985,7 @@
   double* x = parameters_;
   double* y = x + 2;
   double* z = y + 3;
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
   parameter_blocks.push_back(z);
@@ -1009,7 +1014,7 @@
   double* x = parameters_;
   double* y = x + 2;
   double* z = y + 3;
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
   parameter_blocks.push_back(z);
@@ -1038,17 +1043,17 @@
   double* y = x + 2;
   double* z = y + 3;
 
-  problem_.SetParameterization(x, new PolynomialParameterization);
+  problem_.SetManifold(x, new PolynomialManifold);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
-  problem_.SetParameterization(y, new SubsetParameterization(3, subset));
+  problem_.SetManifold(y, new SubsetManifold(3, subset));
 
-  local_column_bounds_[x] = make_pair(0, 1);
-  local_column_bounds_[y] = make_pair(1, 3);
-  local_column_bounds_[z] = make_pair(3, 4);
+  local_column_bounds_[x] = std::make_pair(0, 1);
+  local_column_bounds_[y] = std::make_pair(1, 3);
+  local_column_bounds_[z] = std::make_pair(3, 4);
 
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
   parameter_blocks.push_back(z);
@@ -1077,7 +1082,7 @@
   Covariance covariance(options);
   double* x = parameters_;
   double* y = x + 2;
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
@@ -1085,11 +1090,11 @@
   EXPECT_DEATH_IF_SUPPORTED(covariance.Compute(parameter_blocks, &problem_),
                             "Covariance::Compute called with duplicate blocks "
                             "at indices \\(0, 1\\) and \\(2, 3\\)");
-  vector<pair<const double*, const double*>> covariance_blocks;
-  covariance_blocks.push_back(make_pair(x, x));
-  covariance_blocks.push_back(make_pair(x, x));
-  covariance_blocks.push_back(make_pair(y, y));
-  covariance_blocks.push_back(make_pair(y, y));
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
+  covariance_blocks.emplace_back(x, x);
+  covariance_blocks.emplace_back(x, x);
+  covariance_blocks.emplace_back(y, y);
+  covariance_blocks.emplace_back(y, y);
   EXPECT_DEATH_IF_SUPPORTED(covariance.Compute(covariance_blocks, &problem_),
                             "Covariance::Compute called with duplicate blocks "
                             "at indices \\(0, 1\\) and \\(2, 3\\)");
@@ -1104,44 +1109,46 @@
 
     {
       double jacobian[] = {1.0, 0.0, 0.0, 1.0};
-      problem_.AddResidualBlock(new UnaryCostFunction(2, 2, jacobian), NULL, x);
+      problem_.AddResidualBlock(
+          new UnaryCostFunction(2, 2, jacobian), nullptr, x);
     }
 
     {
       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);
+      problem_.AddResidualBlock(
+          new UnaryCostFunction(3, 3, jacobian), nullptr, y);
     }
 
     {
       double jacobian = 5.0;
       problem_.AddResidualBlock(
-          new UnaryCostFunction(1, 1, &jacobian), NULL, z);
+          new UnaryCostFunction(1, 1, &jacobian), nullptr, z);
     }
 
     {
       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), nullptr, y, x);
     }
 
     {
       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), nullptr, z, x);
     }
 
-    all_covariance_blocks_.push_back(make_pair(x, x));
-    all_covariance_blocks_.push_back(make_pair(y, y));
-    all_covariance_blocks_.push_back(make_pair(z, z));
-    all_covariance_blocks_.push_back(make_pair(x, y));
-    all_covariance_blocks_.push_back(make_pair(x, z));
-    all_covariance_blocks_.push_back(make_pair(y, z));
+    all_covariance_blocks_.emplace_back(x, x);
+    all_covariance_blocks_.emplace_back(y, y);
+    all_covariance_blocks_.emplace_back(z, z);
+    all_covariance_blocks_.emplace_back(x, y);
+    all_covariance_blocks_.emplace_back(x, z);
+    all_covariance_blocks_.emplace_back(y, z);
 
-    column_bounds_[x] = make_pair(0, 2);
-    column_bounds_[y] = make_pair(2, 5);
-    column_bounds_[z] = make_pair(5, 6);
+    column_bounds_[x] = std::make_pair(0, 2);
+    column_bounds_[y] = std::make_pair(2, 5);
+    column_bounds_[z] = std::make_pair(5, 6);
   }
 };
 
@@ -1197,22 +1204,22 @@
   }
 };
 
-TEST(Covariance, ZeroSizedLocalParameterizationGetCovariance) {
+TEST(Covariance, ZeroSizedManifoldGetCovariance) {
   double x = 0.0;
   double y = 1.0;
   Problem problem;
   problem.AddResidualBlock(LinearCostFunction::Create(), nullptr, &x, &y);
-  problem.SetParameterization(&y, new SubsetParameterization(1, {0}));
+  problem.SetManifold(&y, new SubsetManifold(1, {0}));
   // J = [-1 0]
   //     [ 0 0]
   Covariance::Options options;
   options.algorithm_type = DENSE_SVD;
   Covariance covariance(options);
-  vector<pair<const double*, const double*>> covariance_blocks;
-  covariance_blocks.push_back(std::make_pair(&x, &x));
-  covariance_blocks.push_back(std::make_pair(&x, &y));
-  covariance_blocks.push_back(std::make_pair(&y, &x));
-  covariance_blocks.push_back(std::make_pair(&y, &y));
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
+  covariance_blocks.emplace_back(&x, &x);
+  covariance_blocks.emplace_back(&x, &y);
+  covariance_blocks.emplace_back(&y, &x);
+  covariance_blocks.emplace_back(&y, &y);
   EXPECT_TRUE(covariance.Compute(covariance_blocks, &problem));
 
   double value = -1;
@@ -1232,22 +1239,22 @@
   EXPECT_NEAR(value, 0.0, std::numeric_limits<double>::epsilon());
 }
 
-TEST(Covariance, ZeroSizedLocalParameterizationGetCovarianceInTangentSpace) {
+TEST(Covariance, ZeroSizedManifoldGetCovarianceInTangentSpace) {
   double x = 0.0;
   double y = 1.0;
   Problem problem;
   problem.AddResidualBlock(LinearCostFunction::Create(), nullptr, &x, &y);
-  problem.SetParameterization(&y, new SubsetParameterization(1, {0}));
+  problem.SetManifold(&y, new SubsetManifold(1, {0}));
   // J = [-1 0]
   //     [ 0 0]
   Covariance::Options options;
   options.algorithm_type = DENSE_SVD;
   Covariance covariance(options);
-  vector<pair<const double*, const double*>> covariance_blocks;
-  covariance_blocks.push_back(std::make_pair(&x, &x));
-  covariance_blocks.push_back(std::make_pair(&x, &y));
-  covariance_blocks.push_back(std::make_pair(&y, &x));
-  covariance_blocks.push_back(std::make_pair(&y, &y));
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
+  covariance_blocks.emplace_back(&x, &x);
+  covariance_blocks.emplace_back(&x, &y);
+  covariance_blocks.emplace_back(&y, &x);
+  covariance_blocks.emplace_back(&y, &y);
   EXPECT_TRUE(covariance.Compute(covariance_blocks, &problem));
 
   double value = -1;
@@ -1270,8 +1277,8 @@
   void SetUp() final {
     num_parameter_blocks_ = 2000;
     parameter_block_size_ = 5;
-    parameters_.reset(
-        new double[parameter_block_size_ * num_parameter_blocks_]);
+    parameters_ = std::make_unique<double[]>(parameter_block_size_ *
+                                             num_parameter_blocks_);
 
     Matrix jacobian(parameter_block_size_, parameter_block_size_);
     for (int i = 0; i < num_parameter_blocks_; ++i) {
@@ -1282,11 +1289,11 @@
       problem_.AddResidualBlock(
           new UnaryCostFunction(
               parameter_block_size_, parameter_block_size_, jacobian.data()),
-          NULL,
+          nullptr,
           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));
+        all_covariance_blocks_.emplace_back(block_i, block_j);
       }
     }
   }
@@ -1339,16 +1346,16 @@
   int num_parameter_blocks_;
 
   Problem problem_;
-  vector<pair<const double*, const double*>> all_covariance_blocks_;
+  std::vector<std::pair<const double*, const double*>> all_covariance_blocks_;
 };
 
-#if !defined(CERES_NO_SUITESPARSE) && defined(CERES_USE_OPENMP)
+#if !defined(CERES_NO_SUITESPARSE)
 
 TEST_F(LargeScaleCovarianceTest, Parallel) {
   ComputeAndCompare(SPARSE_QR, SUITE_SPARSE, 4);
 }
 
-#endif  // !defined(CERES_NO_SUITESPARSE) && defined(CERES_USE_OPENMP)
+#endif  // !defined(CERES_NO_SUITESPARSE)
 
 }  // namespace internal
 }  // namespace ceres