Removing using std::...
Change-Id: I584402e2a34869183c1d59071a15d97b216c52fb
diff --git a/examples/libmv_bundle_adjuster.cc b/examples/libmv_bundle_adjuster.cc
index fc45139..30ec111 100644
--- a/examples/libmv_bundle_adjuster.cc
+++ b/examples/libmv_bundle_adjuster.cc
@@ -123,8 +123,6 @@
using Vec3 = Eigen::Vector3d;
using Vec4 = Eigen::Vector4d;
-using std::vector;
-
DEFINE_string(input, "", "Input File name");
DEFINE_string(refine_intrinsics,
"",
@@ -207,7 +205,7 @@
};
// Returns a pointer to the camera corresponding to a image.
-EuclideanCamera* CameraForImage(vector<EuclideanCamera>* all_cameras,
+EuclideanCamera* CameraForImage(std::vector<EuclideanCamera>* all_cameras,
const int image) {
if (image < 0 || image >= all_cameras->size()) {
return nullptr;
@@ -220,7 +218,7 @@
}
const EuclideanCamera* CameraForImage(
- const vector<EuclideanCamera>& all_cameras, const int image) {
+ const std::vector<EuclideanCamera>& all_cameras, const int image) {
if (image < 0 || image >= all_cameras.size()) {
return nullptr;
}
@@ -232,7 +230,7 @@
}
// Returns maximal image number at which marker exists.
-int MaxImage(const vector<Marker>& all_markers) {
+int MaxImage(const std::vector<Marker>& all_markers) {
if (all_markers.size() == 0) {
return -1;
}
@@ -245,7 +243,7 @@
}
// Returns a pointer to the point corresponding to a track.
-EuclideanPoint* PointForTrack(vector<EuclideanPoint>* all_points,
+EuclideanPoint* PointForTrack(std::vector<EuclideanPoint>* all_points,
const int track) {
if (track < 0 || track >= all_points->size()) {
return nullptr;
@@ -373,10 +371,10 @@
// reading.
bool ReadProblemFromFile(const std::string& file_name,
double camera_intrinsics[8],
- vector<EuclideanCamera>* all_cameras,
- vector<EuclideanPoint>* all_points,
+ std::vector<EuclideanCamera>* all_cameras,
+ std::vector<EuclideanPoint>* all_points,
bool* is_image_space,
- vector<Marker>* all_markers) {
+ std::vector<Marker>* all_markers) {
EndianAwareFileReader file_reader;
if (!file_reader.OpenFile(file_name)) {
return false;
@@ -614,10 +612,10 @@
//
// Element with index i matches to a rotation+translation for
// camera at image i.
-vector<Vec6> PackCamerasRotationAndTranslation(
- const vector<Marker>& all_markers,
- const vector<EuclideanCamera>& all_cameras) {
- vector<Vec6> all_cameras_R_t;
+std::vector<Vec6> PackCamerasRotationAndTranslation(
+ const std::vector<Marker>& all_markers,
+ const std::vector<EuclideanCamera>& all_cameras) {
+ std::vector<Vec6> all_cameras_R_t;
int max_image = MaxImage(all_markers);
all_cameras_R_t.resize(max_image + 1);
@@ -637,9 +635,9 @@
}
// Convert cameras rotations fro mangle axis back to rotation matrix.
-void UnpackCamerasRotationAndTranslation(const vector<Marker>& all_markers,
- const vector<Vec6>& all_cameras_R_t,
- vector<EuclideanCamera>* all_cameras) {
+void UnpackCamerasRotationAndTranslation(const std::vector<Marker>& all_markers,
+ const std::vector<Vec6>& all_cameras_R_t,
+ std::vector<EuclideanCamera>* all_cameras) {
int max_image = MaxImage(all_markers);
for (int i = 0; i <= max_image; i++) {
@@ -654,12 +652,12 @@
}
}
-void EuclideanBundleCommonIntrinsics(const vector<Marker>& all_markers,
+void EuclideanBundleCommonIntrinsics(const std::vector<Marker>& all_markers,
const int bundle_intrinsics,
const int bundle_constraints,
double* camera_intrinsics,
- vector<EuclideanCamera>* all_cameras,
- vector<EuclideanPoint>* all_points) {
+ std::vector<EuclideanCamera>* all_cameras,
+ std::vector<EuclideanPoint>* all_points) {
PrintCameraIntrinsics("Original intrinsics: ", camera_intrinsics);
ceres::Problem::Options problem_options;
@@ -671,7 +669,7 @@
//
// Block for minimization has got the following structure:
// <3 elements for angle-axis> <3 elements for translation>
- vector<Vec6> all_cameras_R_t =
+ std::vector<Vec6> all_cameras_R_t =
PackCamerasRotationAndTranslation(all_markers, *all_cameras);
// Manifold used to restrict camera motion for modal solvers.
@@ -799,10 +797,10 @@
}
double camera_intrinsics[8];
- vector<EuclideanCamera> all_cameras;
- vector<EuclideanPoint> all_points;
+ std::vector<EuclideanCamera> all_cameras;
+ std::vector<EuclideanPoint> all_points;
bool is_image_space;
- vector<Marker> all_markers;
+ std::vector<Marker> all_markers;
if (!ReadProblemFromFile(CERES_GET_FLAG(FLAGS_input),
camera_intrinsics,
diff --git a/examples/nist.cc b/examples/nist.cc
index 05c15b2..04f1474 100644
--- a/examples/nist.cc
+++ b/examples/nist.cc
@@ -159,17 +159,10 @@
using Vector = Eigen::Matrix<double, Dynamic, 1>;
using Matrix = Eigen::Matrix<double, Dynamic, Dynamic, RowMajor>;
-using std::atof;
-using std::atoi;
-using std::cout;
-using std::ifstream;
-using std::string;
-using std::vector;
-
-void SplitStringUsingChar(const string& full,
+void SplitStringUsingChar(const std::string& full,
const char delim,
- vector<string>* result) {
- std::back_insert_iterator<vector<string>> it(*result);
+ std::vector<std::string>* result) {
+ std::back_insert_iterator<std::vector<std::string>> it(*result);
const char* p = full.data();
const char* end = p + full.size();
@@ -181,20 +174,20 @@
while (++p != end && *p != delim) {
// Skip to the next occurrence of the delimiter.
}
- *it++ = string(start, p - start);
+ *it++ = std::string(start, p - start);
}
}
}
-bool GetAndSplitLine(ifstream& ifs, vector<string>* pieces) {
+bool GetAndSplitLine(std::ifstream& ifs, std::vector<std::string>* pieces) {
pieces->clear();
char buf[256];
ifs.getline(buf, 256);
- SplitStringUsingChar(string(buf), ' ', pieces);
+ SplitStringUsingChar(std::string(buf), ' ', pieces);
return true;
}
-void SkipLines(ifstream& ifs, int num_lines) {
+void SkipLines(std::ifstream& ifs, int num_lines) {
char buf[256];
for (int i = 0; i < num_lines; ++i) {
ifs.getline(buf, 256);
@@ -203,24 +196,24 @@
class NISTProblem {
public:
- explicit NISTProblem(const string& filename) {
- ifstream ifs(filename.c_str(), ifstream::in);
+ explicit NISTProblem(const std::string& filename) {
+ std::ifstream ifs(filename.c_str(), std::ifstream::in);
CHECK(ifs) << "Unable to open : " << filename;
- vector<string> pieces;
+ std::vector<std::string> pieces;
SkipLines(ifs, 24);
GetAndSplitLine(ifs, &pieces);
- const int kNumResponses = atoi(pieces[1].c_str());
+ const int kNumResponses = std::atoi(pieces[1].c_str());
GetAndSplitLine(ifs, &pieces);
- const int kNumPredictors = atoi(pieces[0].c_str());
+ const int kNumPredictors = std::atoi(pieces[0].c_str());
GetAndSplitLine(ifs, &pieces);
- const int kNumObservations = atoi(pieces[0].c_str());
+ const int kNumObservations = std::atoi(pieces[0].c_str());
SkipLines(ifs, 4);
GetAndSplitLine(ifs, &pieces);
- const int kNumParameters = atoi(pieces[0].c_str());
+ const int kNumParameters = std::atoi(pieces[0].c_str());
SkipLines(ifs, 8);
// Get the first line of initial and final parameter values to
@@ -236,24 +229,24 @@
// Parse the line for parameter b1.
int parameter_id = 0;
for (int i = 0; i < kNumTries; ++i) {
- initial_parameters_(i, parameter_id) = atof(pieces[i + 2].c_str());
+ initial_parameters_(i, parameter_id) = std::atof(pieces[i + 2].c_str());
}
- final_parameters_(0, parameter_id) = atof(pieces[2 + kNumTries].c_str());
+ final_parameters_(0, parameter_id) = std::atof(pieces[2 + kNumTries].c_str());
// Parse the remaining parameter lines.
for (int parameter_id = 1; parameter_id < kNumParameters; ++parameter_id) {
GetAndSplitLine(ifs, &pieces);
// b2, b3, ....
for (int i = 0; i < kNumTries; ++i) {
- initial_parameters_(i, parameter_id) = atof(pieces[i + 2].c_str());
+ initial_parameters_(i, parameter_id) = std::atof(pieces[i + 2].c_str());
}
- final_parameters_(0, parameter_id) = atof(pieces[2 + kNumTries].c_str());
+ final_parameters_(0, parameter_id) = std::atof(pieces[2 + kNumTries].c_str());
}
// Certified cost
SkipLines(ifs, 1);
GetAndSplitLine(ifs, &pieces);
- certified_cost_ = atof(pieces[4].c_str()) / 2.0;
+ certified_cost_ = std::atof(pieces[4].c_str()) / 2.0;
// Read the observations.
SkipLines(ifs, 18 - kNumParameters);
@@ -261,12 +254,12 @@
GetAndSplitLine(ifs, &pieces);
// Response.
for (int j = 0; j < kNumResponses; ++j) {
- response_(i, j) = atof(pieces[j].c_str());
+ response_(i, j) = std::atof(pieces[j].c_str());
}
// Predictor variables.
for (int j = 0; j < kNumPredictors; ++j) {
- predictor_(i, j) = atof(pieces[j + kNumResponses].c_str());
+ predictor_(i, j) = std::atof(pieces[j + kNumResponses].c_str());
}
}
}
@@ -507,7 +500,7 @@
options->parameter_tolerance = std::numeric_limits<double>::epsilon();
}
-string JoinPath(const string& dirname, const string& basename) {
+std::string JoinPath(const std::string& dirname, const std::string& basename) {
#ifdef _WIN32
static const char separator = '\\';
#else
@@ -519,7 +512,7 @@
} else if (dirname[dirname.size() - 1] == separator) {
return dirname + basename;
} else {
- return dirname + string(&separator, 1) + basename;
+ return dirname + std::string(&separator, 1) + basename;
}
}
@@ -583,7 +576,7 @@
}
template <typename Model, int num_parameters>
-int RegressionDriver(const string& filename) {
+int RegressionDriver(const std::string& filename) {
NISTProblem nist_problem(
JoinPath(CERES_GET_FLAG(FLAGS_nist_data_dir), filename));
CHECK_EQ(num_parameters, nist_problem.num_parameters());
@@ -663,7 +656,7 @@
LOG(FATAL) << "Must specify the directory containing the NIST problems";
}
- cout << "Lower Difficulty\n";
+ std::cout << "Lower Difficulty\n";
int easy_success = 0;
easy_success += RegressionDriver<Misra1a, 2>("Misra1a.dat");
easy_success += RegressionDriver<Chwirut, 3>("Chwirut1.dat");
@@ -674,7 +667,7 @@
easy_success += RegressionDriver<DanWood, 2>("DanWood.dat");
easy_success += RegressionDriver<Misra1b, 2>("Misra1b.dat");
- cout << "\nMedium Difficulty\n";
+ std::cout << "\nMedium Difficulty\n";
int medium_success = 0;
medium_success += RegressionDriver<Kirby2, 5>("Kirby2.dat");
medium_success += RegressionDriver<Hahn1, 7>("Hahn1.dat");
@@ -688,7 +681,7 @@
medium_success += RegressionDriver<Roszman1, 4>("Roszman1.dat");
medium_success += RegressionDriver<ENSO, 9>("ENSO.dat");
- cout << "\nHigher Difficulty\n";
+ std::cout << "\nHigher Difficulty\n";
int hard_success = 0;
hard_success += RegressionDriver<MGH09, 4>("MGH09.dat");
hard_success += RegressionDriver<Thurber, 7>("Thurber.dat");
@@ -699,11 +692,11 @@
hard_success += RegressionDriver<Rat43, 4>("Rat43.dat");
hard_success += RegressionDriver<Bennet5, 3>("Bennett5.dat");
- cout << "\n";
- cout << "Easy : " << easy_success << "/16\n";
- cout << "Medium : " << medium_success << "/22\n";
- cout << "Hard : " << hard_success << "/16\n";
- cout << "Total : " << easy_success + medium_success + hard_success
+ std::cout << "\n";
+ std::cout << "Easy : " << easy_success << "/16\n";
+ std::cout << "Medium : " << medium_success << "/22\n";
+ std::cout << "Hard : " << hard_success << "/16\n";
+ std::cout << "Total : " << easy_success + medium_success + hard_success
<< "/54\n";
}
diff --git a/examples/robot_pose_mle.cc b/examples/robot_pose_mle.cc
index 5f57a89..7dd981d 100644
--- a/examples/robot_pose_mle.cc
+++ b/examples/robot_pose_mle.cc
@@ -143,8 +143,6 @@
using ceres::Problem;
using ceres::Solve;
using ceres::Solver;
-using std::min;
-using std::vector;
DEFINE_double(corridor_length,
30.0,
@@ -215,8 +213,8 @@
// conveniently add to a ceres problem.
static RangeCostFunction* Create(const int pose_index,
const double range_reading,
- vector<double>* odometry_values,
- vector<double*>* parameter_blocks) {
+ std::vector<double>* odometry_values,
+ std::vector<double*>* parameter_blocks) {
auto* constraint =
new RangeConstraint(pose_index,
range_reading,
@@ -241,8 +239,8 @@
namespace {
-void SimulateRobot(vector<double>* odometry_values,
- vector<double>* range_readings) {
+void SimulateRobot(std::vector<double>* odometry_values,
+ std::vector<double>* range_readings) {
const int num_steps =
static_cast<int>(ceil(CERES_GET_FLAG(FLAGS_corridor_length) /
CERES_GET_FLAG(FLAGS_pose_separation)));
@@ -256,8 +254,8 @@
double robot_location = 0.0;
for (int i = 0; i < num_steps; ++i) {
const double actual_odometry_value =
- min(CERES_GET_FLAG(FLAGS_pose_separation),
- CERES_GET_FLAG(FLAGS_corridor_length) - robot_location);
+ std::min(CERES_GET_FLAG(FLAGS_pose_separation),
+ CERES_GET_FLAG(FLAGS_corridor_length) - robot_location);
robot_location += actual_odometry_value;
const double actual_range =
CERES_GET_FLAG(FLAGS_corridor_length) - robot_location;
@@ -269,8 +267,8 @@
}
}
-void PrintState(const vector<double>& odometry_readings,
- const vector<double>& range_readings) {
+void PrintState(const std::vector<double>& odometry_readings,
+ const std::vector<double>& range_readings) {
CHECK_EQ(odometry_readings.size(), range_readings.size());
double robot_location = 0.0;
printf("pose: location odom range r.error o.error\n");
@@ -301,8 +299,8 @@
CHECK_GT(CERES_GET_FLAG(FLAGS_odometry_stddev), 0.0);
CHECK_GT(CERES_GET_FLAG(FLAGS_range_stddev), 0.0);
- vector<double> odometry_values;
- vector<double> range_readings;
+ std::vector<double> odometry_values;
+ std::vector<double> range_readings;
SimulateRobot(&odometry_values, &range_readings);
printf("Initial values:\n");
@@ -312,7 +310,7 @@
for (int i = 0; i < odometry_values.size(); ++i) {
// Create and add a DynamicAutoDiffCostFunction for the RangeConstraint from
// pose i.
- vector<double*> parameter_blocks;
+ std::vector<double*> parameter_blocks;
RangeConstraint::RangeCostFunction* range_cost_function =
RangeConstraint::Create(
i, range_readings[i], &odometry_values, ¶meter_blocks);
diff --git a/internal/ceres/array_utils.cc b/internal/ceres/array_utils.cc
index 1501866..8362618 100644
--- a/internal/ceres/array_utils.cc
+++ b/internal/ceres/array_utils.cc
@@ -38,9 +38,8 @@
#include "ceres/stringprintf.h"
#include "ceres/types.h"
-namespace ceres::internal {
-using std::string;
+namespace ceres::internal {
bool IsArrayValid(const int size, const double* x) {
if (x != nullptr) {
@@ -75,7 +74,7 @@
}
}
-void AppendArrayToString(const int size, const double* x, string* result) {
+void AppendArrayToString(const int size, const double* x, std::string* result) {
for (int i = 0; i < size; ++i) {
if (x == nullptr) {
StringAppendF(result, "Not Computed ");
diff --git a/internal/ceres/array_utils_test.cc b/internal/ceres/array_utils_test.cc
index 8a94ec1..5820728 100644
--- a/internal/ceres/array_utils_test.cc
+++ b/internal/ceres/array_utils_test.cc
@@ -38,8 +38,6 @@
namespace ceres::internal {
-using std::vector;
-
TEST(ArrayUtils, IsArrayValid) {
double x[3];
x[0] = 0.0;
@@ -75,10 +73,10 @@
}
TEST(MapValuesToContiguousRange, ContiguousEntries) {
- vector<int> array;
+ std::vector<int> array;
array.push_back(0);
array.push_back(1);
- vector<int> expected = array;
+ std::vector<int> expected = array;
MapValuesToContiguousRange(array.size(), &array[0]);
EXPECT_EQ(array, expected);
array.clear();
@@ -91,10 +89,10 @@
}
TEST(MapValuesToContiguousRange, NonContiguousEntries) {
- vector<int> array;
+ std::vector<int> array;
array.push_back(0);
array.push_back(2);
- vector<int> expected;
+ std::vector<int> expected;
expected.push_back(0);
expected.push_back(1);
MapValuesToContiguousRange(array.size(), &array[0]);
@@ -102,14 +100,14 @@
}
TEST(MapValuesToContiguousRange, NonContiguousRepeatingEntries) {
- vector<int> array;
+ std::vector<int> array;
array.push_back(3);
array.push_back(1);
array.push_back(0);
array.push_back(0);
array.push_back(0);
array.push_back(5);
- vector<int> expected;
+ std::vector<int> expected;
expected.push_back(2);
expected.push_back(1);
expected.push_back(0);
diff --git a/internal/ceres/block_jacobian_writer.cc b/internal/ceres/block_jacobian_writer.cc
index d7e1e95..a481626 100644
--- a/internal/ceres/block_jacobian_writer.cc
+++ b/internal/ceres/block_jacobian_writer.cc
@@ -43,8 +43,6 @@
namespace ceres::internal {
-using std::vector;
-
namespace {
// Given the residual block ordering, build a lookup table to determine which
@@ -59,9 +57,9 @@
// instead of num_eliminate_blocks.
void BuildJacobianLayout(const Program& program,
int num_eliminate_blocks,
- vector<int*>* jacobian_layout,
- vector<int>* jacobian_layout_storage) {
- const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
+ std::vector<int*>* jacobian_layout,
+ std::vector<int>* jacobian_layout_storage) {
+ const std::vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
// Iterate over all the active residual blocks and determine how many E blocks
// are there. This will determine where the F blocks start in the jacobian
@@ -153,7 +151,7 @@
std::unique_ptr<SparseMatrix> BlockJacobianWriter::CreateJacobian() const {
auto* bs = new CompressedRowBlockStructure;
- const vector<ParameterBlock*>& parameter_blocks =
+ const std::vector<ParameterBlock*>& parameter_blocks =
program_->parameter_blocks();
// Construct the column blocks.
@@ -167,7 +165,7 @@
}
// Construct the cells in each row.
- const vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
+ const std::vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
int row_block_position = 0;
bs->rows.resize(residual_blocks.size());
for (int i = 0; i < residual_blocks.size(); ++i) {
diff --git a/internal/ceres/bundle_adjustment_test_util.h b/internal/ceres/bundle_adjustment_test_util.h
index 696b39e..68d7a7c 100644
--- a/internal/ceres/bundle_adjustment_test_util.h
+++ b/internal/ceres/bundle_adjustment_test_util.h
@@ -51,9 +51,6 @@
namespace ceres {
namespace internal {
-using std::string;
-using std::vector;
-
const bool kAutomaticOrdering = true;
const bool kUserOrdering = false;
@@ -68,7 +65,7 @@
BuildProblem();
}
BundleAdjustmentProblem() {
- const string input_file = TestFileAbsolutePath("problem-16-22106-pre.txt");
+ const std::string input_file = TestFileAbsolutePath("problem-16-22106-pre.txt");
ReadData(input_file);
BuildProblem();
}
@@ -98,7 +95,7 @@
static double kResidualTolerance;
private:
- void ReadData(const string& filename) {
+ void ReadData(const std::string& filename) {
FILE* fptr = fopen(filename.c_str(), "r");
if (!fptr) {
diff --git a/internal/ceres/callbacks.cc b/internal/ceres/callbacks.cc
index fcdcb2a..b46f62c 100644
--- a/internal/ceres/callbacks.cc
+++ b/internal/ceres/callbacks.cc
@@ -39,8 +39,6 @@
namespace ceres::internal {
-using std::string;
-
StateUpdatingCallback::StateUpdatingCallback(Program* program,
double* parameters)
: program_(program), parameters_(parameters) {}
@@ -82,7 +80,7 @@
CallbackReturnType LoggingCallback::operator()(
const IterationSummary& summary) {
- string output;
+ std::string output;
if (minimizer_type == LINE_SEARCH) {
output = StringPrintf(
"% 4d: f:% 8e d:% 3.2e g:% 3.2e h:% 3.2e s:% 3.2e e:% 3d it:% 3.2e "
diff --git a/internal/ceres/canonical_views_clustering.cc b/internal/ceres/canonical_views_clustering.cc
index 7c385fc..7599f6d 100644
--- a/internal/ceres/canonical_views_clustering.cc
+++ b/internal/ceres/canonical_views_clustering.cc
@@ -41,8 +41,6 @@
namespace ceres::internal {
-using std::vector;
-
using IntMap = std::unordered_map<int, int>;
using IntSet = std::unordered_set<int>;
@@ -58,15 +56,15 @@
// are assigned to a cluster with id = kInvalidClusterId.
void ComputeClustering(const CanonicalViewsClusteringOptions& options,
const WeightedGraph<int>& graph,
- vector<int>* centers,
+ std::vector<int>* centers,
IntMap* membership);
private:
void FindValidViews(IntSet* valid_views) const;
double ComputeClusteringQualityDifference(const int candidate,
- const vector<int>& centers) const;
+ const std::vector<int>& centers) const;
void UpdateCanonicalViewAssignments(const int canonical_view);
- void ComputeClusterMembership(const vector<int>& centers,
+ void ComputeClusterMembership(const std::vector<int>& centers,
IntMap* membership) const;
CanonicalViewsClusteringOptions options_;
@@ -81,7 +79,7 @@
void ComputeCanonicalViewsClustering(
const CanonicalViewsClusteringOptions& options,
const WeightedGraph<int>& graph,
- vector<int>* centers,
+ std::vector<int>* centers,
IntMap* membership) {
time_t start_time = time(nullptr);
CanonicalViewsClustering cv;
@@ -94,7 +92,7 @@
void CanonicalViewsClustering::ComputeClustering(
const CanonicalViewsClusteringOptions& options,
const WeightedGraph<int>& graph,
- vector<int>* centers,
+ std::vector<int>* centers,
IntMap* membership) {
options_ = options;
CHECK(centers != nullptr);
@@ -150,7 +148,7 @@
// Computes the difference in the quality score if 'candidate' were
// added to the set of canonical views.
double CanonicalViewsClustering::ComputeClusteringQualityDifference(
- const int candidate, const vector<int>& centers) const {
+ const int candidate, const std::vector<int>& centers) const {
// View score.
double difference =
options_.view_score_weight * graph_->VertexWeight(candidate);
@@ -197,7 +195,7 @@
// Assign a cluster id to each view.
void CanonicalViewsClustering::ComputeClusterMembership(
- const vector<int>& centers, IntMap* membership) const {
+ const std::vector<int>& centers, IntMap* membership) const {
CHECK(membership != nullptr);
membership->clear();
diff --git a/internal/ceres/coordinate_descent_minimizer.cc b/internal/ceres/coordinate_descent_minimizer.cc
index de22822..cd0caf2 100644
--- a/internal/ceres/coordinate_descent_minimizer.cc
+++ b/internal/ceres/coordinate_descent_minimizer.cc
@@ -51,13 +51,6 @@
namespace ceres::internal {
-using std::map;
-using std::max;
-using std::min;
-using std::set;
-using std::string;
-using std::vector;
-
CoordinateDescentMinimizer::CoordinateDescentMinimizer(ContextImpl* context)
: context_(context) {
CHECK(context_ != nullptr);
@@ -69,15 +62,15 @@
const Program& program,
const ProblemImpl::ParameterMap& parameter_map,
const ParameterBlockOrdering& ordering,
- string* error) {
+ std::string* error) {
parameter_blocks_.clear();
independent_set_offsets_.clear();
independent_set_offsets_.push_back(0);
// Serialize the OrderedGroups into a vector of parameter block
// offsets for parallel access.
- map<ParameterBlock*, int> parameter_block_index;
- map<int, set<double*>> group_to_elements = ordering.group_to_elements();
+ std::map<ParameterBlock*, int> parameter_block_index;
+ std::map<int, std::set<double*>> group_to_elements = ordering.group_to_elements();
for (const auto& g_t_e : group_to_elements) {
const auto& elements = g_t_e.second;
for (double* parameter_block : elements) {
@@ -92,7 +85,7 @@
// The ordering does not have to contain all parameter blocks, so
// assign zero offsets/empty independent sets to these parameter
// blocks.
- const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+ const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
for (auto* parameter_block : parameter_blocks) {
if (!ordering.IsMember(parameter_block->mutable_user_state())) {
parameter_blocks_.push_back(parameter_block);
@@ -103,7 +96,7 @@
// Compute the set of residual blocks that depend on each parameter
// block.
residual_blocks_.resize(parameter_block_index.size());
- const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
+ const std::vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
for (auto* residual_block : residual_blocks) {
const int num_parameter_blocks = residual_block->NumParameterBlocks();
for (int j = 0; j < num_parameter_blocks; ++j) {
@@ -152,9 +145,9 @@
}
const int num_inner_iteration_threads =
- min(options.num_threads, num_problems);
+ std::min(options.num_threads, num_problems);
evaluator_options_.num_threads =
- max(1, options.num_threads / num_inner_iteration_threads);
+ std::max(1, options.num_threads / num_inner_iteration_threads);
// The parameter blocks in each independent set can be optimized
// in parallel, since they do not co-occur in any residual block.
@@ -214,7 +207,7 @@
summary->initial_cost = 0.0;
summary->fixed_cost = 0.0;
summary->final_cost = 0.0;
- string error;
+ std::string error;
Minimizer::Options minimizer_options;
minimizer_options.evaluator =
@@ -237,8 +230,8 @@
bool CoordinateDescentMinimizer::IsOrderingValid(
const Program& program,
const ParameterBlockOrdering& ordering,
- string* message) {
- const map<int, set<double*>>& group_to_elements =
+ std::string* message) {
+ const std::map<int, std::set<double*>>& group_to_elements =
ordering.group_to_elements();
// Verify that each group is an independent set
diff --git a/internal/ceres/cost_function_to_functor_test.cc b/internal/ceres/cost_function_to_functor_test.cc
index f26fc1d..cf4a57b 100644
--- a/internal/ceres/cost_function_to_functor_test.cc
+++ b/internal/ceres/cost_function_to_functor_test.cc
@@ -40,7 +40,6 @@
namespace ceres::internal {
-using std::vector;
const double kTolerance = 1e-18;
static void ExpectCostFunctionsAreEqual(
@@ -49,9 +48,9 @@
EXPECT_EQ(cost_function.num_residuals(),
actual_cost_function.num_residuals());
const int num_residuals = cost_function.num_residuals();
- const vector<int32_t>& parameter_block_sizes =
+ const std::vector<int32_t>& parameter_block_sizes =
cost_function.parameter_block_sizes();
- const vector<int32_t>& actual_parameter_block_sizes =
+ const std::vector<int32_t>& actual_parameter_block_sizes =
actual_cost_function.parameter_block_sizes();
EXPECT_EQ(parameter_block_sizes.size(), actual_parameter_block_sizes.size());
diff --git a/internal/ceres/covariance.cc b/internal/ceres/covariance.cc
index 029f3f5..b24999d 100644
--- a/internal/ceres/covariance.cc
+++ b/internal/ceres/covariance.cc
@@ -39,9 +39,6 @@
namespace ceres {
-using std::pair;
-using std::vector;
-
Covariance::Covariance(const Covariance::Options& options) {
impl_ = std::make_unique<internal::CovarianceImpl>(options);
}
@@ -49,12 +46,12 @@
Covariance::~Covariance() = default;
bool Covariance::Compute(
- const vector<pair<const double*, const double*>>& covariance_blocks,
+ const std::vector<std::pair<const double*, const double*>>& covariance_blocks,
Problem* problem) {
return impl_->Compute(covariance_blocks, problem->mutable_impl());
}
-bool Covariance::Compute(const vector<const double*>& parameter_blocks,
+bool Covariance::Compute(const std::vector<const double*>& parameter_blocks,
Problem* problem) {
return impl_->Compute(parameter_blocks, problem->mutable_impl());
}
@@ -79,7 +76,7 @@
}
bool Covariance::GetCovarianceMatrix(
- const vector<const double*>& parameter_blocks,
+ const std::vector<const double*>& parameter_blocks,
double* covariance_matrix) const {
return impl_->GetCovarianceMatrixInTangentOrAmbientSpace(parameter_blocks,
true, // ambient
diff --git a/internal/ceres/covariance_impl.cc b/internal/ceres/covariance_impl.cc
index 5d8b87f..4245e43 100644
--- a/internal/ceres/covariance_impl.cc
+++ b/internal/ceres/covariance_impl.cc
@@ -59,8 +59,6 @@
namespace ceres::internal {
-using std::swap;
-
using CovarianceBlocks = std::vector<std::pair<const double*, const double*>>;
CovarianceImpl::CovarianceImpl(const Covariance::Options& options)
@@ -166,7 +164,7 @@
const double* parameter_block2 = original_parameter_block2;
const bool transpose = parameter_block1 > parameter_block2;
if (transpose) {
- swap(parameter_block1, parameter_block2);
+ std::swap(parameter_block1, parameter_block2);
}
// Find where in the covariance matrix the block is located.
diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 76fcb12..7d477a7 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -50,11 +50,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,
@@ -84,7 +79,7 @@
}
private:
- vector<double> jacobian_;
+ std::vector<double> jacobian_;
};
class BinaryCostFunction : public CostFunction {
@@ -126,8 +121,8 @@
}
private:
- vector<double> jacobian1_;
- vector<double> jacobian2_;
+ std::vector<double> jacobian1_;
+ std::vector<double> jacobian2_;
};
TEST(CovarianceImpl, ComputeCovarianceSparsity) {
@@ -184,7 +179,7 @@
6, 7, 8, 9};
// clang-format on
- vector<pair<const double*, const double*>> covariance_blocks;
+ 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);
@@ -265,7 +260,7 @@
3, 4, 5, 6};
// clang-format on
- vector<pair<const double*, const double*>> covariance_blocks;
+ 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);
@@ -344,7 +339,7 @@
3, 4, 5, 6};
// clang-format on
- vector<pair<const double*, const double*>> covariance_blocks;
+ 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);
@@ -409,7 +404,7 @@
class CovarianceTest : public ::testing::Test {
protected:
- using BoundsMap = map<const double*, pair<int, int>>;
+ using BoundsMap = std::map<const double*, std::pair<int, int>>;
void SetUp() override {
double* x = parameters_;
@@ -462,9 +457,9 @@
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.
@@ -492,7 +487,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]);
}
@@ -585,7 +580,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_;
};
@@ -746,7 +741,7 @@
problem_.SetManifold(x, new PolynomialManifold);
- vector<int> subset;
+ std::vector<int> subset;
subset.push_back(2);
problem_.SetManifold(y, new SubsetManifold(3, subset));
@@ -806,13 +801,13 @@
problem_.SetManifold(x, new PolynomialManifold);
- vector<int> subset;
+ std::vector<int> subset;
subset.push_back(2);
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
//
@@ -870,14 +865,14 @@
problem_.SetManifold(x, new PolynomialManifold);
problem_.SetParameterBlockConstant(x);
- vector<int> subset;
+ std::vector<int> subset;
subset.push_back(2);
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
//
@@ -987,7 +982,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);
@@ -1016,7 +1011,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);
@@ -1047,15 +1042,15 @@
problem_.SetManifold(x, new PolynomialManifold);
- vector<int> subset;
+ std::vector<int> subset;
subset.push_back(2);
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);
@@ -1084,7 +1079,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);
@@ -1092,7 +1087,7 @@
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;
+ 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);
@@ -1148,9 +1143,9 @@
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);
}
};
@@ -1217,7 +1212,7 @@
Covariance::Options options;
options.algorithm_type = DENSE_SVD;
Covariance covariance(options);
- vector<pair<const double*, const double*>> covariance_blocks;
+ 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);
@@ -1252,7 +1247,7 @@
Covariance::Options options;
options.algorithm_type = DENSE_SVD;
Covariance covariance(options);
- vector<pair<const double*, const double*>> covariance_blocks;
+ 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);
@@ -1348,7 +1343,7 @@
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)
diff --git a/internal/ceres/dynamic_autodiff_cost_function_test.cc b/internal/ceres/dynamic_autodiff_cost_function_test.cc
index 6777d0c..d4800c2 100644
--- a/internal/ceres/dynamic_autodiff_cost_function_test.cc
+++ b/internal/ceres/dynamic_autodiff_cost_function_test.cc
@@ -39,8 +39,6 @@
namespace ceres::internal {
-using std::vector;
-
// Takes 2 parameter blocks:
// parameters[0] is size 10.
// parameters[1] is size 5.
@@ -74,8 +72,8 @@
};
TEST(DynamicAutodiffCostFunctionTest, TestResiduals) {
- vector<double> param_block_0(10, 0.0);
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -83,8 +81,8 @@
cost_function.SetNumResiduals(21);
// Test residual computation.
- vector<double> residuals(21, -100000);
- vector<double*> parameter_blocks(2);
+ std::vector<double> residuals(21, -100000);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
EXPECT_TRUE(
@@ -98,11 +96,11 @@
TEST(DynamicAutodiffCostFunctionTest, TestJacobian) {
// Test the residual counting.
- vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
param_block_0[i] = 2 * i;
}
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -110,18 +108,18 @@
cost_function.SetNumResiduals(21);
// Prepare the residuals.
- vector<double> residuals(21, -100000);
+ std::vector<double> residuals(21, -100000);
// Prepare the parameters.
- vector<double*> parameter_blocks(2);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
// Prepare the jacobian.
- vector<vector<double>> jacobian_vect(2);
+ std::vector<std::vector<double>> jacobian_vect(2);
jacobian_vect[0].resize(21 * 10, -100000);
jacobian_vect[1].resize(21 * 5, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect[0].data());
jacobian.push_back(jacobian_vect[1].data());
@@ -164,11 +162,11 @@
TEST(DynamicAutodiffCostFunctionTest, JacobianWithFirstParameterBlockConstant) {
// Test the residual counting.
- vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
param_block_0[i] = 2 * i;
}
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -176,18 +174,18 @@
cost_function.SetNumResiduals(21);
// Prepare the residuals.
- vector<double> residuals(21, -100000);
+ std::vector<double> residuals(21, -100000);
// Prepare the parameters.
- vector<double*> parameter_blocks(2);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
// Prepare the jacobian.
- vector<vector<double>> jacobian_vect(2);
+ std::vector<std::vector<double>> jacobian_vect(2);
jacobian_vect[0].resize(21 * 10, -100000);
jacobian_vect[1].resize(21 * 5, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(nullptr);
jacobian.push_back(jacobian_vect[1].data());
@@ -214,11 +212,11 @@
TEST(DynamicAutodiffCostFunctionTest,
JacobianWithSecondParameterBlockConstant) { // NOLINT
// Test the residual counting.
- vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
param_block_0[i] = 2 * i;
}
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -226,18 +224,18 @@
cost_function.SetNumResiduals(21);
// Prepare the residuals.
- vector<double> residuals(21, -100000);
+ std::vector<double> residuals(21, -100000);
// Prepare the parameters.
- vector<double*> parameter_blocks(2);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
// Prepare the jacobian.
- vector<vector<double>> jacobian_vect(2);
+ std::vector<std::vector<double>> jacobian_vect(2);
jacobian_vect[0].resize(21 * 10, -100000);
jacobian_vect[1].resize(21 * 5, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect[0].data());
jacobian.push_back(nullptr);
@@ -408,25 +406,25 @@
}
protected:
- vector<double> x_;
- vector<double> y_;
- vector<double> z_;
+ std::vector<double> x_;
+ std::vector<double> y_;
+ std::vector<double> z_;
- vector<double*> parameter_blocks_;
+ std::vector<double*> parameter_blocks_;
std::unique_ptr<CostFunction> cost_function_;
- vector<vector<double>> jacobian_vect_;
+ std::vector<std::vector<double>> jacobian_vect_;
- vector<double> expected_residuals_;
+ std::vector<double> expected_residuals_;
- vector<double> expected_jacobian_x_;
- vector<double> expected_jacobian_y_;
- vector<double> expected_jacobian_z_;
+ std::vector<double> expected_jacobian_x_;
+ std::vector<double> expected_jacobian_y_;
+ std::vector<double> expected_jacobian_z_;
};
TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
EXPECT_TRUE(cost_function_->Evaluate(
parameter_blocks_.data(), residuals.data(), nullptr));
for (int i = 0; i < 7; ++i) {
@@ -435,9 +433,9 @@
}
TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterJacobian) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect_[0].data());
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(jacobian_vect_[2].data());
@@ -464,9 +462,9 @@
TEST_F(ThreeParameterCostFunctorTest,
ThreeParameterJacobianWithFirstAndLastParameterBlockConstant) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(nullptr);
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(nullptr);
@@ -485,9 +483,9 @@
TEST_F(ThreeParameterCostFunctorTest,
ThreeParameterJacobianWithSecondParameterBlockConstant) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect_[0].data());
jacobian.push_back(nullptr);
jacobian.push_back(jacobian_vect_[2].data());
@@ -654,18 +652,18 @@
double z1_;
double z2_;
- vector<double*> parameter_blocks_;
+ std::vector<double*> parameter_blocks_;
std::unique_ptr<CostFunction> cost_function_;
- vector<vector<double>> jacobian_vect_;
+ std::vector<std::vector<double>> jacobian_vect_;
- vector<double> expected_residuals_;
- vector<vector<double>> expected_jacobians_;
+ std::vector<double> expected_residuals_;
+ std::vector<std::vector<double>> expected_jacobians_;
};
TEST_F(SixParameterCostFunctorTest, TestSixParameterResiduals) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
EXPECT_TRUE(cost_function_->Evaluate(
parameter_blocks_.data(), residuals.data(), nullptr));
for (int i = 0; i < 7; ++i) {
@@ -674,9 +672,9 @@
}
TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobian) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect_[0].data());
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(jacobian_vect_[2].data());
@@ -699,9 +697,9 @@
}
TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobianVVCVVC) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect_[0].data());
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(nullptr);
@@ -729,9 +727,9 @@
}
TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobianVCCVCV) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect_[0].data());
jacobian.push_back(nullptr);
jacobian.push_back(nullptr);
diff --git a/internal/ceres/dynamic_compressed_row_jacobian_writer.cc b/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
index a97c333..78d1875 100644
--- a/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
+++ b/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
@@ -41,9 +41,6 @@
namespace ceres::internal {
-using std::pair;
-using std::vector;
-
std::unique_ptr<ScratchEvaluatePreparer[]>
DynamicCompressedRowJacobianWriter::CreateEvaluatePreparers(int num_threads) {
return ScratchEvaluatePreparer::Create(*program_, num_threads);
@@ -68,7 +65,7 @@
program_->residual_blocks()[residual_id];
const int num_residuals = residual_block->NumResiduals();
- vector<pair<int, int>> evaluated_jacobian_blocks;
+ std::vector<std::pair<int, int>> evaluated_jacobian_blocks;
CompressedRowJacobianWriter::GetOrderedParameterBlocks(
program_, residual_id, &evaluated_jacobian_blocks);
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
index 269858f..c32233c 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
@@ -42,9 +42,6 @@
namespace ceres {
namespace internal {
-using std::copy;
-using std::vector;
-
class DynamicCompressedRowSparseMatrixTest : public ::testing::Test {
protected:
void SetUp() final {
@@ -82,8 +79,8 @@
}
void InitialiseSparseMatrixReferences() {
- vector<int> rows, cols;
- vector<double> values;
+ std::vector<int> rows, cols;
+ std::vector<double> values;
for (int i = 0; i < (num_rows * num_cols); ++i) {
const int r = i / num_cols, c = i % num_cols;
if (r != c) {
@@ -96,9 +93,9 @@
tsm = std::make_unique<TripletSparseMatrix>(
num_rows, num_cols, expected_num_nonzeros);
- copy(rows.begin(), rows.end(), tsm->mutable_rows());
- copy(cols.begin(), cols.end(), tsm->mutable_cols());
- copy(values.begin(), values.end(), tsm->mutable_values());
+ std::copy(rows.begin(), rows.end(), tsm->mutable_rows());
+ std::copy(cols.begin(), cols.end(), tsm->mutable_cols());
+ std::copy(values.begin(), values.end(), tsm->mutable_values());
tsm->set_num_nonzeros(values.size());
Matrix dense_from_tsm;
diff --git a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
index f2a37e3..0dae837 100644
--- a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
+++ b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
@@ -38,8 +38,6 @@
namespace ceres::internal {
-using std::vector;
-
const double kTolerance = 1e-6;
// Takes 2 parameter blocks:
@@ -74,8 +72,8 @@
};
TEST(DynamicNumericdiffCostFunctionTest, TestResiduals) {
- vector<double> param_block_0(10, 0.0);
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -83,8 +81,8 @@
cost_function.SetNumResiduals(21);
// Test residual computation.
- vector<double> residuals(21, -100000);
- vector<double*> parameter_blocks(2);
+ std::vector<double> residuals(21, -100000);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
EXPECT_TRUE(
@@ -98,11 +96,11 @@
TEST(DynamicNumericdiffCostFunctionTest, TestJacobian) {
// Test the residual counting.
- vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
param_block_0[i] = 2 * i;
}
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -110,18 +108,18 @@
cost_function.SetNumResiduals(21);
// Prepare the residuals.
- vector<double> residuals(21, -100000);
+ std::vector<double> residuals(21, -100000);
// Prepare the parameters.
- vector<double*> parameter_blocks(2);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
// Prepare the jacobian.
- vector<vector<double>> jacobian_vect(2);
+ std::vector<std::vector<double>> jacobian_vect(2);
jacobian_vect[0].resize(21 * 10, -100000);
jacobian_vect[1].resize(21 * 5, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect[0].data());
jacobian.push_back(jacobian_vect[1].data());
@@ -165,11 +163,11 @@
TEST(DynamicNumericdiffCostFunctionTest,
JacobianWithFirstParameterBlockConstant) { // NOLINT
// Test the residual counting.
- vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
param_block_0[i] = 2 * i;
}
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -177,18 +175,18 @@
cost_function.SetNumResiduals(21);
// Prepare the residuals.
- vector<double> residuals(21, -100000);
+ std::vector<double> residuals(21, -100000);
// Prepare the parameters.
- vector<double*> parameter_blocks(2);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
// Prepare the jacobian.
- vector<vector<double>> jacobian_vect(2);
+ std::vector<std::vector<double>> jacobian_vect(2);
jacobian_vect[0].resize(21 * 10, -100000);
jacobian_vect[1].resize(21 * 5, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(nullptr);
jacobian.push_back(jacobian_vect[1].data());
@@ -215,11 +213,11 @@
TEST(DynamicNumericdiffCostFunctionTest,
JacobianWithSecondParameterBlockConstant) { // NOLINT
// Test the residual counting.
- vector<double> param_block_0(10, 0.0);
+ std::vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
param_block_0[i] = 2 * i;
}
- vector<double> param_block_1(5, 0.0);
+ std::vector<double> param_block_1(5, 0.0);
DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
new MyCostFunctor());
cost_function.AddParameterBlock(param_block_0.size());
@@ -227,18 +225,18 @@
cost_function.SetNumResiduals(21);
// Prepare the residuals.
- vector<double> residuals(21, -100000);
+ std::vector<double> residuals(21, -100000);
// Prepare the parameters.
- vector<double*> parameter_blocks(2);
+ std::vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
// Prepare the jacobian.
- vector<vector<double>> jacobian_vect(2);
+ std::vector<std::vector<double>> jacobian_vect(2);
jacobian_vect[0].resize(21 * 10, -100000);
jacobian_vect[1].resize(21 * 5, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect[0].data());
jacobian.push_back(nullptr);
@@ -409,25 +407,25 @@
}
protected:
- vector<double> x_;
- vector<double> y_;
- vector<double> z_;
+ std::vector<double> x_;
+ std::vector<double> y_;
+ std::vector<double> z_;
- vector<double*> parameter_blocks_;
+ std::vector<double*> parameter_blocks_;
std::unique_ptr<CostFunction> cost_function_;
- vector<vector<double>> jacobian_vect_;
+ std::vector<std::vector<double>> jacobian_vect_;
- vector<double> expected_residuals_;
+ std::vector<double> expected_residuals_;
- vector<double> expected_jacobian_x_;
- vector<double> expected_jacobian_y_;
- vector<double> expected_jacobian_z_;
+ std::vector<double> expected_jacobian_x_;
+ std::vector<double> expected_jacobian_y_;
+ std::vector<double> expected_jacobian_z_;
};
TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
EXPECT_TRUE(cost_function_->Evaluate(
parameter_blocks_.data(), residuals.data(), nullptr));
for (int i = 0; i < 7; ++i) {
@@ -436,9 +434,9 @@
}
TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterJacobian) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect_[0].data());
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(jacobian_vect_[2].data());
@@ -465,9 +463,9 @@
TEST_F(ThreeParameterCostFunctorTest,
ThreeParameterJacobianWithFirstAndLastParameterBlockConstant) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(nullptr);
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(nullptr);
@@ -486,9 +484,9 @@
TEST_F(ThreeParameterCostFunctorTest,
ThreeParameterJacobianWithSecondParameterBlockConstant) {
- vector<double> residuals(7, -100000);
+ std::vector<double> residuals(7, -100000);
- vector<double*> jacobian;
+ std::vector<double*> jacobian;
jacobian.push_back(jacobian_vect_[0].data());
jacobian.push_back(nullptr);
jacobian.push_back(jacobian_vect_[2].data());
diff --git a/internal/ceres/evaluator_test.cc b/internal/ceres/evaluator_test.cc
index 24da250..d9a1b21 100644
--- a/internal/ceres/evaluator_test.cc
+++ b/internal/ceres/evaluator_test.cc
@@ -52,9 +52,6 @@
namespace ceres {
namespace internal {
-using std::string;
-using std::vector;
-
// TODO(keir): Consider pushing this into a common test utils file.
template <int kFactor, int kNumResiduals, int... Ns>
class ParameterIgnoringCostFunction
@@ -122,7 +119,7 @@
program->SetParameterOffsetsAndIndex();
if (VLOG_IS_ON(1)) {
- string report;
+ std::string report;
StringAppendF(&report,
"Creating evaluator with type: %d",
GetParam().linear_solver_type);
@@ -140,7 +137,7 @@
options.num_eliminate_blocks = GetParam().num_eliminate_blocks;
options.dynamic_sparsity = GetParam().dynamic_sparsity;
options.context = problem.context();
- string error;
+ std::string error;
return Evaluator::Create(options, program, &error);
}
@@ -171,7 +168,7 @@
ASSERT_EQ(expected_num_rows, jacobian->num_rows());
ASSERT_EQ(expected_num_cols, jacobian->num_cols());
- vector<double> state(evaluator->NumParameters());
+ std::vector<double> state(evaluator->NumParameters());
// clang-format off
ASSERT_TRUE(evaluator->Evaluate(
@@ -399,12 +396,12 @@
problem.AddParameterBlock(x, 2);
// Fix y's first dimension.
- vector<int> y_fixed;
+ std::vector<int> y_fixed;
y_fixed.push_back(0);
problem.AddParameterBlock(y, 3, new SubsetManifold(3, y_fixed));
// Fix z's second dimension.
- vector<int> z_fixed;
+ std::vector<int> z_fixed;
z_fixed.push_back(1);
problem.AddParameterBlock(z, 4, new SubsetManifold(4, z_fixed));
@@ -486,7 +483,7 @@
// Normally, the preprocessing of the program that happens in solver_impl
// takes care of this, but we don't want to invoke the solver here.
Program reduced_program;
- vector<ParameterBlock*>* parameter_blocks =
+ std::vector<ParameterBlock*>* parameter_blocks =
problem.mutable_program()->mutable_parameter_blocks();
// "z" is the last parameter; save it for later and pop it off temporarily.
@@ -620,7 +617,7 @@
options.linear_solver_type = DENSE_QR;
options.num_eliminate_blocks = 0;
options.context = problem.context();
- string error;
+ std::string error;
std::unique_ptr<Evaluator> evaluator(
Evaluator::Create(options, program, &error));
std::unique_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
diff --git a/internal/ceres/file.cc b/internal/ceres/file.cc
index cd91843..601964f 100644
--- a/internal/ceres/file.cc
+++ b/internal/ceres/file.cc
@@ -38,9 +38,7 @@
namespace ceres::internal {
-using std::string;
-
-void WriteStringToFileOrDie(const string& data, const string& filename) {
+void WriteStringToFileOrDie(const std::string& data, const std::string& filename) {
FILE* file_descriptor = fopen(filename.c_str(), "wb");
if (!file_descriptor) {
LOG(FATAL) << "Couldn't write to file: " << filename;
@@ -49,7 +47,7 @@
fclose(file_descriptor);
}
-void ReadFileToStringOrDie(const string& filename, string* data) {
+void ReadFileToStringOrDie(const std::string& filename, std::string* data) {
FILE* file_descriptor = fopen(filename.c_str(), "r");
if (!file_descriptor) {
@@ -73,7 +71,7 @@
fclose(file_descriptor);
}
-string JoinPath(const string& dirname, const string& basename) {
+std::string JoinPath(const std::string& dirname, const std::string& basename) {
#ifdef _WIN32
static const char separator = '\\';
#else
@@ -85,7 +83,7 @@
} else if (dirname[dirname.size() - 1] == separator) {
return dirname + basename;
} else {
- return dirname + string(&separator, 1) + basename;
+ return dirname + std::string(&separator, 1) + basename;
}
}
diff --git a/internal/ceres/gradient_checker.cc b/internal/ceres/gradient_checker.cc
index 68bcf86..dfd5c6a 100644
--- a/internal/ceres/gradient_checker.cc
+++ b/internal/ceres/gradient_checker.cc
@@ -48,8 +48,6 @@
using internal::IsClose;
using internal::StringAppendF;
using internal::StringPrintf;
-using std::string;
-using std::vector;
namespace {
// Evaluate the cost function and transform the returned Jacobians to
@@ -64,12 +62,12 @@
CHECK(jacobians != nullptr);
CHECK(local_jacobians != nullptr);
- const vector<int32_t>& block_sizes = function->parameter_block_sizes();
+ const std::vector<int32_t>& block_sizes = function->parameter_block_sizes();
const int num_parameter_blocks = block_sizes.size();
// Allocate Jacobian matrices in tangent space.
local_jacobians->resize(num_parameter_blocks);
- vector<double*> local_jacobian_data(num_parameter_blocks);
+ std::vector<double*> local_jacobian_data(num_parameter_blocks);
for (int i = 0; i < num_parameter_blocks; ++i) {
int block_size = block_sizes.at(i);
if (manifolds.at(i) != nullptr) {
@@ -82,7 +80,7 @@
// Allocate Jacobian matrices in ambient space.
jacobians->resize(num_parameter_blocks);
- vector<double*> jacobian_data(num_parameter_blocks);
+ std::vector<double*> jacobian_data(num_parameter_blocks);
for (int i = 0; i < num_parameter_blocks; ++i) {
jacobians->at(i).resize(function->num_residuals(), block_sizes.at(i));
jacobians->at(i).setZero();
@@ -116,7 +114,7 @@
} // namespace
GradientChecker::GradientChecker(const CostFunction* function,
- const vector<const Manifold*>* manifolds,
+ const std::vector<const Manifold*>* manifolds,
const NumericDiffOptions& options)
: function_(function) {
CHECK(function != nullptr);
@@ -129,7 +127,7 @@
auto finite_diff_cost_function =
std::make_unique<DynamicNumericDiffCostFunction<CostFunction, RIDDERS>>(
function, DO_NOT_TAKE_OWNERSHIP, options);
- const vector<int32_t>& parameter_block_sizes =
+ const std::vector<int32_t>& parameter_block_sizes =
function->parameter_block_sizes();
const int num_parameter_blocks = parameter_block_sizes.size();
for (int i = 0; i < num_parameter_blocks; ++i) {
@@ -164,8 +162,8 @@
results->return_value = true;
// Evaluate the derivative using the user supplied code.
- vector<Matrix>& jacobians = results->jacobians;
- vector<Matrix>& local_jacobians = results->local_jacobians;
+ std::vector<Matrix>& jacobians = results->jacobians;
+ std::vector<Matrix>& local_jacobians = results->local_jacobians;
if (!EvaluateCostFunction(function_,
parameters,
manifolds_,
@@ -177,8 +175,8 @@
}
// Evaluate the derivative using numeric derivatives.
- vector<Matrix>& numeric_jacobians = results->numeric_jacobians;
- vector<Matrix>& local_numeric_jacobians = results->local_numeric_jacobians;
+ std::vector<Matrix>& numeric_jacobians = results->numeric_jacobians;
+ std::vector<Matrix>& local_numeric_jacobians = results->local_numeric_jacobians;
Vector finite_diff_residuals;
if (!EvaluateCostFunction(finite_diff_cost_function_.get(),
parameters,
@@ -218,7 +216,7 @@
// Accumulate the error message for all the jacobians, since it won't get
// output if there are no bad jacobian components.
- string error_log;
+ std::string error_log;
for (int k = 0; k < function_->parameter_block_sizes().size(); k++) {
StringAppendF(&error_log,
"========== "
@@ -272,7 +270,7 @@
// Since there were some bad errors, dump comprehensive debug info.
if (num_bad_jacobian_components) {
- string header = StringPrintf(
+ std::string header = StringPrintf(
"\nDetected %d bad Jacobian component(s). "
"Worst relative error was %g.\n",
num_bad_jacobian_components,
diff --git a/internal/ceres/gradient_checker_test.cc b/internal/ceres/gradient_checker_test.cc
index 1e6fe9a..3508455 100644
--- a/internal/ceres/gradient_checker_test.cc
+++ b/internal/ceres/gradient_checker_test.cc
@@ -46,7 +46,6 @@
namespace ceres::internal {
-using std::vector;
const double kTolerance = 1e-12;
// We pick a (non-quadratic) function whose derivative are easy:
@@ -115,7 +114,7 @@
private:
int arity_;
bool return_value_;
- vector<vector<double>> a_; // our vectors.
+ std::vector<std::vector<double>> a_; // our vectors.
};
class BadTestTerm : public CostFunction {
@@ -170,7 +169,7 @@
private:
int arity_;
- vector<vector<double>> a_; // our vectors.
+ std::vector<std::vector<double>> a_; // our vectors.
};
static void CheckDimensions(const GradientChecker::ProbeResults& results,
diff --git a/internal/ceres/gradient_checking_cost_function.cc b/internal/ceres/gradient_checking_cost_function.cc
index 04440c2..013a98a 100644
--- a/internal/ceres/gradient_checking_cost_function.cc
+++ b/internal/ceres/gradient_checking_cost_function.cc
@@ -54,11 +54,6 @@
namespace ceres::internal {
-using std::abs;
-using std::max;
-using std::string;
-using std::vector;
-
namespace {
class GradientCheckingCostFunction final : public CostFunction {
@@ -67,7 +62,7 @@
const std::vector<const Manifold*>* manifolds,
const NumericDiffOptions& options,
double relative_precision,
- string extra_info,
+ std::string extra_info,
GradientCheckingIterationCallback* callback)
: function_(function),
gradient_checker_(function, manifolds, options),
@@ -75,7 +70,7 @@
extra_info_(std::move(extra_info)),
callback_(callback) {
CHECK(callback_ != nullptr);
- const vector<int32_t>& parameter_block_sizes =
+ const std::vector<int32_t>& parameter_block_sizes =
function->parameter_block_sizes();
*mutable_parameter_block_sizes() = parameter_block_sizes;
set_num_residuals(function->num_residuals());
@@ -104,7 +99,7 @@
MatrixRef(residuals, num_residuals, 1) = results.residuals;
// Copy the original jacobian blocks into the jacobians array.
- const vector<int32_t>& block_sizes = function_->parameter_block_sizes();
+ const std::vector<int32_t>& block_sizes = function_->parameter_block_sizes();
for (int k = 0; k < block_sizes.size(); k++) {
if (jacobians[k] != nullptr) {
MatrixRef(jacobians[k],
@@ -126,7 +121,7 @@
const CostFunction* function_;
GradientChecker gradient_checker_;
double relative_precision_;
- string extra_info_;
+ std::string extra_info_;
GradientCheckingIterationCallback* callback_;
};
@@ -197,7 +192,7 @@
// For every ParameterBlock in problem_impl, create a new parameter block with
// the same manifold and constancy.
- const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+ const std::vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
for (auto* parameter_block : parameter_blocks) {
gradient_checking_problem_impl->AddParameterBlock(
parameter_block->mutable_user_state(),
@@ -224,17 +219,17 @@
// For every ResidualBlock in problem_impl, create a new
// ResidualBlock by wrapping its CostFunction inside a
// GradientCheckingCostFunction.
- const vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
+ const std::vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
for (int i = 0; i < residual_blocks.size(); ++i) {
ResidualBlock* residual_block = residual_blocks[i];
// Build a human readable string which identifies the
// ResidualBlock. This is used by the GradientCheckingCostFunction
// when logging debugging information.
- string extra_info =
+ std::string extra_info =
StringPrintf("Residual block id %d; depends on parameters [", i);
- vector<double*> parameter_blocks;
- vector<const Manifold*> manifolds;
+ std::vector<double*> parameter_blocks;
+ std::vector<const Manifold*> manifolds;
parameter_blocks.reserve(residual_block->NumParameterBlocks());
manifolds.reserve(residual_block->NumParameterBlocks());
for (int j = 0; j < residual_block->NumParameterBlocks(); ++j) {
diff --git a/internal/ceres/gradient_checking_cost_function_test.cc b/internal/ceres/gradient_checking_cost_function_test.cc
index 87c3278..027aa67 100644
--- a/internal/ceres/gradient_checking_cost_function_test.cc
+++ b/internal/ceres/gradient_checking_cost_function_test.cc
@@ -51,7 +51,6 @@
namespace ceres::internal {
-using std::vector;
using testing::_;
using testing::AllOf;
using testing::AnyNumber;
@@ -128,7 +127,7 @@
private:
int arity_;
- vector<vector<double>> a_;
+ std::vector<std::vector<double>> a_;
};
TEST(GradientCheckingCostFunction, ResidualsAndJacobiansArePreservedTest) {
@@ -137,7 +136,7 @@
int const dim[arity] = {2, 3, 4};
// Make a random set of blocks.
- vector<double*> parameters(arity);
+ std::vector<double*> parameters(arity);
std::mt19937 prng;
std::uniform_real_distribution<double> distribution(-1.0, 1.0);
auto randu = [&prng, &distribution] { return distribution(prng); };
@@ -150,8 +149,8 @@
double original_residual;
double residual;
- vector<double*> original_jacobians(arity);
- vector<double*> jacobians(arity);
+ std::vector<double*> original_jacobians(arity);
+ std::vector<double*> jacobians(arity);
for (int j = 0; j < arity; ++j) {
// Since residual is one dimensional the jacobians have the same
@@ -195,7 +194,7 @@
int const dim[arity] = {2, 3, 4};
// Make a random set of blocks.
- vector<double*> parameters(arity);
+ std::vector<double*> parameters(arity);
std::mt19937 prng;
std::uniform_real_distribution<double> distribution(-1.0, 1.0);
auto randu = [&prng, &distribution] { return distribution(prng); };
@@ -207,7 +206,7 @@
}
double residual;
- vector<double*> jacobians(arity);
+ std::vector<double*> jacobians(arity);
for (int j = 0; j < arity; ++j) {
// Since residual is one dimensional the jacobians have the same size as the
// parameter blocks.
diff --git a/internal/ceres/gradient_problem_solver.cc b/internal/ceres/gradient_problem_solver.cc
index 114b0ee..3438409 100644
--- a/internal/ceres/gradient_problem_solver.cc
+++ b/internal/ceres/gradient_problem_solver.cc
@@ -49,7 +49,6 @@
namespace ceres {
using internal::StringAppendF;
using internal::StringPrintf;
-using std::string;
namespace {
@@ -181,7 +180,7 @@
SetSummaryFinalCost(summary);
}
- const std::map<string, CallStatistics>& evaluator_statistics =
+ const std::map<std::string, CallStatistics>& evaluator_statistics =
minimizer_options.evaluator->Statistics();
{
const CallStatistics& call_stats = FindWithDefault(
@@ -204,7 +203,7 @@
return internal::IsSolutionUsable(*this);
}
-string GradientProblemSolver::Summary::BriefReport() const {
+std::string GradientProblemSolver::Summary::BriefReport() const {
return StringPrintf(
"Ceres GradientProblemSolver Report: "
"Iterations: %d, "
@@ -217,12 +216,12 @@
TerminationTypeToString(termination_type));
}
-string GradientProblemSolver::Summary::FullReport() const {
+std::string GradientProblemSolver::Summary::FullReport() const {
using internal::VersionString;
// NOTE operator+ is not usable for concatenating a string and a string_view.
- string report =
- string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
+ std::string report =
+ std::string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
StringAppendF(&report, "Parameters % 25d\n", num_parameters);
if (num_tangent_parameters != num_parameters) {
@@ -230,7 +229,7 @@
&report, "Tangent parameters % 25d\n", num_tangent_parameters);
}
- string line_search_direction_string;
+ std::string line_search_direction_string;
if (line_search_direction_type == LBFGS) {
line_search_direction_string = StringPrintf("LBFGS (%d)", max_lbfgs_rank);
} else if (line_search_direction_type == NONLINEAR_CONJUGATE_GRADIENT) {
@@ -245,7 +244,7 @@
"Line search direction %19s\n",
line_search_direction_string.c_str());
- const string line_search_type_string = StringPrintf(
+ const std::string line_search_type_string = StringPrintf(
"%s %s",
LineSearchInterpolationTypeToString(line_search_interpolation_type),
LineSearchTypeToString(line_search_type));
diff --git a/internal/ceres/graph_algorithms_test.cc b/internal/ceres/graph_algorithms_test.cc
index c03cda4..ac56497 100644
--- a/internal/ceres/graph_algorithms_test.cc
+++ b/internal/ceres/graph_algorithms_test.cc
@@ -40,8 +40,6 @@
namespace ceres::internal {
-using std::vector;
-
TEST(IndependentSetOrdering, Chain) {
Graph<int> graph;
graph.AddVertex(0);
@@ -57,7 +55,7 @@
// 0-1-2-3-4
// 0, 2, 4 should be in the independent set.
- vector<int> ordering;
+ std::vector<int> ordering;
int independent_set_size = IndependentSetOrdering(graph, &ordering);
sort(ordering.begin(), ordering.begin() + 3);
@@ -91,7 +89,7 @@
// |
// 3
// 1, 2, 3, 4 should be in the independent set.
- vector<int> ordering;
+ std::vector<int> ordering;
int independent_set_size = IndependentSetOrdering(graph, &ordering);
EXPECT_EQ(independent_set_size, 4);
EXPECT_EQ(ordering.size(), 5);
@@ -219,7 +217,7 @@
// guarantees that it will always be the first vertex in the
// ordering vector.
{
- vector<int> ordering;
+ std::vector<int> ordering;
ordering.push_back(0);
ordering.push_back(1);
ordering.push_back(2);
@@ -231,7 +229,7 @@
}
{
- vector<int> ordering;
+ std::vector<int> ordering;
ordering.push_back(1);
ordering.push_back(0);
ordering.push_back(2);
diff --git a/internal/ceres/line_search.cc b/internal/ceres/line_search.cc
index 68d6bbe..2b6fe4d 100644
--- a/internal/ceres/line_search.cc
+++ b/internal/ceres/line_search.cc
@@ -47,20 +47,15 @@
namespace ceres::internal {
-using std::map;
-using std::ostream;
-using std::string;
-using std::vector;
-
namespace {
// Precision used for floating point values in error message output.
const int kErrorMessageNumericPrecision = 8;
} // namespace
-ostream& operator<<(ostream& os, const FunctionSample& sample);
+std::ostream& operator<<(std::ostream& os, const FunctionSample& sample);
// Convenience stream operator for pushing FunctionSamples into log messages.
-ostream& operator<<(ostream& os, const FunctionSample& sample) {
+std::ostream& operator<<(std::ostream& os, const FunctionSample& sample) {
os << sample.ToDebugString();
return os;
}
@@ -73,16 +68,16 @@
std::unique_ptr<LineSearch> LineSearch::Create(
const LineSearchType line_search_type,
const LineSearch::Options& options,
- string* error) {
+ std::string* error) {
switch (line_search_type) {
case ceres::ARMIJO:
return std::make_unique<ArmijoLineSearch>(options);
case ceres::WOLFE:
return std::make_unique<WolfeLineSearch>(options);
default:
- *error = string("Invalid line search algorithm type: ") +
+ *error = std::string("Invalid line search algorithm type: ") +
LineSearchTypeToString(line_search_type) +
- string(", unable to create line search.");
+ std::string(", unable to create line search.");
}
return nullptr;
}
@@ -149,7 +144,7 @@
}
void LineSearchFunction::ResetTimeStatistics() {
- const map<string, CallStatistics> evaluator_statistics =
+ const std::map<std::string, CallStatistics> evaluator_statistics =
evaluator_->Statistics();
initial_evaluator_residual_time_in_seconds =
@@ -165,7 +160,7 @@
void LineSearchFunction::TimeStatistics(
double* cost_evaluation_time_in_seconds,
double* gradient_evaluation_time_in_seconds) const {
- const map<string, CallStatistics> evaluator_time_statistics =
+ const std::map<std::string, CallStatistics> evaluator_time_statistics =
evaluator_->Statistics();
*cost_evaluation_time_in_seconds =
FindWithDefault(
@@ -242,7 +237,7 @@
// Select step size by interpolating the function and gradient values
// and minimizing the corresponding polynomial.
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
samples.push_back(lowerbound);
if (interpolation_type == QUADRATIC) {
diff --git a/internal/ceres/linear_least_squares_problems.cc b/internal/ceres/linear_least_squares_problems.cc
index 4c55fbc..7b87c9a 100644
--- a/internal/ceres/linear_least_squares_problems.cc
+++ b/internal/ceres/linear_least_squares_problems.cc
@@ -46,8 +46,6 @@
namespace ceres::internal {
-using std::string;
-
std::unique_ptr<LinearLeastSquaresProblem>
CreateLinearLeastSquaresProblemFromId(int id) {
switch (id) {
@@ -952,7 +950,7 @@
return true;
}
-void WriteArrayToFileOrDie(const string& filename,
+void WriteArrayToFileOrDie(const std::string& filename,
const double* x,
const int size) {
CHECK(x != nullptr);
@@ -965,7 +963,7 @@
fclose(fptr);
}
-bool DumpLinearLeastSquaresProblemToTextFile(const string& filename_base,
+bool DumpLinearLeastSquaresProblemToTextFile(const std::string& filename_base,
const SparseMatrix* A,
const double* D,
const double* b,
@@ -974,14 +972,14 @@
CHECK(A != nullptr);
LOG(INFO) << "writing to: " << filename_base << "*";
- string matlab_script;
+ std::string matlab_script;
StringAppendF(&matlab_script,
"function lsqp = load_trust_region_problem()\n");
StringAppendF(&matlab_script, "lsqp.num_rows = %d;\n", A->num_rows());
StringAppendF(&matlab_script, "lsqp.num_cols = %d;\n", A->num_cols());
{
- string filename = filename_base + "_A.txt";
+ std::string filename = filename_base + "_A.txt";
FILE* fptr = fopen(filename.c_str(), "w");
CHECK(fptr != nullptr);
A->ToTextFile(fptr);
@@ -996,33 +994,33 @@
}
if (D != nullptr) {
- string filename = filename_base + "_D.txt";
+ std::string filename = filename_base + "_D.txt";
WriteArrayToFileOrDie(filename, D, A->num_cols());
StringAppendF(
&matlab_script, "lsqp.D = load('%s', '-ascii');\n", filename.c_str());
}
if (b != nullptr) {
- string filename = filename_base + "_b.txt";
+ std::string filename = filename_base + "_b.txt";
WriteArrayToFileOrDie(filename, b, A->num_rows());
StringAppendF(
&matlab_script, "lsqp.b = load('%s', '-ascii');\n", filename.c_str());
}
if (x != nullptr) {
- string filename = filename_base + "_x.txt";
+ std::string filename = filename_base + "_x.txt";
WriteArrayToFileOrDie(filename, x, A->num_cols());
StringAppendF(
&matlab_script, "lsqp.x = load('%s', '-ascii');\n", filename.c_str());
}
- string matlab_filename = filename_base + ".m";
+ std::string matlab_filename = filename_base + ".m";
WriteStringToFileOrDie(matlab_script, matlab_filename);
return true;
}
} // namespace
-bool DumpLinearLeastSquaresProblem(const string& filename_base,
+bool DumpLinearLeastSquaresProblem(const std::string& filename_base,
DumpFormatType dump_format_type,
const SparseMatrix* A,
const double* D,
diff --git a/internal/ceres/low_rank_inverse_hessian.cc b/internal/ceres/low_rank_inverse_hessian.cc
index c471844..a11a197 100644
--- a/internal/ceres/low_rank_inverse_hessian.cc
+++ b/internal/ceres/low_rank_inverse_hessian.cc
@@ -37,8 +37,6 @@
namespace ceres::internal {
-using std::list;
-
// The (L)BFGS algorithm explicitly requires that the secant equation:
//
// B_{k+1} * s_k = y_k
diff --git a/internal/ceres/parameter_block_ordering.cc b/internal/ceres/parameter_block_ordering.cc
index c01eb20..5f675ab 100644
--- a/internal/ceres/parameter_block_ordering.cc
+++ b/internal/ceres/parameter_block_ordering.cc
@@ -44,19 +44,15 @@
namespace ceres::internal {
-using std::map;
-using std::set;
-using std::vector;
-
int ComputeStableSchurOrdering(const Program& program,
- vector<ParameterBlock*>* ordering) {
+ std::vector<ParameterBlock*>* ordering) {
CHECK(ordering != nullptr);
ordering->clear();
EventLogger event_logger("ComputeStableSchurOrdering");
auto graph = CreateHessianGraph(program);
event_logger.AddEvent("CreateHessianGraph");
- const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+ const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
const std::unordered_set<ParameterBlock*>& vertices = graph->vertices();
for (auto* parameter_block : parameter_blocks) {
if (vertices.count(parameter_block) > 0) {
@@ -80,13 +76,13 @@
}
int ComputeSchurOrdering(const Program& program,
- vector<ParameterBlock*>* ordering) {
+ std::vector<ParameterBlock*>* ordering) {
CHECK(ordering != nullptr);
ordering->clear();
auto graph = CreateHessianGraph(program);
int independent_set_size = IndependentSetOrdering(*graph, ordering);
- const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+ const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
// Add the excluded blocks to back of the ordering vector.
for (auto* parameter_block : parameter_blocks) {
@@ -102,13 +98,13 @@
ParameterBlockOrdering* ordering) {
CHECK(ordering != nullptr);
ordering->Clear();
- const vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
+ const std::vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
auto graph = CreateHessianGraph(program);
int num_covered = 0;
int round = 0;
while (num_covered < parameter_blocks.size()) {
- vector<ParameterBlock*> independent_set_ordering;
+ std::vector<ParameterBlock*> independent_set_ordering;
const int independent_set_size =
IndependentSetOrdering(*graph, &independent_set_ordering);
for (int i = 0; i < independent_set_size; ++i) {
@@ -125,14 +121,14 @@
const Program& program) {
auto graph = std::make_unique<Graph<ParameterBlock*>>();
CHECK(graph != nullptr);
- const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+ const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
for (auto* parameter_block : parameter_blocks) {
if (!parameter_block->IsConstant()) {
graph->AddVertex(parameter_block);
}
}
- const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
+ const std::vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
for (auto* residual_block : residual_blocks) {
const int num_parameter_blocks = residual_block->NumParameterBlocks();
ParameterBlock* const* parameter_blocks =
@@ -156,14 +152,14 @@
}
void OrderingToGroupSizes(const ParameterBlockOrdering* ordering,
- vector<int>* group_sizes) {
+ std::vector<int>* group_sizes) {
CHECK(group_sizes != nullptr);
group_sizes->clear();
if (ordering == nullptr) {
return;
}
- const map<int, set<double*>>& group_to_elements =
+ const std::map<int, std::set<double*>>& group_to_elements =
ordering->group_to_elements();
for (const auto& g_t_e : group_to_elements) {
group_sizes->push_back(g_t_e.second.size());
diff --git a/internal/ceres/polynomial.cc b/internal/ceres/polynomial.cc
index a3e790d..0577643 100644
--- a/internal/ceres/polynomial.cc
+++ b/internal/ceres/polynomial.cc
@@ -42,8 +42,6 @@
namespace ceres::internal {
-using std::vector;
-
namespace {
// Balancing function as described by B. N. Parlett and C. Reinsch,
@@ -325,7 +323,7 @@
}
}
-Vector FindInterpolatingPolynomial(const vector<FunctionSample>& samples) {
+Vector FindInterpolatingPolynomial(const std::vector<FunctionSample>& samples) {
const int num_samples = samples.size();
int num_constraints = 0;
for (int i = 0; i < num_samples; ++i) {
@@ -368,7 +366,7 @@
return lu.setThreshold(0.0).solve(rhs);
}
-void MinimizeInterpolatingPolynomial(const vector<FunctionSample>& samples,
+void MinimizeInterpolatingPolynomial(const std::vector<FunctionSample>& samples,
double x_min,
double x_max,
double* optimal_x,
diff --git a/internal/ceres/polynomial_test.cc b/internal/ceres/polynomial_test.cc
index 6b6d718..ea701b0 100644
--- a/internal/ceres/polynomial_test.cc
+++ b/internal/ceres/polynomial_test.cc
@@ -42,8 +42,6 @@
namespace ceres::internal {
-using std::vector;
-
namespace {
// For IEEE-754 doubles, machine precision is about 2e-16.
@@ -314,7 +312,7 @@
Vector true_polynomial(1);
true_polynomial << 1.0;
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
FunctionSample sample;
sample.x = 1.0;
sample.value = 1.0;
@@ -330,7 +328,7 @@
Vector true_polynomial(2);
true_polynomial << 2.0, -1.0;
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
FunctionSample sample;
sample.x = 1.0;
sample.value = 1.0;
@@ -348,7 +346,7 @@
Vector true_polynomial(3);
true_polynomial << 2.0, 3.0, 2.0;
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
{
FunctionSample sample;
sample.x = 1.0;
@@ -376,7 +374,7 @@
Vector true_polynomial(4);
true_polynomial << 0.0, 2.0, 3.0, 2.0;
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
{
FunctionSample sample;
sample.x = 1.0;
@@ -406,7 +404,7 @@
Vector true_polynomial(4);
true_polynomial << 1.0, 2.0, 3.0, 2.0;
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
{
FunctionSample sample;
sample.x = 1.0;
@@ -449,7 +447,7 @@
true_polynomial << 1.0, 2.0, 3.0, 2.0;
Vector true_gradient_polynomial = DifferentiatePolynomial(true_polynomial);
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
{
FunctionSample sample;
sample.x = 1.0;
@@ -486,7 +484,7 @@
true_polynomial << 1.0, 2.0, 3.0, 2.0;
Vector true_gradient_polynomial = DifferentiatePolynomial(true_polynomial);
- vector<FunctionSample> samples;
+ std::vector<FunctionSample> samples;
{
FunctionSample sample;
sample.x = -3.0;
diff --git a/internal/ceres/problem.cc b/internal/ceres/problem.cc
index e8589be..ca775fc 100644
--- a/internal/ceres/problem.cc
+++ b/internal/ceres/problem.cc
@@ -39,8 +39,6 @@
namespace ceres {
-using std::vector;
-
Problem::Problem() : impl_(new internal::ProblemImpl) {}
Problem::Problem(const Problem::Options& options)
: impl_(new internal::ProblemImpl(options)) {}
@@ -52,7 +50,7 @@
ResidualBlockId Problem::AddResidualBlock(
CostFunction* cost_function,
LossFunction* loss_function,
- const vector<double*>& parameter_blocks) {
+ const std::vector<double*>& parameter_blocks) {
return impl_->AddResidualBlock(cost_function,
loss_function,
parameter_blocks.data(),
@@ -129,8 +127,8 @@
bool Problem::Evaluate(const EvaluateOptions& evaluate_options,
double* cost,
- vector<double>* residuals,
- vector<double>* gradient,
+ std::vector<double>* residuals,
+ std::vector<double>* gradient,
CRSMatrix* jacobian) {
return impl_->Evaluate(evaluate_options, cost, residuals, gradient, jacobian);
}
@@ -182,18 +180,18 @@
return impl_->HasParameterBlock(values);
}
-void Problem::GetParameterBlocks(vector<double*>* parameter_blocks) const {
+void Problem::GetParameterBlocks(std::vector<double*>* parameter_blocks) const {
impl_->GetParameterBlocks(parameter_blocks);
}
void Problem::GetResidualBlocks(
- vector<ResidualBlockId>* residual_blocks) const {
+ std::vector<ResidualBlockId>* residual_blocks) const {
impl_->GetResidualBlocks(residual_blocks);
}
void Problem::GetParameterBlocksForResidualBlock(
const ResidualBlockId residual_block,
- vector<double*>* parameter_blocks) const {
+ std::vector<double*>* parameter_blocks) const {
impl_->GetParameterBlocksForResidualBlock(residual_block, parameter_blocks);
}
@@ -208,7 +206,7 @@
}
void Problem::GetResidualBlocksForParameterBlock(
- const double* values, vector<ResidualBlockId>* residual_blocks) const {
+ const double* values, std::vector<ResidualBlockId>* residual_blocks) const {
impl_->GetResidualBlocksForParameterBlock(values, residual_blocks);
}
diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index eb5a86f..a3f26dd 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc
@@ -52,8 +52,6 @@
namespace ceres::internal {
-using std::vector;
-
// The following three classes are for the purposes of defining
// function signatures. They have dummy Evaluate functions.
@@ -624,14 +622,14 @@
problem.AddParameterBlock(x, 3);
problem.AddParameterBlock(y, 4);
- vector<int> constant_parameters;
+ std::vector<int> constant_parameters;
constant_parameters.push_back(0);
problem.SetManifold(x, new SubsetManifold(3, constant_parameters));
EXPECT_EQ(problem.ParameterBlockSize(x), 3);
EXPECT_EQ(problem.ParameterBlockTangentSize(x), 2);
EXPECT_EQ(problem.ParameterBlockTangentSize(y), 4);
- vector<double*> parameter_blocks;
+ std::vector<double*> parameter_blocks;
problem.GetParameterBlocks(¶meter_blocks);
EXPECT_EQ(parameter_blocks.size(), 2);
EXPECT_NE(parameter_blocks[0], parameter_blocks[1]);
@@ -653,14 +651,14 @@
problem.AddParameterBlock(x, 3);
problem.AddParameterBlock(y, 4);
- vector<int> constant_parameters;
+ std::vector<int> constant_parameters;
constant_parameters.push_back(0);
problem.SetManifold(x, new SubsetManifold(3, constant_parameters));
EXPECT_EQ(problem.ParameterBlockSize(x), 3);
EXPECT_EQ(problem.ParameterBlockTangentSize(x), 2);
EXPECT_EQ(problem.ParameterBlockTangentSize(y), 4);
- vector<double*> parameter_blocks;
+ std::vector<double*> parameter_blocks;
problem.GetParameterBlocks(¶meter_blocks);
EXPECT_EQ(parameter_blocks.size(), 2);
EXPECT_NE(parameter_blocks[0], parameter_blocks[1]);
@@ -978,7 +976,7 @@
// Check that a null-terminated array, a, has the same elements as b.
template <typename T>
-void ExpectVectorContainsUnordered(const T* a, const vector<T>& b) {
+void ExpectVectorContainsUnordered(const T* a, const std::vector<T>& b) {
// Compute the size of a.
int size = 0;
while (a[size]) {
@@ -987,12 +985,12 @@
ASSERT_EQ(size, b.size());
// Sort a.
- vector<T> a_sorted(size);
+ std::vector<T> a_sorted(size);
copy(a, a + size, a_sorted.begin());
sort(a_sorted.begin(), a_sorted.end());
// Sort b.
- vector<T> b_sorted(b);
+ std::vector<T> b_sorted(b);
sort(b_sorted.begin(), b_sorted.end());
// Compare.
@@ -1004,7 +1002,7 @@
static void ExpectProblemHasResidualBlocks(
const ProblemImpl& problem,
const ResidualBlockId* expected_residual_blocks) {
- vector<ResidualBlockId> residual_blocks;
+ std::vector<ResidualBlockId> residual_blocks;
problem.GetResidualBlocks(&residual_blocks);
ExpectVectorContainsUnordered(expected_residual_blocks, residual_blocks);
}
@@ -1065,8 +1063,8 @@
ExpectProblemHasResidualBlocks(*problem, expected_residuals);
}
- vector<double*> parameter_blocks;
- vector<ResidualBlockId> residual_blocks;
+ std::vector<double*> parameter_blocks;
+ std::vector<ResidualBlockId> residual_blocks;
// Check GetResidualBlocksForParameterBlock() for all parameter blocks.
struct GetResidualBlocksForParameterBlockTestCase {
@@ -1208,8 +1206,8 @@
const double* expected_gradient,
const double* expected_jacobian) {
double cost;
- vector<double> residuals;
- vector<double> gradient;
+ std::vector<double> residuals;
+ std::vector<double> gradient;
CRSMatrix jacobian;
EXPECT_TRUE(
@@ -1264,8 +1262,8 @@
ProblemImpl problem_;
double parameters_[6];
- vector<double*> parameter_blocks_;
- vector<ResidualBlockId> residual_blocks_;
+ std::vector<double*> parameter_blocks_;
+ std::vector<ResidualBlockId> residual_blocks_;
};
TEST_F(ProblemEvaluateTest, MultipleParameterAndResidualBlocks) {
@@ -1591,7 +1589,7 @@
};
// clang-format on
- vector<int> constant_parameters;
+ std::vector<int> constant_parameters;
constant_parameters.push_back(0);
problem_.SetManifold(parameters_ + 2,
new SubsetManifold(2, constant_parameters));
diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index 300a3a5..115d905 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -46,9 +46,6 @@
namespace ceres {
namespace internal {
-using std::string;
-using std::vector;
-
// A cost function that simply returns its argument.
class UnaryIdentityCostFunction : public SizedCostFunction<1, 1> {
public:
@@ -96,9 +93,9 @@
problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
problem.AddResidualBlock(new TernaryCostFunction(), nullptr, &x, &y, &z);
- vector<double*> removed_parameter_blocks;
+ std::vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
- string message;
+ std::string message;
std::unique_ptr<Program> reduced_program(
problem.program().CreateReducedProgram(
&removed_parameter_blocks, &fixed_cost, &message));
@@ -117,9 +114,9 @@
problem.AddResidualBlock(new UnaryCostFunction(), nullptr, &x);
problem.SetParameterBlockConstant(&x);
- vector<double*> removed_parameter_blocks;
+ std::vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
- string message;
+ std::string message;
std::unique_ptr<Program> reduced_program(
problem.program().CreateReducedProgram(
&removed_parameter_blocks, &fixed_cost, &message));
@@ -141,9 +138,9 @@
problem.AddParameterBlock(&y, 1);
problem.AddParameterBlock(&z, 1);
- vector<double*> removed_parameter_blocks;
+ std::vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
- string message;
+ std::string message;
std::unique_ptr<Program> reduced_program(
problem.program().CreateReducedProgram(
&removed_parameter_blocks, &fixed_cost, &message));
@@ -167,9 +164,9 @@
problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
problem.SetParameterBlockConstant(&x);
- vector<double*> removed_parameter_blocks;
+ std::vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
- string message;
+ std::string message;
std::unique_ptr<Program> reduced_program(
problem.program().CreateReducedProgram(
&removed_parameter_blocks, &fixed_cost, &message));
@@ -191,9 +188,9 @@
problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
problem.SetParameterBlockConstant(&x);
- vector<double*> removed_parameter_blocks;
+ std::vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
- string message;
+ std::string message;
std::unique_ptr<Program> reduced_program(
problem.program().CreateReducedProgram(
&removed_parameter_blocks, &fixed_cost, &message));
@@ -223,9 +220,9 @@
expected_removed_block->Evaluate(
true, &expected_fixed_cost, nullptr, nullptr, scratch.get());
- vector<double*> removed_parameter_blocks;
+ std::vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
- string message;
+ std::string message;
std::unique_ptr<Program> reduced_program(
problem.program().CreateReducedProgram(
&removed_parameter_blocks, &fixed_cost, &message));
@@ -347,7 +344,7 @@
ProblemImpl problem;
double x[20];
- vector<double*> parameter_blocks;
+ std::vector<double*> parameter_blocks;
for (int i = 0; i < 20; ++i) {
problem.AddParameterBlock(x + i, 1);
parameter_blocks.push_back(x + i);
@@ -392,9 +389,9 @@
x[0] = 1.0;
x[1] = std::numeric_limits<double>::quiet_NaN();
problem.AddResidualBlock(new MockCostFunctionBase<1, 2>(), nullptr, x);
- string error;
+ std::string error;
EXPECT_FALSE(problem.program().ParameterBlocksAreFinite(&error));
- EXPECT_NE(error.find("has at least one invalid value"), string::npos)
+ EXPECT_NE(error.find("has at least one invalid value"), std::string::npos)
<< error;
}
@@ -404,9 +401,9 @@
problem.AddResidualBlock(new MockCostFunctionBase<1, 2>(), nullptr, x);
problem.SetParameterLowerBound(x, 0, 2.0);
problem.SetParameterUpperBound(x, 0, 1.0);
- string error;
+ std::string error;
EXPECT_FALSE(problem.program().IsFeasible(&error));
- EXPECT_NE(error.find("infeasible bound"), string::npos) << error;
+ EXPECT_NE(error.find("infeasible bound"), std::string::npos) << error;
}
TEST(Program, InfeasibleConstantParameterBlock) {
@@ -416,9 +413,9 @@
problem.SetParameterLowerBound(x, 0, 1.0);
problem.SetParameterUpperBound(x, 0, 2.0);
problem.SetParameterBlockConstant(x);
- string error;
+ std::string error;
EXPECT_FALSE(problem.program().IsFeasible(&error));
- EXPECT_NE(error.find("infeasible value"), string::npos) << error;
+ EXPECT_NE(error.find("infeasible value"), std::string::npos) << error;
}
} // namespace internal
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index 912fe3d..6c5318b 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -64,11 +64,6 @@
namespace ceres::internal {
-using std::map;
-using std::set;
-using std::string;
-using std::vector;
-
namespace {
// Find the minimum index of any parameter block to the given
@@ -99,7 +94,7 @@
const int* rows = block_jacobian_transpose.rows();
const int* cols = block_jacobian_transpose.cols();
int num_nonzeros = block_jacobian_transpose.num_nonzeros();
- vector<Triplet> triplets;
+ std::vector<Triplet> triplets;
triplets.reserve(num_nonzeros);
for (int i = 0; i < num_nonzeros; ++i) {
triplets.emplace_back(cols[i], rows[i], 1);
@@ -114,7 +109,7 @@
void OrderingForSparseNormalCholeskyUsingSuiteSparse(
const LinearSolverOrderingType linear_solver_ordering_type,
const TripletSparseMatrix& tsm_block_jacobian_transpose,
- const vector<ParameterBlock*>& parameter_blocks,
+ const std::vector<ParameterBlock*>& parameter_blocks,
const ParameterBlockOrdering& parameter_block_ordering,
int* ordering) {
#ifdef CERES_NO_SUITESPARSE
@@ -132,7 +127,7 @@
ss.Ordering(block_jacobian_transpose, OrderingType::AMD, ordering);
} else {
// The user supplied an ordering, so use CAMD.
- vector<int> constraints;
+ std::vector<int> constraints;
constraints.reserve(parameter_blocks.size());
for (auto* parameter_block : parameter_blocks) {
constraints.push_back(parameter_block_ordering.GroupId(
@@ -210,7 +205,7 @@
bool ApplyOrdering(const ProblemImpl::ParameterMap& parameter_map,
const ParameterBlockOrdering& ordering,
Program* program,
- string* error) {
+ std::string* error) {
const int num_parameter_blocks = program->NumParameterBlocks();
if (ordering.NumElements() != num_parameter_blocks) {
*error = StringPrintf(
@@ -222,13 +217,13 @@
return false;
}
- vector<ParameterBlock*>* parameter_blocks =
+ std::vector<ParameterBlock*>* parameter_blocks =
program->mutable_parameter_blocks();
parameter_blocks->clear();
- const map<int, set<double*>>& groups = ordering.group_to_elements();
+ const std::map<int, std::set<double*>>& groups = ordering.group_to_elements();
for (const auto& p : groups) {
- const set<double*>& group = p.second;
+ const std::set<double*>& group = p.second;
for (double* parameter_block_ptr : group) {
auto it = parameter_map.find(parameter_block_ptr);
if (it == parameter_map.end()) {
@@ -248,16 +243,16 @@
bool LexicographicallyOrderResidualBlocks(
const int size_of_first_elimination_group,
Program* program,
- string* error) {
+ std::string* error) {
CHECK_GE(size_of_first_elimination_group, 1)
<< "Congratulations, you found a Ceres bug! Please report this error "
<< "to the developers.";
// Create a histogram of the number of residuals for each E block. There is an
// extra bucket at the end to catch all non-eliminated F blocks.
- vector<int> residual_blocks_per_e_block(size_of_first_elimination_group + 1);
- vector<ResidualBlock*>* residual_blocks = program->mutable_residual_blocks();
- vector<int> min_position_per_residual(residual_blocks->size());
+ std::vector<int> residual_blocks_per_e_block(size_of_first_elimination_group + 1);
+ std::vector<ResidualBlock*>* residual_blocks = program->mutable_residual_blocks();
+ std::vector<int> min_position_per_residual(residual_blocks->size());
for (int i = 0; i < residual_blocks->size(); ++i) {
ResidualBlock* residual_block = (*residual_blocks)[i];
int position =
@@ -270,7 +265,7 @@
// Run a cumulative sum on the histogram, to obtain offsets to the start of
// each histogram bucket (where each bucket is for the residuals for that
// E-block).
- vector<int> offsets(size_of_first_elimination_group + 1);
+ std::vector<int> offsets(size_of_first_elimination_group + 1);
std::partial_sum(residual_blocks_per_e_block.begin(),
residual_blocks_per_e_block.end(),
offsets.begin());
@@ -291,7 +286,7 @@
// from each offset as a residual block is placed in the bucket. When the
// filling is finished, the offset pointers should have shifted down one
// entry (this is verified below).
- vector<ResidualBlock*> reordered_residual_blocks(
+ std::vector<ResidualBlock*> reordered_residual_blocks(
(*residual_blocks).size(), static_cast<ResidualBlock*>(nullptr));
for (int i = 0; i < residual_blocks->size(); ++i) {
int bucket = min_position_per_residual[i];
@@ -332,8 +327,8 @@
const ParameterBlockOrdering& parameter_block_ordering, Program* program) {
#ifndef CERES_NO_SUITESPARSE
SuiteSparse ss;
- vector<int> constraints;
- vector<ParameterBlock*>& parameter_blocks =
+ std::vector<int> constraints;
+ std::vector<ParameterBlock*>& parameter_blocks =
*(program->mutable_parameter_blocks());
for (auto* parameter_block : parameter_blocks) {
@@ -353,12 +348,12 @@
cholmod_sparse* block_jacobian_transpose =
ss.CreateSparseMatrix(tsm_block_jacobian_transpose.get());
- vector<int> ordering(parameter_blocks.size(), 0);
+ std::vector<int> ordering(parameter_blocks.size(), 0);
ss.ConstrainedApproximateMinimumDegreeOrdering(
block_jacobian_transpose, constraints.data(), ordering.data());
ss.Free(block_jacobian_transpose);
- const vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
+ const std::vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
for (int i = 0; i < program->NumParameterBlocks(); ++i) {
parameter_blocks[i] = parameter_blocks_copy[ordering[i]];
}
@@ -408,8 +403,8 @@
#endif
}
- const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
- vector<ParameterBlock*> ordering(num_cols);
+ const std::vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+ std::vector<ParameterBlock*> ordering(num_cols);
// The ordering of the first size_of_first_elimination_group does
// not matter, so we preserve the existing ordering.
@@ -435,7 +430,7 @@
const ProblemImpl::ParameterMap& parameter_map,
ParameterBlockOrdering* parameter_block_ordering,
Program* program,
- string* error) {
+ std::string* error) {
if (parameter_block_ordering->NumElements() !=
program->NumParameterBlocks()) {
*error = StringPrintf(
@@ -453,7 +448,7 @@
// parameter block ordering as it sees fit. For Schur type solvers,
// this means that the user wishes for Ceres to identify the
// e_blocks, which we do by computing a maximal independent set.
- vector<ParameterBlock*> schur_ordering;
+ std::vector<ParameterBlock*> schur_ordering;
const int size_of_first_elimination_group =
ComputeStableSchurOrdering(*program, &schur_ordering);
@@ -476,7 +471,7 @@
// group.
// Verify that the first elimination group is an independent set.
- const set<double*>& first_elimination_group =
+ const std::set<double*>& first_elimination_group =
parameter_block_ordering->group_to_elements().begin()->second;
if (!program->IsParameterBlockSetIndependent(first_elimination_group)) {
*error = StringPrintf(
@@ -527,7 +522,7 @@
const ParameterBlockOrdering& parameter_block_ordering,
int start_row_block,
Program* program,
- string* error) {
+ std::string* error) {
if (parameter_block_ordering.NumElements() != program->NumParameterBlocks()) {
*error = StringPrintf(
"The program has %d parameter blocks, but the parameter block "
@@ -541,8 +536,8 @@
std::unique_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
program->CreateJacobianBlockSparsityTranspose(start_row_block));
- vector<int> ordering(program->NumParameterBlocks(), 0);
- vector<ParameterBlock*>& parameter_blocks =
+ std::vector<int> ordering(program->NumParameterBlocks(), 0);
+ std::vector<ParameterBlock*>& parameter_blocks =
*(program->mutable_parameter_blocks());
if (sparse_linear_algebra_library_type == SUITE_SPARSE) {
@@ -569,7 +564,7 @@
}
// Apply ordering.
- const vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
+ const std::vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
for (int i = 0; i < program->NumParameterBlocks(); ++i) {
parameter_blocks[i] = parameter_blocks_copy[ordering[i]];
}
diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index d6a6577..3510171 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -44,8 +44,6 @@
namespace ceres {
namespace internal {
-using std::vector;
-
// Templated base class for the CostFunction signatures.
template <int kNumResiduals, int... Ns>
class MockCostFunctionBase : public SizedCostFunction<kNumResiduals, Ns...> {
@@ -88,10 +86,10 @@
options.linear_solver_type = DENSE_SCHUR;
options.linear_solver_ordering = linear_solver_ordering;
- const vector<ResidualBlock*>& residual_blocks =
+ const std::vector<ResidualBlock*>& residual_blocks =
problem.program().residual_blocks();
- vector<ResidualBlock*> expected_residual_blocks;
+ std::vector<ResidualBlock*> expected_residual_blocks;
// This is a bit fragile, but it serves the purpose. We know the
// bucketing algorithm that the reordering function uses, so we
@@ -156,7 +154,7 @@
EXPECT_TRUE(ApplyOrdering(
problem.parameter_map(), linear_solver_ordering, program, &message));
- const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+ const std::vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
EXPECT_EQ(parameter_blocks.size(), 3);
EXPECT_EQ(parameter_blocks[0]->user_state(), &x);
@@ -180,7 +178,7 @@
void ComputeAndValidateOrdering(
const ParameterBlockOrdering& linear_solver_ordering) {
Program* program = problem_.mutable_program();
- vector<ParameterBlock*> unordered_parameter_blocks =
+ std::vector<ParameterBlock*> unordered_parameter_blocks =
program->parameter_blocks();
std::string error;
@@ -190,7 +188,7 @@
0, /* use all rows */
program,
&error));
- const vector<ParameterBlock*>& ordered_parameter_blocks =
+ const std::vector<ParameterBlock*>& ordered_parameter_blocks =
program->parameter_blocks();
EXPECT_EQ(ordered_parameter_blocks.size(),
unordered_parameter_blocks.size());
diff --git a/internal/ceres/residual_block_test.cc b/internal/ceres/residual_block_test.cc
index 8f99b23..0a84248 100644
--- a/internal/ceres/residual_block_test.cc
+++ b/internal/ceres/residual_block_test.cc
@@ -40,8 +40,6 @@
namespace ceres::internal {
-using std::vector;
-
// Trivial cost function that accepts three arguments.
class TernaryCostFunction : public CostFunction {
public:
@@ -87,7 +85,7 @@
double values_z[4];
ParameterBlock z(values_z, 4, -1);
- vector<ParameterBlock*> parameters;
+ std::vector<ParameterBlock*> parameters;
parameters.push_back(&x);
parameters.push_back(&y);
parameters.push_back(&z);
@@ -212,19 +210,19 @@
double values_z[4];
ParameterBlock z(values_z, 4, -1);
- vector<ParameterBlock*> parameters;
+ std::vector<ParameterBlock*> parameters;
parameters.push_back(&x);
parameters.push_back(&y);
parameters.push_back(&z);
// Make x have the first component fixed.
- vector<int> x_fixed;
+ std::vector<int> x_fixed;
x_fixed.push_back(0);
SubsetManifold x_manifold(2, x_fixed);
x.SetManifold(&x_manifold);
// Make z have the last and last component fixed.
- vector<int> z_fixed;
+ std::vector<int> z_fixed;
z_fixed.push_back(2);
SubsetManifold z_manifold(4, z_fixed);
z.SetManifold(&z_manifold);
diff --git a/internal/ceres/residual_block_utils.cc b/internal/ceres/residual_block_utils.cc
index 7dc5d44..74eaf58 100644
--- a/internal/ceres/residual_block_utils.cc
+++ b/internal/ceres/residual_block_utils.cc
@@ -44,8 +44,6 @@
namespace ceres::internal {
-using std::string;
-
void InvalidateEvaluation(const ResidualBlock& block,
double* cost,
double* residuals,
@@ -63,7 +61,7 @@
}
}
-string EvaluationToString(const ResidualBlock& block,
+std::string EvaluationToString(const ResidualBlock& block,
double const* const* parameters,
double* cost,
double* residuals,
@@ -73,7 +71,7 @@
const int num_parameter_blocks = block.NumParameterBlocks();
const int num_residuals = block.NumResiduals();
- string result = "";
+ std::string result = "";
// clang-format off
StringAppendF(&result,
@@ -88,7 +86,7 @@
"to Inf or NaN is also an error. \n\n"; // NOLINT
// clang-format on
- string space = "Residuals: ";
+ std::string space = "Residuals: ";
result += space;
AppendArrayToString(num_residuals, residuals, &result);
StringAppendF(&result, "\n\n");
diff --git a/internal/ceres/rotation_test.cc b/internal/ceres/rotation_test.cc
index 577f8ed..b59c487 100644
--- a/internal/ceres/rotation_test.cc
+++ b/internal/ceres/rotation_test.cc
@@ -50,17 +50,11 @@
namespace ceres {
namespace internal {
-using std::max;
-using std::min;
-using std::numeric_limits;
-using std::string;
-using std::swap;
-
inline constexpr double kPi = constants::pi_v<double>;
const double kHalfSqrt2 = 0.707106781186547524401;
// A tolerance value for floating-point comparisons.
-static double const kTolerance = numeric_limits<double>::epsilon() * 10;
+static double const kTolerance = std::numeric_limits<double>::epsilon() * 10;
// Looser tolerance used for numerically unstable conversions.
static double const kLooseTolerance = 1e-9;
@@ -136,12 +130,12 @@
Eigen::Vector3d e(expected[0], expected[1], expected[2]);
const double e_norm = e.norm();
- double delta_norm = numeric_limits<double>::max();
+ double delta_norm = std::numeric_limits<double>::max();
if (e_norm > 0) {
// Deal with the sign ambiguity near PI. Since the sign can flip,
// we take the smaller of the two differences.
if (fabs(e_norm - kPi) < kLooseTolerance) {
- delta_norm = min((a - e).norm(), (a + e).norm()) / e_norm;
+ delta_norm = std::min((a - e).norm(), (a + e).norm()) / e_norm;
} else {
delta_norm = (a - e).norm() / e_norm;
}
@@ -229,7 +223,7 @@
// Test that approximate conversion works for very small angles.
TEST(Rotation, TinyAngleAxisToQuaternion) {
// Very small value that could potentially cause underflow.
- double theta = pow(numeric_limits<double>::min(), 0.75);
+ double theta = pow(std::numeric_limits<double>::min(), 0.75);
double axis_angle[3] = {theta, 0, 0};
double quaternion[4];
double expected[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
@@ -290,7 +284,7 @@
// Test that approximate conversion works for very small angles.
TEST(Rotation, TinyQuaternionToAngleAxis) {
// Very small value that could potentially cause underflow.
- double theta = pow(numeric_limits<double>::min(), 0.75);
+ double theta = pow(std::numeric_limits<double>::min(), 0.75);
double quaternion[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
double axis_angle[3];
double expected[3] = {theta, 0, 0};
@@ -496,7 +490,7 @@
LOG(INFO) << "Rotation:";
LOG(INFO) << "EXPECTED | ACTUAL";
for (int i = 0; i < 3; ++i) {
- string line;
+ std::string line;
for (int j = 0; j < 3; ++j) {
StringAppendF(&line, "%g ", kMatrix[i][j]);
}
@@ -600,16 +594,16 @@
for (int i = 0; i < 3; ++i) {
EXPECT_NEAR(
- round_trip[i], axis_angle[i], numeric_limits<double>::epsilon());
+ round_trip[i], axis_angle[i], std::numeric_limits<double>::epsilon());
}
}
}
// Transposes a 3x3 matrix.
static void Transpose3x3(double m[9]) {
- swap(m[1], m[3]);
- swap(m[2], m[6]);
- swap(m[5], m[7]);
+ std::swap(m[1], m[3]);
+ std::swap(m[2], m[6]);
+ std::swap(m[5], m[7]);
}
// Convert Euler angles from radians to degrees.
@@ -976,11 +970,11 @@
// Log-10 of a value well below machine precision.
static const int kSmallTinyCutoff =
- static_cast<int>(2 * log(numeric_limits<double>::epsilon()) / log(10.0));
+ static_cast<int>(2 * log(std::numeric_limits<double>::epsilon()) / log(10.0));
// Log-10 of a value just below values representable by double.
static const int kTinyZeroLimit =
- static_cast<int>(1 + log(numeric_limits<double>::min()) / log(10.0));
+ static_cast<int>(1 + log(std::numeric_limits<double>::min()) / log(10.0));
// Test that exact conversion works for small angles when jets are used.
TEST(Rotation, SmallAngleAxisToQuaternionForJets) {
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 12dfc59..5ba477e 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -61,17 +61,14 @@
using internal::StringAppendF;
using internal::StringPrintf;
-using std::map;
-using std::string;
-using std::vector;
#define OPTION_OP(x, y, OP) \
if (!(options.x OP y)) { \
std::stringstream ss; \
ss << "Invalid configuration. "; \
- ss << string("Solver::Options::" #x " = ") << options.x << ". "; \
+ ss << std::string("Solver::Options::" #x " = ") << options.x << ". "; \
ss << "Violated constraint: "; \
- ss << string("Solver::Options::" #x " " #OP " " #y); \
+ ss << std::string("Solver::Options::" #x " " #OP " " #y); \
*error = ss.str(); \
return false; \
}
@@ -80,11 +77,11 @@
if (!(options.x OP options.y)) { \
std::stringstream ss; \
ss << "Invalid configuration. "; \
- ss << string("Solver::Options::" #x " = ") << options.x << ". "; \
- ss << string("Solver::Options::" #y " = ") << options.y << ". "; \
+ ss << std::string("Solver::Options::" #x " = ") << options.x << ". "; \
+ ss << std::string("Solver::Options::" #y " = ") << options.y << ". "; \
ss << "Violated constraint: "; \
- ss << string("Solver::Options::" #x); \
- ss << string(#OP " Solver::Options::" #y "."); \
+ ss << std::string("Solver::Options::" #x); \
+ ss << std::string(#OP " Solver::Options::" #y "."); \
*error = ss.str(); \
return false; \
}
@@ -96,7 +93,7 @@
#define OPTION_LE_OPTION(x, y) OPTION_OP_OPTION(x, y, <=)
#define OPTION_LT_OPTION(x, y) OPTION_OP_OPTION(x, y, <)
-bool CommonOptionsAreValid(const Solver::Options& options, string* error) {
+bool CommonOptionsAreValid(const Solver::Options& options, std::string* error) {
OPTION_GE(max_num_iterations, 0);
OPTION_GE(max_solver_time_in_seconds, 0.0);
OPTION_GE(function_tolerance, 0.0);
@@ -123,7 +120,7 @@
}
bool OptionsAreValidForDenseSolver(const Solver::Options& options,
- string* error) {
+ std::string* error) {
const char* library_name = DenseLinearAlgebraLibraryTypeToString(
options.dense_linear_algebra_library_type);
const char* solver_name =
@@ -141,7 +138,7 @@
}
bool OptionsAreValidForSparseCholeskyBasedSolver(const Solver::Options& options,
- string* error) {
+ std::string* error) {
const char* library_name = SparseLinearAlgebraLibraryTypeToString(
options.sparse_linear_algebra_library_type);
// Sparse factorization based solvers and some preconditioners require a
@@ -199,12 +196,12 @@
}
bool OptionsAreValidForDenseNormalCholesky(const Solver::Options& options,
- string* error) {
+ std::string* error) {
CHECK_EQ(options.linear_solver_type, DENSE_NORMAL_CHOLESKY);
return OptionsAreValidForDenseSolver(options, error);
}
-bool OptionsAreValidForDenseQr(const Solver::Options& options, string* error) {
+bool OptionsAreValidForDenseQr(const Solver::Options& options, std::string* error) {
CHECK_EQ(options.linear_solver_type, DENSE_QR);
if (!OptionsAreValidForDenseSolver(options, error)) {
@@ -220,13 +217,13 @@
}
bool OptionsAreValidForSparseNormalCholesky(const Solver::Options& options,
- string* error) {
+ std::string* error) {
CHECK_EQ(options.linear_solver_type, SPARSE_NORMAL_CHOLESKY);
return OptionsAreValidForSparseCholeskyBasedSolver(options, error);
}
bool OptionsAreValidForDenseSchur(const Solver::Options& options,
- string* error) {
+ std::string* error) {
CHECK_EQ(options.linear_solver_type, DENSE_SCHUR);
if (options.dynamic_sparsity) {
@@ -242,7 +239,7 @@
}
bool OptionsAreValidForSparseSchur(const Solver::Options& options,
- string* error) {
+ std::string* error) {
CHECK_EQ(options.linear_solver_type, SPARSE_SCHUR);
if (options.dynamic_sparsity) {
*error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
@@ -252,7 +249,7 @@
}
bool OptionsAreValidForIterativeSchur(const Solver::Options& options,
- string* error) {
+ std::string* error) {
CHECK_EQ(options.linear_solver_type, ITERATIVE_SCHUR);
if (options.dynamic_sparsity) {
*error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
@@ -305,7 +302,7 @@
return true;
}
-bool OptionsAreValidForCgnr(const Solver::Options& options, string* error) {
+bool OptionsAreValidForCgnr(const Solver::Options& options, std::string* error) {
CHECK_EQ(options.linear_solver_type, CGNR);
if (options.preconditioner_type != IDENTITY &&
@@ -361,7 +358,7 @@
}
bool OptionsAreValidForLinearSolver(const Solver::Options& options,
- string* error) {
+ std::string* error) {
switch (options.linear_solver_type) {
case DENSE_NORMAL_CHOLESKY:
return OptionsAreValidForDenseNormalCholesky(options, error);
@@ -386,7 +383,7 @@
return false;
}
-bool TrustRegionOptionsAreValid(const Solver::Options& options, string* error) {
+bool TrustRegionOptionsAreValid(const Solver::Options& options, std::string* error) {
OPTION_GT(initial_trust_region_radius, 0.0);
OPTION_GT(min_trust_region_radius, 0.0);
OPTION_GT(max_trust_region_radius, 0.0);
@@ -434,7 +431,7 @@
return true;
}
-bool LineSearchOptionsAreValid(const Solver::Options& options, string* error) {
+bool LineSearchOptionsAreValid(const Solver::Options& options, std::string* error) {
OPTION_GT(max_lbfgs_rank, 0);
OPTION_GT(min_line_search_step_size, 0.0);
OPTION_GT(max_line_search_step_contraction, 0.0);
@@ -454,9 +451,9 @@
options.line_search_direction_type == ceres::LBFGS) &&
options.line_search_type != ceres::WOLFE) {
*error =
- string("Invalid configuration: Solver::Options::line_search_type = ") +
- string(LineSearchTypeToString(options.line_search_type)) +
- string(
+ std::string("Invalid configuration: Solver::Options::line_search_type = ") +
+ std::string(LineSearchTypeToString(options.line_search_type)) +
+ std::string(
". When using (L)BFGS, "
"Solver::Options::line_search_type must be set to WOLFE.");
return false;
@@ -490,7 +487,7 @@
#undef OPTION_LE_OPTION
#undef OPTION_LT_OPTION
-void StringifyOrdering(const vector<int>& ordering, string* report) {
+void StringifyOrdering(const std::vector<int>& ordering, std::string* report) {
if (ordering.empty()) {
internal::StringAppendF(report, "AUTOMATIC");
return;
@@ -590,7 +587,7 @@
// not contain any parameter blocks. Thus, only extract the
// evaluator statistics if one exists.
if (pp.evaluator != nullptr) {
- const map<string, CallStatistics>& evaluator_statistics =
+ const std::map<std::string, CallStatistics>& evaluator_statistics =
pp.evaluator->Statistics();
{
const CallStatistics& call_stats = FindWithDefault(
@@ -612,7 +609,7 @@
// solver from which we can extract run time statistics. In
// particular the line search solver does not use a linear solver.
if (pp.linear_solver != nullptr) {
- const map<string, CallStatistics>& linear_solver_statistics =
+ const std::map<std::string, CallStatistics>& linear_solver_statistics =
pp.linear_solver->Statistics();
const CallStatistics& call_stats = FindWithDefault(
linear_solver_statistics, "LinearSolver::Solve", CallStatistics());
@@ -684,7 +681,7 @@
} // namespace
-bool Solver::Options::IsValid(string* error) const {
+bool Solver::Options::IsValid(std::string* error) const {
if (!CommonOptionsAreValid(*this, error)) {
return false;
}
@@ -833,7 +830,7 @@
solver.Solve(options, problem, summary);
}
-string Solver::Summary::BriefReport() const {
+std::string Solver::Summary::BriefReport() const {
return StringPrintf(
"Ceres Solver Report: "
"Iterations: %d, "
@@ -846,12 +843,12 @@
TerminationTypeToString(termination_type));
}
-string Solver::Summary::FullReport() const {
+std::string Solver::Summary::FullReport() const {
using internal::VersionString;
// NOTE operator+ is not usable for concatenating a string and a string_view.
- string report =
- string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
+ std::string report =
+ std::string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
StringAppendF(&report, "%45s %21s\n", "Original", "Reduced");
StringAppendF(&report,
@@ -967,9 +964,9 @@
num_threads_given,
num_threads_used);
- string given;
+ std::string given;
StringifyOrdering(linear_solver_ordering_given, &given);
- string used;
+ std::string used;
StringifyOrdering(linear_solver_ordering_used, &used);
StringAppendF(&report,
"Linear solver ordering %22s %24s\n",
@@ -990,9 +987,9 @@
}
if (inner_iterations_used) {
- string given;
+ std::string given;
StringifyOrdering(inner_iteration_ordering_given, &given);
- string used;
+ std::string used;
StringifyOrdering(inner_iteration_ordering_used, &used);
StringAppendF(&report,
"Inner iteration ordering %20s %24s\n",
@@ -1003,7 +1000,7 @@
// LINE_SEARCH HEADER
StringAppendF(&report, "\nMinimizer %19s\n", "LINE_SEARCH");
- string line_search_direction_string;
+ std::string line_search_direction_string;
if (line_search_direction_type == LBFGS) {
line_search_direction_string = StringPrintf("LBFGS (%d)", max_lbfgs_rank);
} else if (line_search_direction_type == NONLINEAR_CONJUGATE_GRADIENT) {
@@ -1018,7 +1015,7 @@
"Line search direction %19s\n",
line_search_direction_string.c_str());
- const string line_search_type_string = StringPrintf(
+ const std::string line_search_type_string = StringPrintf(
"%s %s",
LineSearchInterpolationTypeToString(line_search_interpolation_type),
LineSearchTypeToString(line_search_type));
diff --git a/internal/ceres/solver_test.cc b/internal/ceres/solver_test.cc
index 929e293..a8df340 100644
--- a/internal/ceres/solver_test.cc
+++ b/internal/ceres/solver_test.cc
@@ -46,19 +46,17 @@
namespace ceres::internal {
-using std::string;
-
TEST(SolverOptions, DefaultTrustRegionOptionsAreValid) {
Solver::Options options;
options.minimizer_type = TRUST_REGION;
- string error;
+ std::string error;
EXPECT_TRUE(options.IsValid(&error)) << error;
}
TEST(SolverOptions, DefaultLineSearchOptionsAreValid) {
Solver::Options options;
options.minimizer_type = LINE_SEARCH;
- string error;
+ std::string error;
EXPECT_TRUE(options.IsValid(&error)) << error;
}
diff --git a/internal/ceres/stringprintf.cc b/internal/ceres/stringprintf.cc
index 1b6b6ff..1bf4fc2 100644
--- a/internal/ceres/stringprintf.cc
+++ b/internal/ceres/stringprintf.cc
@@ -40,9 +40,7 @@
namespace ceres::internal {
-using std::string;
-
-void StringAppendV(string* dst, const char* format, va_list ap) {
+void StringAppendV(std::string* dst, const char* format, va_list ap) {
// First try with a small fixed size buffer
char space[1024];
@@ -92,16 +90,16 @@
delete[] buf;
}
-string StringPrintf(const char* format, ...) {
+std::string StringPrintf(const char* format, ...) {
va_list ap;
va_start(ap, format);
- string result;
+ std::string result;
StringAppendV(&result, format, ap);
va_end(ap);
return result;
}
-const string& SStringPrintf(string* dst, const char* format, ...) {
+const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
va_list ap;
va_start(ap, format);
dst->clear();
@@ -110,7 +108,7 @@
return *dst;
}
-void StringAppendF(string* dst, const char* format, ...) {
+void StringAppendF(std::string* dst, const char* format, ...) {
va_list ap;
va_start(ap, format);
StringAppendV(dst, format, ap);
diff --git a/internal/ceres/trust_region_preprocessor.cc b/internal/ceres/trust_region_preprocessor.cc
index 67f928e..31ff288 100644
--- a/internal/ceres/trust_region_preprocessor.cc
+++ b/internal/ceres/trust_region_preprocessor.cc
@@ -50,15 +50,13 @@
namespace ceres::internal {
-using std::vector;
-
namespace {
std::shared_ptr<ParameterBlockOrdering> CreateDefaultLinearSolverOrdering(
const Program& program) {
std::shared_ptr<ParameterBlockOrdering> ordering =
std::make_shared<ParameterBlockOrdering>();
- const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+ const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
for (auto* parameter_block : parameter_blocks) {
ordering->AddElementToGroup(
const_cast<double*>(parameter_block->user_state()), 0);
diff --git a/internal/ceres/types.cc b/internal/ceres/types.cc
index 3de91ed..be61476 100644
--- a/internal/ceres/types.cc
+++ b/internal/ceres/types.cc
@@ -39,14 +39,12 @@
namespace ceres {
-using std::string;
-
// clang-format off
#define CASESTR(x) case x: return #x
#define STRENUM(x) if (value == #x) { *type = x; return true; }
// clang-format on
-static void UpperCase(string* input) {
+static void UpperCase(std::string* input) {
std::transform(input->begin(), input->end(), input->begin(), ::toupper);
}
@@ -64,7 +62,7 @@
}
}
-bool StringToLinearSolverType(string value, LinearSolverType* type) {
+bool StringToLinearSolverType(std::string value, LinearSolverType* type) {
UpperCase(&value);
STRENUM(DENSE_NORMAL_CHOLESKY);
STRENUM(DENSE_QR);
@@ -90,7 +88,7 @@
}
}
-bool StringToPreconditionerType(string value, PreconditionerType* type) {
+bool StringToPreconditionerType(std::string value, PreconditionerType* type) {
UpperCase(&value);
STRENUM(IDENTITY);
STRENUM(JACOBI);
@@ -116,7 +114,7 @@
}
bool StringToSparseLinearAlgebraLibraryType(
- string value, SparseLinearAlgebraLibraryType* type) {
+ std::string value, SparseLinearAlgebraLibraryType* type) {
UpperCase(&value);
STRENUM(SUITE_SPARSE);
STRENUM(EIGEN_SPARSE);
@@ -135,7 +133,7 @@
}
}
-bool StringToLinearSolverOrderingType(string value,
+bool StringToLinearSolverOrderingType(std::string value,
LinearSolverOrderingType* type) {
UpperCase(&value);
STRENUM(AMD);
@@ -155,7 +153,7 @@
}
bool StringToDenseLinearAlgebraLibraryType(
- string value, DenseLinearAlgebraLibraryType* type) {
+ std::string value, DenseLinearAlgebraLibraryType* type) {
UpperCase(&value);
STRENUM(EIGEN);
STRENUM(LAPACK);
@@ -172,7 +170,7 @@
}
}
-bool StringToTrustRegionStrategyType(string value,
+bool StringToTrustRegionStrategyType(std::string value,
TrustRegionStrategyType* type) {
UpperCase(&value);
STRENUM(LEVENBERG_MARQUARDT);
@@ -189,7 +187,7 @@
}
}
-bool StringToDoglegType(string value, DoglegType* type) {
+bool StringToDoglegType(std::string value, DoglegType* type) {
UpperCase(&value);
STRENUM(TRADITIONAL_DOGLEG);
STRENUM(SUBSPACE_DOGLEG);
@@ -205,7 +203,7 @@
}
}
-bool StringToMinimizerType(string value, MinimizerType* type) {
+bool StringToMinimizerType(std::string value, MinimizerType* type) {
UpperCase(&value);
STRENUM(TRUST_REGION);
STRENUM(LINE_SEARCH);
@@ -223,7 +221,7 @@
}
}
-bool StringToLineSearchDirectionType(string value,
+bool StringToLineSearchDirectionType(std::string value,
LineSearchDirectionType* type) {
UpperCase(&value);
STRENUM(STEEPEST_DESCENT);
@@ -242,7 +240,7 @@
}
}
-bool StringToLineSearchType(string value, LineSearchType* type) {
+bool StringToLineSearchType(std::string value, LineSearchType* type) {
UpperCase(&value);
STRENUM(ARMIJO);
STRENUM(WOLFE);
@@ -260,7 +258,7 @@
}
}
-bool StringToLineSearchInterpolationType(string value,
+bool StringToLineSearchInterpolationType(std::string value,
LineSearchInterpolationType* type) {
UpperCase(&value);
STRENUM(BISECTION);
@@ -281,7 +279,7 @@
}
bool StringToNonlinearConjugateGradientType(
- string value, NonlinearConjugateGradientType* type) {
+ std::string value, NonlinearConjugateGradientType* type) {
UpperCase(&value);
STRENUM(FLETCHER_REEVES);
STRENUM(POLAK_RIBIERE);
@@ -298,7 +296,7 @@
}
}
-bool StringToCovarianceAlgorithmType(string value,
+bool StringToCovarianceAlgorithmType(std::string value,
CovarianceAlgorithmType* type) {
UpperCase(&value);
STRENUM(DENSE_SVD);
@@ -316,7 +314,7 @@
}
}
-bool StringToNumericDiffMethodType(string value, NumericDiffMethodType* type) {
+bool StringToNumericDiffMethodType(std::string value, NumericDiffMethodType* type) {
UpperCase(&value);
STRENUM(CENTRAL);
STRENUM(FORWARD);
@@ -333,7 +331,7 @@
}
}
-bool StringToVisibilityClusteringType(string value,
+bool StringToVisibilityClusteringType(std::string value,
VisibilityClusteringType* type) {
UpperCase(&value);
STRENUM(CANONICAL_VIEWS);
diff --git a/internal/ceres/visibility.cc b/internal/ceres/visibility.cc
index 2dcfbe7..92d1e30 100644
--- a/internal/ceres/visibility.cc
+++ b/internal/ceres/visibility.cc
@@ -46,15 +46,9 @@
namespace ceres::internal {
-using std::make_pair;
-using std::max;
-using std::pair;
-using std::set;
-using std::vector;
-
void ComputeVisibility(const CompressedRowBlockStructure& block_structure,
const int num_eliminate_blocks,
- vector<set<int>>* visibility) {
+ std::vector<std::set<int>>* visibility) {
CHECK(visibility != nullptr);
// Clear the visibility vector and resize it to hold a
@@ -63,7 +57,7 @@
visibility->resize(block_structure.cols.size() - num_eliminate_blocks);
for (const auto& row : block_structure.rows) {
- const vector<Cell>& cells = row.cells;
+ const std::vector<Cell>& cells = row.cells;
int block_id = cells[0].block_id;
// If the first block is not an e_block, then skip this row block.
if (block_id >= num_eliminate_blocks) {
@@ -80,7 +74,7 @@
}
std::unique_ptr<WeightedGraph<int>> CreateSchurComplementGraph(
- const vector<set<int>>& visibility) {
+ const std::vector<std::set<int>>& visibility) {
const time_t start_time = time(nullptr);
// Compute the number of e_blocks/point blocks. Since the visibility
// set for each e_block/camera contains the set of e_blocks/points
@@ -88,7 +82,7 @@
int num_points = 0;
for (const auto& visible : visibility) {
if (!visible.empty()) {
- num_points = max(num_points, (*visible.rbegin()) + 1);
+ num_points = std::max(num_points, (*visible.rbegin()) + 1);
}
}
@@ -97,9 +91,9 @@
// cameras. However, to compute the sparsity structure of the Schur
// Complement efficiently, its better to have the point->camera
// mapping.
- vector<set<int>> inverse_visibility(num_points);
+ std::vector<std::set<int>> inverse_visibility(num_points);
for (int i = 0; i < visibility.size(); i++) {
- const set<int>& visibility_set = visibility[i];
+ const std::set<int>& visibility_set = visibility[i];
for (int v : visibility_set) {
inverse_visibility[v].insert(i);
}
@@ -107,7 +101,7 @@
// Map from camera pairs to number of points visible to both cameras
// in the pair.
- std::unordered_map<pair<int, int>, int, pair_hash> camera_pairs;
+ std::unordered_map<std::pair<int, int>, int, pair_hash> camera_pairs;
// Count the number of points visible to each camera/f_block pair.
for (const auto& inverse_visibility_set : inverse_visibility) {
@@ -116,7 +110,7 @@
++camera1) {
auto camera2 = camera1;
for (++camera2; camera2 != inverse_visibility_set.end(); ++camera2) {
- ++(camera_pairs[make_pair(*camera1, *camera2)]);
+ ++(camera_pairs[std::make_pair(*camera1, *camera2)]);
}
}
}
diff --git a/internal/ceres/visibility_test.cc b/internal/ceres/visibility_test.cc
index a107c2f..25d0510 100644
--- a/internal/ceres/visibility_test.cc
+++ b/internal/ceres/visibility_test.cc
@@ -42,9 +42,6 @@
namespace ceres::internal {
-using std::set;
-using std::vector;
-
class VisibilityTest : public ::testing::Test {};
TEST(VisibilityTest, SimpleMatrix) {
@@ -98,7 +95,7 @@
}
bs.cols.resize(num_cols);
- vector<set<int>> visibility;
+ std::vector<std::set<int>> visibility;
ComputeVisibility(bs, num_eliminate_blocks, &visibility);
ASSERT_EQ(visibility.size(), num_cols - num_eliminate_blocks);
for (const auto& visible : visibility) {
@@ -173,7 +170,7 @@
}
bs.cols.resize(num_cols);
- vector<set<int>> visibility;
+ std::vector<std::set<int>> visibility;
ComputeVisibility(bs, num_eliminate_blocks, &visibility);
ASSERT_EQ(visibility.size(), num_cols - num_eliminate_blocks);
for (const auto& visible : visibility) {
