fix formatting for (non-generated) internal source files
- Change formatting standard to Cpp11. Main difference is not having
the space between two closing >> for nested templates. We don't
choose c++14, because older versions of clang-format (version 9
and earlier) don't know this value yet, and it doesn't make a
difference in the formatting.
- Apply clang-format to all (non generated) internal source files.
- Manually fix some code sections (clang-format on/off) and c-strings
- Exclude some embedded external files with very different formatting
(gtest/gmock)
- Add script to format all source files
Change-Id: Ic6cea41575ad6e37c9e136dbce176b0d505dc44d
diff --git a/.clang-format b/.clang-format
index e28c3fd..21cad9e 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,4 +1,5 @@
BasedOnStyle: Google
+Standard: Cpp11
BinPackArguments: false
BinPackParameters: false
PointerAlignment: Left
diff --git a/examples/bal_problem.h b/examples/bal_problem.h
index 81e8844..e6d4ace 100644
--- a/examples/bal_problem.h
+++ b/examples/bal_problem.h
@@ -65,18 +65,20 @@
const double translation_sigma,
const double point_sigma);
- int camera_block_size() const { return use_quaternions_ ? 10 : 9; }
- int point_block_size() const { return 3; }
- int num_cameras() const { return num_cameras_; }
- int num_points() const { return num_points_; }
- int num_observations() const { return num_observations_; }
- int num_parameters() const { return num_parameters_; }
- const int* point_index() const { return point_index_; }
- const int* camera_index() const { return camera_index_; }
- const double* observations() const { return observations_; }
- const double* parameters() const { return parameters_; }
- const double* cameras() const { return parameters_; }
- double* mutable_cameras() { return parameters_; }
+ // clang-format off
+ int camera_block_size() const { return use_quaternions_ ? 10 : 9; }
+ int point_block_size() const { return 3; }
+ int num_cameras() const { return num_cameras_; }
+ int num_points() const { return num_points_; }
+ int num_observations() const { return num_observations_; }
+ int num_parameters() const { return num_parameters_; }
+ const int* point_index() const { return point_index_; }
+ const int* camera_index() const { return camera_index_; }
+ const double* observations() const { return observations_; }
+ const double* parameters() const { return parameters_; }
+ const double* cameras() const { return parameters_; }
+ double* mutable_cameras() { return parameters_; }
+ // clang-format on
double* mutable_points() {
return parameters_ + camera_block_size() * num_cameras_;
}
diff --git a/examples/fields_of_experts.h b/examples/fields_of_experts.h
index d7f1a4a..429881d 100644
--- a/examples/fields_of_experts.h
+++ b/examples/fields_of_experts.h
@@ -125,7 +125,7 @@
// The coefficients in front of each term.
std::vector<double> alpha_;
// The filters used for the dot product with image patches.
- std::vector<std::vector<double> > filters_;
+ std::vector<std::vector<double>> filters_;
};
} // namespace examples
diff --git a/examples/nist.cc b/examples/nist.cc
index 937d6bd..977b69d 100644
--- a/examples/nist.cc
+++ b/examples/nist.cc
@@ -167,7 +167,7 @@
void SplitStringUsingChar(const string& full,
const char delim,
vector<string>* result) {
- std::back_insert_iterator<vector<string> > it(*result);
+ std::back_insert_iterator<vector<string>> it(*result);
const char* p = full.data();
const char* end = p + full.size();
@@ -606,7 +606,7 @@
ceres::TinySolverCostFunctionAdapter<Eigen::Dynamic, num_parameters> cfa(
*cost_function);
typedef ceres::TinySolver<
- ceres::TinySolverCostFunctionAdapter<Eigen::Dynamic, num_parameters> >
+ ceres::TinySolverCostFunctionAdapter<Eigen::Dynamic, num_parameters>>
Solver;
Solver solver;
solver.options.max_num_iterations = FLAGS_num_iterations;
diff --git a/examples/sampled_function/sampled_function.cc b/examples/sampled_function/sampled_function.cc
index 7dec42b..e96018d 100644
--- a/examples/sampled_function/sampled_function.cc
+++ b/examples/sampled_function/sampled_function.cc
@@ -47,7 +47,7 @@
// values with automatic differentiation.
struct InterpolatedCostFunctor {
explicit InterpolatedCostFunctor(
- const CubicInterpolator<Grid1D<double> >& interpolator)
+ const CubicInterpolator<Grid1D<double>>& interpolator)
: interpolator_(interpolator) {}
template <typename T>
@@ -57,13 +57,13 @@
}
static CostFunction* Create(
- const CubicInterpolator<Grid1D<double> >& interpolator) {
+ const CubicInterpolator<Grid1D<double>>& interpolator) {
return new AutoDiffCostFunction<InterpolatedCostFunctor, 1, 1>(
new InterpolatedCostFunctor(interpolator));
}
private:
- const CubicInterpolator<Grid1D<double> >& interpolator_;
+ const CubicInterpolator<Grid1D<double>>& interpolator_;
};
int main(int argc, char** argv) {
@@ -77,7 +77,7 @@
}
Grid1D<double> array(values, 0, kNumSamples);
- CubicInterpolator<Grid1D<double> > interpolator(array);
+ CubicInterpolator<Grid1D<double>> interpolator(array);
double x = 1.0;
Problem problem;
diff --git a/examples/slam/pose_graph_2d/pose_graph_2d_error_term.h b/examples/slam/pose_graph_2d/pose_graph_2d_error_term.h
index 5d404e3..2df31f6 100644
--- a/examples/slam/pose_graph_2d/pose_graph_2d_error_term.h
+++ b/examples/slam/pose_graph_2d/pose_graph_2d_error_term.h
@@ -78,7 +78,7 @@
const Eigen::Matrix<T, 2, 1> p_a(*x_a, *y_a);
const Eigen::Matrix<T, 2, 1> p_b(*x_b, *y_b);
- Eigen::Map<Eigen::Matrix<T, 3, 1> > residuals_map(residuals_ptr);
+ Eigen::Map<Eigen::Matrix<T, 3, 1>> residuals_map(residuals_ptr);
residuals_map.template head<2>() =
RotationMatrix2D(*yaw_a).transpose() * (p_b - p_a) - p_ab_.cast<T>();
diff --git a/examples/slam/pose_graph_3d/pose_graph_3d.cc b/examples/slam/pose_graph_3d/pose_graph_3d.cc
index c54412d..2f8d6a4 100644
--- a/examples/slam/pose_graph_3d/pose_graph_3d.cc
+++ b/examples/slam/pose_graph_3d/pose_graph_3d.cc
@@ -133,14 +133,14 @@
for (std::map<int,
Pose3d,
std::less<int>,
- Eigen::aligned_allocator<std::pair<const int, Pose3d> > >::
+ Eigen::aligned_allocator<std::pair<const int, Pose3d>>>::
const_iterator poses_iter = poses.begin();
poses_iter != poses.end();
++poses_iter) {
const std::map<int,
Pose3d,
std::less<int>,
- Eigen::aligned_allocator<std::pair<const int, Pose3d> > >::
+ Eigen::aligned_allocator<std::pair<const int, Pose3d>>>::
value_type& pair = *poses_iter;
outfile << pair.first << " " << pair.second.p.transpose() << " "
<< pair.second.q.x() << " " << pair.second.q.y() << " "
diff --git a/examples/slam/pose_graph_3d/pose_graph_3d_error_term.h b/examples/slam/pose_graph_3d/pose_graph_3d_error_term.h
index c8def17..1f3e8de 100644
--- a/examples/slam/pose_graph_3d/pose_graph_3d_error_term.h
+++ b/examples/slam/pose_graph_3d/pose_graph_3d_error_term.h
@@ -79,11 +79,11 @@
const T* const p_b_ptr,
const T* const q_b_ptr,
T* residuals_ptr) const {
- Eigen::Map<const Eigen::Matrix<T, 3, 1> > p_a(p_a_ptr);
- Eigen::Map<const Eigen::Quaternion<T> > q_a(q_a_ptr);
+ Eigen::Map<const Eigen::Matrix<T, 3, 1>> p_a(p_a_ptr);
+ Eigen::Map<const Eigen::Quaternion<T>> q_a(q_a_ptr);
- Eigen::Map<const Eigen::Matrix<T, 3, 1> > p_b(p_b_ptr);
- Eigen::Map<const Eigen::Quaternion<T> > q_b(q_b_ptr);
+ Eigen::Map<const Eigen::Matrix<T, 3, 1>> p_b(p_b_ptr);
+ Eigen::Map<const Eigen::Quaternion<T>> q_b(q_b_ptr);
// Compute the relative transformation between the two frames.
Eigen::Quaternion<T> q_a_inverse = q_a.conjugate();
@@ -99,7 +99,7 @@
// Compute the residuals.
// [ position ] [ delta_p ]
// [ orientation (3x1)] = [ 2 * delta_q(0:2) ]
- Eigen::Map<Eigen::Matrix<T, 6, 1> > residuals(residuals_ptr);
+ Eigen::Map<Eigen::Matrix<T, 6, 1>> residuals(residuals_ptr);
residuals.template block<3, 1>(0, 0) =
p_ab_estimated - t_ab_measured_.p.template cast<T>();
residuals.template block<3, 1>(3, 0) = T(2.0) * delta_q.vec();
diff --git a/examples/slam/pose_graph_3d/types.h b/examples/slam/pose_graph_3d/types.h
index 25f7ba2..d3f19ed 100644
--- a/examples/slam/pose_graph_3d/types.h
+++ b/examples/slam/pose_graph_3d/types.h
@@ -64,7 +64,7 @@
typedef std::map<int,
Pose3d,
std::less<int>,
- Eigen::aligned_allocator<std::pair<const int, Pose3d> > >
+ Eigen::aligned_allocator<std::pair<const int, Pose3d>>>
MapOfPoses;
// The constraint between two vertices in the pose graph. The constraint is the
@@ -103,7 +103,7 @@
return input;
}
-typedef std::vector<Constraint3d, Eigen::aligned_allocator<Constraint3d> >
+typedef std::vector<Constraint3d, Eigen::aligned_allocator<Constraint3d>>
VectorOfConstraints;
} // namespace examples
diff --git a/internal/ceres/accelerate_sparse.cc b/internal/ceres/accelerate_sparse.cc
index eb04e71..d2b642b 100644
--- a/internal/ceres/accelerate_sparse.cc
+++ b/internal/ceres/accelerate_sparse.cc
@@ -33,18 +33,19 @@
#ifndef CERES_NO_ACCELERATE_SPARSE
-#include "ceres/accelerate_sparse.h"
-
#include <algorithm>
#include <string>
#include <vector>
+#include "ceres/accelerate_sparse.h"
#include "ceres/compressed_col_sparse_matrix_utils.h"
#include "ceres/compressed_row_sparse_matrix.h"
#include "ceres/triplet_sparse_matrix.h"
#include "glog/logging.h"
-#define CASESTR(x) case x: return #x
+#define CASESTR(x) \
+ case x: \
+ return #x
namespace ceres {
namespace internal {
@@ -68,7 +69,7 @@
// aligned to kAccelerateRequiredAlignment and returns a pointer to the
// aligned start.
void* ResizeForAccelerateAlignment(const size_t required_size,
- std::vector<uint8_t> *workspace) {
+ std::vector<uint8_t>* workspace) {
// As per the Accelerate documentation, all workspace memory passed to the
// sparse solver functions must be 16-byte aligned.
constexpr int kAccelerateRequiredAlignment = 16;
@@ -80,29 +81,28 @@
size_t size_from_aligned_start = workspace->size();
void* aligned_solve_workspace_start =
reinterpret_cast<void*>(workspace->data());
- aligned_solve_workspace_start =
- std::align(kAccelerateRequiredAlignment,
- required_size,
- aligned_solve_workspace_start,
- size_from_aligned_start);
+ aligned_solve_workspace_start = std::align(kAccelerateRequiredAlignment,
+ required_size,
+ aligned_solve_workspace_start,
+ size_from_aligned_start);
CHECK(aligned_solve_workspace_start != nullptr)
<< "required_size: " << required_size
<< ", workspace size: " << workspace->size();
return aligned_solve_workspace_start;
}
-template<typename Scalar>
+template <typename Scalar>
void AccelerateSparse<Scalar>::Solve(NumericFactorization* numeric_factor,
DenseVector* rhs_and_solution) {
// From SparseSolve() documentation in Solve.h
- const int required_size =
- numeric_factor->solveWorkspaceRequiredStatic +
- numeric_factor->solveWorkspaceRequiredPerRHS;
- SparseSolve(*numeric_factor, *rhs_and_solution,
+ const int required_size = numeric_factor->solveWorkspaceRequiredStatic +
+ numeric_factor->solveWorkspaceRequiredPerRHS;
+ SparseSolve(*numeric_factor,
+ *rhs_and_solution,
ResizeForAccelerateAlignment(required_size, &solve_workspace_));
}
-template<typename Scalar>
+template <typename Scalar>
typename AccelerateSparse<Scalar>::ASSparseMatrix
AccelerateSparse<Scalar>::CreateSparseMatrixTransposeView(
CompressedRowSparseMatrix* A) {
@@ -112,7 +112,7 @@
//
// Accelerate's columnStarts is a long*, not an int*. These types might be
// different (e.g. ARM on iOS) so always make a copy.
- column_starts_.resize(A->num_rows() +1); // +1 for final column length.
+ column_starts_.resize(A->num_rows() + 1); // +1 for final column length.
std::copy_n(A->rows(), column_starts_.size(), &column_starts_[0]);
ASSparseMatrix At;
@@ -136,29 +136,31 @@
return At;
}
-template<typename Scalar>
+template <typename Scalar>
typename AccelerateSparse<Scalar>::SymbolicFactorization
AccelerateSparse<Scalar>::AnalyzeCholesky(ASSparseMatrix* A) {
return SparseFactor(SparseFactorizationCholesky, A->structure);
}
-template<typename Scalar>
+template <typename Scalar>
typename AccelerateSparse<Scalar>::NumericFactorization
AccelerateSparse<Scalar>::Cholesky(ASSparseMatrix* A,
SymbolicFactorization* symbolic_factor) {
return SparseFactor(*symbolic_factor, *A);
}
-template<typename Scalar>
+template <typename Scalar>
void AccelerateSparse<Scalar>::Cholesky(ASSparseMatrix* A,
NumericFactorization* numeric_factor) {
// From SparseRefactor() documentation in Solve.h
- const int required_size = std::is_same<Scalar, double>::value
- ? numeric_factor->symbolicFactorization.workspaceSize_Double
- : numeric_factor->symbolicFactorization.workspaceSize_Float;
- return SparseRefactor(*A, numeric_factor,
- ResizeForAccelerateAlignment(required_size,
- &factorization_workspace_));
+ const int required_size =
+ std::is_same<Scalar, double>::value
+ ? numeric_factor->symbolicFactorization.workspaceSize_Double
+ : numeric_factor->symbolicFactorization.workspaceSize_Float;
+ return SparseRefactor(
+ *A,
+ numeric_factor,
+ ResizeForAccelerateAlignment(required_size, &factorization_workspace_));
}
// Instantiate only for the specific template types required/supported s/t the
@@ -166,34 +168,33 @@
template class AccelerateSparse<double>;
template class AccelerateSparse<float>;
-template<typename Scalar>
-std::unique_ptr<SparseCholesky>
-AppleAccelerateCholesky<Scalar>::Create(OrderingType ordering_type) {
+template <typename Scalar>
+std::unique_ptr<SparseCholesky> AppleAccelerateCholesky<Scalar>::Create(
+ OrderingType ordering_type) {
return std::unique_ptr<SparseCholesky>(
new AppleAccelerateCholesky<Scalar>(ordering_type));
}
-template<typename Scalar>
+template <typename Scalar>
AppleAccelerateCholesky<Scalar>::AppleAccelerateCholesky(
const OrderingType ordering_type)
: ordering_type_(ordering_type) {}
-template<typename Scalar>
+template <typename Scalar>
AppleAccelerateCholesky<Scalar>::~AppleAccelerateCholesky() {
FreeSymbolicFactorization();
FreeNumericFactorization();
}
-template<typename Scalar>
+template <typename Scalar>
CompressedRowSparseMatrix::StorageType
AppleAccelerateCholesky<Scalar>::StorageType() const {
return CompressedRowSparseMatrix::LOWER_TRIANGULAR;
}
-template<typename Scalar>
-LinearSolverTerminationType
-AppleAccelerateCholesky<Scalar>::Factorize(CompressedRowSparseMatrix* lhs,
- std::string* message) {
+template <typename Scalar>
+LinearSolverTerminationType AppleAccelerateCholesky<Scalar>::Factorize(
+ CompressedRowSparseMatrix* lhs, std::string* message) {
CHECK_EQ(lhs->storage_type(), StorageType());
if (lhs == NULL) {
*message = "Failure: Input lhs is NULL.";
@@ -234,11 +235,9 @@
return LINEAR_SOLVER_SUCCESS;
}
-template<typename Scalar>
-LinearSolverTerminationType
-AppleAccelerateCholesky<Scalar>::Solve(const double* rhs,
- double* solution,
- std::string* message) {
+template <typename Scalar>
+LinearSolverTerminationType AppleAccelerateCholesky<Scalar>::Solve(
+ const double* rhs, double* solution, std::string* message) {
CHECK_EQ(numeric_factor_->status, SparseStatusOK)
<< "Solve called without a call to Factorize first ("
<< SparseStatusToString(numeric_factor_->status) << ").";
@@ -262,7 +261,7 @@
return LINEAR_SOLVER_SUCCESS;
}
-template<typename Scalar>
+template <typename Scalar>
void AppleAccelerateCholesky<Scalar>::FreeSymbolicFactorization() {
if (symbolic_factor_) {
SparseCleanup(*symbolic_factor_);
@@ -270,7 +269,7 @@
}
}
-template<typename Scalar>
+template <typename Scalar>
void AppleAccelerateCholesky<Scalar>::FreeNumericFactorization() {
if (numeric_factor_) {
SparseCleanup(*numeric_factor_);
@@ -283,7 +282,7 @@
template class AppleAccelerateCholesky<double>;
template class AppleAccelerateCholesky<float>;
-}
-}
+} // namespace internal
+} // namespace ceres
#endif // CERES_NO_ACCELERATE_SPARSE
diff --git a/internal/ceres/accelerate_sparse.h b/internal/ceres/accelerate_sparse.h
index 43b4ea5..e53758d 100644
--- a/internal/ceres/accelerate_sparse.h
+++ b/internal/ceres/accelerate_sparse.h
@@ -40,9 +40,9 @@
#include <string>
#include <vector>
+#include "Accelerate.h"
#include "ceres/linear_solver.h"
#include "ceres/sparse_cholesky.h"
-#include "Accelerate.h"
namespace ceres {
namespace internal {
@@ -50,11 +50,10 @@
class CompressedRowSparseMatrix;
class TripletSparseMatrix;
-template<typename Scalar>
-struct SparseTypesTrait {
-};
+template <typename Scalar>
+struct SparseTypesTrait {};
-template<>
+template <>
struct SparseTypesTrait<double> {
typedef DenseVector_Double DenseVector;
typedef SparseMatrix_Double SparseMatrix;
@@ -62,7 +61,7 @@
typedef SparseOpaqueFactorization_Double NumericFactorization;
};
-template<>
+template <>
struct SparseTypesTrait<float> {
typedef DenseVector_Float DenseVector;
typedef SparseMatrix_Float SparseMatrix;
@@ -70,14 +69,16 @@
typedef SparseOpaqueFactorization_Float NumericFactorization;
};
-template<typename Scalar>
+template <typename Scalar>
class AccelerateSparse {
public:
using DenseVector = typename SparseTypesTrait<Scalar>::DenseVector;
// Use ASSparseMatrix to avoid collision with ceres::internal::SparseMatrix.
using ASSparseMatrix = typename SparseTypesTrait<Scalar>::SparseMatrix;
- using SymbolicFactorization = typename SparseTypesTrait<Scalar>::SymbolicFactorization;
- using NumericFactorization = typename SparseTypesTrait<Scalar>::NumericFactorization;
+ using SymbolicFactorization =
+ typename SparseTypesTrait<Scalar>::SymbolicFactorization;
+ using NumericFactorization =
+ typename SparseTypesTrait<Scalar>::NumericFactorization;
// Solves a linear system given its symbolic (reference counted within
// NumericFactorization) and numeric factorization.
@@ -109,7 +110,7 @@
// An implementation of SparseCholesky interface using Apple's Accelerate
// framework.
-template<typename Scalar>
+template <typename Scalar>
class AppleAccelerateCholesky : public SparseCholesky {
public:
// Factory
@@ -122,7 +123,7 @@
std::string* message) final;
LinearSolverTerminationType Solve(const double* rhs,
double* solution,
- std::string* message) final ;
+ std::string* message) final;
private:
AppleAccelerateCholesky(const OrderingType ordering_type);
@@ -132,15 +133,15 @@
const OrderingType ordering_type_;
AccelerateSparse<Scalar> as_;
std::unique_ptr<typename AccelerateSparse<Scalar>::SymbolicFactorization>
- symbolic_factor_;
+ symbolic_factor_;
std::unique_ptr<typename AccelerateSparse<Scalar>::NumericFactorization>
- numeric_factor_;
+ numeric_factor_;
// Copy of rhs/solution if Scalar != double (necessitating a copy).
Eigen::Matrix<Scalar, Eigen::Dynamic, 1> scalar_rhs_and_solution_;
};
-}
-}
+} // namespace internal
+} // namespace ceres
#endif // CERES_NO_ACCELERATE_SPARSE
diff --git a/internal/ceres/array_utils.cc b/internal/ceres/array_utils.cc
index 32459e6..6bffd84 100644
--- a/internal/ceres/array_utils.cc
+++ b/internal/ceres/array_utils.cc
@@ -35,6 +35,7 @@
#include <cstddef>
#include <string>
#include <vector>
+
#include "ceres/stringprintf.h"
#include "ceres/types.h"
namespace ceres {
@@ -45,7 +46,7 @@
bool IsArrayValid(const int size, const double* x) {
if (x != NULL) {
for (int i = 0; i < size; ++i) {
- if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue)) {
+ if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue)) {
return false;
}
}
@@ -59,7 +60,7 @@
}
for (int i = 0; i < size; ++i) {
- if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue)) {
+ if (!std::isfinite(x[i]) || (x[i] == kImpossibleValue)) {
return i;
}
}
@@ -92,14 +93,13 @@
void MapValuesToContiguousRange(const int size, int* array) {
std::vector<int> unique_values(array, array + size);
std::sort(unique_values.begin(), unique_values.end());
- unique_values.erase(std::unique(unique_values.begin(),
- unique_values.end()),
+ unique_values.erase(std::unique(unique_values.begin(), unique_values.end()),
unique_values.end());
for (int i = 0; i < size; ++i) {
- array[i] = std::lower_bound(unique_values.begin(),
- unique_values.end(),
- array[i]) - unique_values.begin();
+ array[i] =
+ std::lower_bound(unique_values.begin(), unique_values.end(), array[i]) -
+ unique_values.begin();
}
}
diff --git a/internal/ceres/array_utils.h b/internal/ceres/array_utils.h
index 1d55733..b068721 100644
--- a/internal/ceres/array_utils.h
+++ b/internal/ceres/array_utils.h
@@ -44,6 +44,7 @@
#define CERES_INTERNAL_ARRAY_UTILS_H_
#include <string>
+
#include "ceres/internal/port.h"
namespace ceres {
diff --git a/internal/ceres/array_utils_test.cc b/internal/ceres/array_utils_test.cc
index 77379d9..6c0ea84 100644
--- a/internal/ceres/array_utils_test.cc
+++ b/internal/ceres/array_utils_test.cc
@@ -30,9 +30,10 @@
#include "ceres/array_utils.h"
-#include <limits>
#include <cmath>
+#include <limits>
#include <vector>
+
#include "gtest/gtest.h"
namespace ceres {
diff --git a/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc b/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc
index 2533ba6..87e0067 100644
--- a/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc
+++ b/internal/ceres/autodiff_benchmarks/autodiff_benchmarks.cc
@@ -55,13 +55,14 @@
template <typename T>
bool operator()(const T* const* parameters, T* residuals) const {
- return Apply(parameters, residuals,
- std::make_index_sequence<kNumParameterBlocks>());
+ return Apply(
+ parameters, residuals, std::make_index_sequence<kNumParameterBlocks>());
}
private:
template <typename T, size_t... Indices>
- bool Apply(const T* const* parameters, T* residuals,
+ bool Apply(const T* const* parameters,
+ T* residuals,
std::index_sequence<Indices...>) const {
return cost_function_(parameters[Indices]..., residuals);
}
@@ -109,7 +110,9 @@
template <>
struct CostFunctionFactory<kNotDynamic> {
- template <typename CostFunctor, int kNumResiduals, int... Ns,
+ template <typename CostFunctor,
+ int kNumResiduals,
+ int... Ns,
typename... Args>
static std::unique_ptr<ceres::CostFunction> Create(Args&&... args) {
return std::make_unique<
@@ -120,7 +123,9 @@
template <>
struct CostFunctionFactory<kDynamic> {
- template <typename CostFunctor, int kNumResiduals, int... Ns,
+ template <typename CostFunctor,
+ int kNumResiduals,
+ int... Ns,
typename... Args>
static std::unique_ptr<ceres::CostFunction> Create(Args&&... args) {
constexpr const int kNumParameterBlocks = sizeof...(Ns);
@@ -147,8 +152,8 @@
double* jacobians[] = {jacobian_values.data()};
std::unique_ptr<ceres::CostFunction> cost_function =
- CostFunctionFactory<kIsDynamic>::template Create<
- ConstantCostFunction<kParameterBlockSize>, 1, 1>();
+ CostFunctionFactory<kIsDynamic>::
+ template Create<ConstantCostFunction<kParameterBlockSize>, 1, 1>();
for (auto _ : state) {
cost_function->Evaluate(parameters, residuals.data(), jacobians);
@@ -186,13 +191,12 @@
double residuals[1];
double* jacobians[] = {jacobian1};
- std::unique_ptr<ceres::CostFunction> cost_function =
- CostFunctionFactory<kIsDynamic>::template Create<Linear1CostFunction, 1,
- 1>();
+ std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+ kIsDynamic>::template Create<Linear1CostFunction, 1, 1>();
for (auto _ : state) {
- cost_function->Evaluate(parameters, residuals,
- state.range(0) ? jacobians : nullptr);
+ cost_function->Evaluate(
+ parameters, residuals, state.range(0) ? jacobians : nullptr);
}
}
BENCHMARK_TEMPLATE(BM_Linear1AutoDiff, kNotDynamic)->Arg(0)->Arg(1);
@@ -207,13 +211,12 @@
double residuals[10];
double* jacobians[] = {jacobian1};
- std::unique_ptr<ceres::CostFunction> cost_function =
- CostFunctionFactory<kIsDynamic>::template Create<Linear10CostFunction, 10,
- 10>();
+ std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+ kIsDynamic>::template Create<Linear10CostFunction, 10, 10>();
for (auto _ : state) {
- cost_function->Evaluate(parameters, residuals,
- state.range(0) ? jacobians : nullptr);
+ cost_function->Evaluate(
+ parameters, residuals, state.range(0) ? jacobians : nullptr);
}
}
BENCHMARK_TEMPLATE(BM_Linear10AutoDiff, kNotDynamic)->Arg(0)->Arg(1);
@@ -255,8 +258,8 @@
x, y);
for (auto _ : state) {
- cost_function->Evaluate(parameters, &residuals,
- state.range(0) ? jacobians : nullptr);
+ cost_function->Evaluate(
+ parameters, &residuals, state.range(0) ? jacobians : nullptr);
}
}
BENCHMARK_TEMPLATE(BM_Rat43AutoDiff, kNotDynamic)->Arg(0)->Arg(1);
@@ -275,13 +278,12 @@
const double x = 0.2;
const double y = 0.3;
- std::unique_ptr<ceres::CostFunction> cost_function =
- CostFunctionFactory<kIsDynamic>::template Create<SnavelyReprojectionError,
- 2, 9, 3>(x, y);
+ std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+ kIsDynamic>::template Create<SnavelyReprojectionError, 2, 9, 3>(x, y);
for (auto _ : state) {
- cost_function->Evaluate(parameters, residuals,
- state.range(0) ? jacobians : nullptr);
+ cost_function->Evaluate(
+ parameters, residuals, state.range(0) ? jacobians : nullptr);
}
}
@@ -338,14 +340,16 @@
intrinsics << 128, 128, 1, -1, 0.5, 0.5;
std::unique_ptr<ceres::CostFunction> cost_function =
- CostFunctionFactory<kIsDynamic>::template Create<
- FunctorType, FunctorType::PATCH_SIZE, FunctorType::POSE_SIZE,
- FunctorType::POSE_SIZE, FunctorType::POINT_SIZE>(
+ CostFunctionFactory<kIsDynamic>::template Create<FunctorType,
+ FunctorType::PATCH_SIZE,
+ FunctorType::POSE_SIZE,
+ FunctorType::POSE_SIZE,
+ FunctorType::POINT_SIZE>(
intensities_host, bearings_host, image_target, intrinsics);
for (auto _ : state) {
- cost_function->Evaluate(parameters, residuals,
- state.range(0) ? jacobians : nullptr);
+ cost_function->Evaluate(
+ parameters, residuals, state.range(0) ? jacobians : nullptr);
}
}
@@ -376,8 +380,8 @@
q_i_j, t_i_j);
for (auto _ : state) {
- cost_function->Evaluate(parameters, residuals,
- state.range(0) ? jacobians : nullptr);
+ cost_function->Evaluate(
+ parameters, residuals, state.range(0) ? jacobians : nullptr);
}
}
@@ -396,24 +400,25 @@
auto x = Eigen::Vector3d(0.5, 0.7, -0.1).normalized();
auto y = Eigen::Vector3d(0.2, -0.2, -0.2).normalized();
- double* parameters[7] = {material, c.data(), n.data(), v.data(),
- l.data(), x.data(), y.data()};
+ double* parameters[7] = {
+ material, c.data(), n.data(), v.data(), l.data(), x.data(), y.data()};
double jacobian[(10 + 6 * 3) * 3];
double residuals[3];
+ // clang-format off
double* jacobians[7] = {
jacobian + 0, jacobian + 10 * 3, jacobian + 13 * 3,
jacobian + 16 * 3, jacobian + 19 * 3, jacobian + 22 * 3,
jacobian + 25 * 3,
};
+ // clang-format on
- std::unique_ptr<ceres::CostFunction> cost_function =
- CostFunctionFactory<kIsDynamic>::template Create<FunctorType, 3, 10, 3, 3,
- 3, 3, 3, 3>();
+ std::unique_ptr<ceres::CostFunction> cost_function = CostFunctionFactory<
+ kIsDynamic>::template Create<FunctorType, 3, 10, 3, 3, 3, 3, 3, 3>();
for (auto _ : state) {
- cost_function->Evaluate(parameters, residuals,
- state.range(0) ? jacobians : nullptr);
+ cost_function->Evaluate(
+ parameters, residuals, state.range(0) ? jacobians : nullptr);
}
}
diff --git a/internal/ceres/autodiff_benchmarks/brdf_cost_function.h b/internal/ceres/autodiff_benchmarks/brdf_cost_function.h
index eba0932..9d7c0cc 100644
--- a/internal/ceres/autodiff_benchmarks/brdf_cost_function.h
+++ b/internal/ceres/autodiff_benchmarks/brdf_cost_function.h
@@ -190,10 +190,10 @@
template <typename T>
inline T GTR2Aniso(const T& n_dot_h,
- const T& h_dot_x,
- const T& h_dot_y,
- const T& ax,
- const T& ay) const {
+ const T& h_dot_x,
+ const T& h_dot_y,
+ const T& ax,
+ const T& ay) const {
return T(1) / (T(M_PI) * ax * ay *
Square(Square(h_dot_x / ax) + Square(h_dot_y / ay) +
n_dot_h * n_dot_h));
@@ -205,10 +205,10 @@
}
template <typename Derived1, typename Derived2>
- inline typename Derived1::PlainObject
- Lerp(const Eigen::MatrixBase<Derived1>& a,
- const Eigen::MatrixBase<Derived2>& b,
- typename Derived1::Scalar alpha) const {
+ inline typename Derived1::PlainObject Lerp(
+ const Eigen::MatrixBase<Derived1>& a,
+ const Eigen::MatrixBase<Derived2>& b,
+ typename Derived1::Scalar alpha) const {
return (typename Derived1::Scalar(1) - alpha) * a + alpha * b;
}
diff --git a/internal/ceres/autodiff_cost_function_test.cc b/internal/ceres/autodiff_cost_function_test.cc
index 53461cb..cc340f6 100644
--- a/internal/ceres/autodiff_cost_function_test.cc
+++ b/internal/ceres/autodiff_cost_function_test.cc
@@ -32,30 +32,30 @@
#include <memory>
-#include "gtest/gtest.h"
-#include "ceres/cost_function.h"
#include "ceres/array_utils.h"
+#include "ceres/cost_function.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
class BinaryScalarCost {
public:
- explicit BinaryScalarCost(double a): a_(a) {}
+ explicit BinaryScalarCost(double a) : a_(a) {}
template <typename T>
- bool operator()(const T* const x, const T* const y,
- T* cost) const {
- cost[0] = x[0] * y[0] + x[1] * y[1] - T(a_);
+ bool operator()(const T* const x, const T* const y, T* cost) const {
+ cost[0] = x[0] * y[0] + x[1] * y[1] - T(a_);
return true;
}
+
private:
double a_;
};
TEST(AutodiffCostFunction, BilinearDifferentiationTest) {
- CostFunction* cost_function =
- new AutoDiffCostFunction<BinaryScalarCost, 1, 2, 2>(
- new BinaryScalarCost(1.0));
+ CostFunction* cost_function =
+ new AutoDiffCostFunction<BinaryScalarCost, 1, 2, 2>(
+ new BinaryScalarCost(1.0));
double** parameters = new double*[2];
parameters[0] = new double[2];
@@ -112,10 +112,19 @@
};
TEST(AutodiffCostFunction, ManyParameterAutodiffInstantiates) {
- CostFunction* cost_function =
- new AutoDiffCostFunction<
- TenParameterCost, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1>(
- new TenParameterCost);
+ CostFunction* cost_function =
+ new AutoDiffCostFunction<TenParameterCost,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1>(new TenParameterCost);
double** parameters = new double*[10];
double** jacobians = new double*[10];
diff --git a/internal/ceres/autodiff_local_parameterization_test.cc b/internal/ceres/autodiff_local_parameterization_test.cc
index df7723d..36fd3c9 100644
--- a/internal/ceres/autodiff_local_parameterization_test.cc
+++ b/internal/ceres/autodiff_local_parameterization_test.cc
@@ -28,8 +28,10 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
-#include <cmath>
#include "ceres/autodiff_local_parameterization.h"
+
+#include <cmath>
+
#include "ceres/local_parameterization.h"
#include "ceres/rotation.h"
#include "gtest/gtest.h"
@@ -48,8 +50,7 @@
};
TEST(AutoDiffLocalParameterizationTest, IdentityParameterization) {
- AutoDiffLocalParameterization<IdentityPlus, 3, 3>
- parameterization;
+ AutoDiffLocalParameterization<IdentityPlus, 3, 3> parameterization;
double x[3] = {1.0, 2.0, 3.0};
double delta[3] = {0.0, 1.0, 2.0};
@@ -71,9 +72,8 @@
}
struct ScaledPlus {
- explicit ScaledPlus(const double &scale_factor)
- : scale_factor_(scale_factor)
- {}
+ explicit ScaledPlus(const double& scale_factor)
+ : scale_factor_(scale_factor) {}
template <typename T>
bool operator()(const T* x, const T* delta, T* x_plus_delta) const {
@@ -89,8 +89,8 @@
TEST(AutoDiffLocalParameterizationTest, ScaledParameterization) {
const double kTolerance = 1e-14;
- AutoDiffLocalParameterization<ScaledPlus, 3, 3>
- parameterization(new ScaledPlus(1.2345));
+ AutoDiffLocalParameterization<ScaledPlus, 3, 3> parameterization(
+ new ScaledPlus(1.2345));
double x[3] = {1.0, 2.0, 3.0};
double delta[3] = {0.0, 1.0, 2.0};
@@ -112,7 +112,7 @@
}
struct QuaternionPlus {
- template<typename T>
+ template <typename T>
bool operator()(const T* x, const T* delta, T* x_plus_delta) const {
const T squared_norm_delta =
delta[0] * delta[0] + delta[1] * delta[1] + delta[2] * delta[2];
@@ -147,7 +147,6 @@
double x_plus_delta_ref[4] = {0.0, 0.0, 0.0, 0.0};
double jacobian_ref[12];
-
QuaternionParameterization ref_parameterization;
ref_parameterization.Plus(x, delta, x_plus_delta_ref);
ref_parameterization.ComputeJacobian(x, jacobian_ref);
@@ -162,20 +161,22 @@
EXPECT_NEAR(x_plus_delta[i], x_plus_delta_ref[i], kTolerance);
}
+ // clang-format off
const double x_plus_delta_norm =
sqrt(x_plus_delta[0] * x_plus_delta[0] +
x_plus_delta[1] * x_plus_delta[1] +
x_plus_delta[2] * x_plus_delta[2] +
x_plus_delta[3] * x_plus_delta[3]);
+ // clang-format on
EXPECT_NEAR(x_plus_delta_norm, 1.0, kTolerance);
for (int i = 0; i < 12; ++i) {
EXPECT_TRUE(std::isfinite(jacobian[i]));
EXPECT_NEAR(jacobian[i], jacobian_ref[i], kTolerance)
- << "Jacobian mismatch: i = " << i
- << "\n Expected \n" << ConstMatrixRef(jacobian_ref, 4, 3)
- << "\n Actual \n" << ConstMatrixRef(jacobian, 4, 3);
+ << "Jacobian mismatch: i = " << i << "\n Expected \n"
+ << ConstMatrixRef(jacobian_ref, 4, 3) << "\n Actual \n"
+ << ConstMatrixRef(jacobian, 4, 3);
}
}
@@ -185,13 +186,14 @@
QuaternionParameterizationTestHelper(x, delta);
}
-
TEST(AutoDiffLocalParameterization, QuaternionParameterizationNearZeroTest) {
double x[4] = {0.52, 0.25, 0.15, 0.45};
+ // clang-format off
double norm_x = sqrt(x[0] * x[0] +
x[1] * x[1] +
x[2] * x[2] +
x[3] * x[3]);
+ // clang-format on
for (int i = 0; i < 4; ++i) {
x[i] = x[i] / norm_x;
}
@@ -206,10 +208,12 @@
TEST(AutoDiffLocalParameterization, QuaternionParameterizationNonZeroTest) {
double x[4] = {0.52, 0.25, 0.15, 0.45};
+ // clang-format off
double norm_x = sqrt(x[0] * x[0] +
x[1] * x[1] +
x[2] * x[2] +
x[3] * x[3]);
+ // clang-format on
for (int i = 0; i < 4; ++i) {
x[i] = x[i] / norm_x;
diff --git a/internal/ceres/blas.cc b/internal/ceres/blas.cc
index 3ba63bb..f8d006e 100644
--- a/internal/ceres/blas.cc
+++ b/internal/ceres/blas.cc
@@ -29,6 +29,7 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/blas.h"
+
#include "ceres/internal/port.h"
#include "glog/logging.h"
diff --git a/internal/ceres/block_evaluate_preparer.cc b/internal/ceres/block_evaluate_preparer.cc
index 59c0d3e..7db96d9 100644
--- a/internal/ceres/block_evaluate_preparer.cc
+++ b/internal/ceres/block_evaluate_preparer.cc
@@ -31,6 +31,7 @@
#include "ceres/block_evaluate_preparer.h"
#include <vector>
+
#include "ceres/block_sparse_matrix.h"
#include "ceres/casts.h"
#include "ceres/parameter_block.h"
@@ -53,10 +54,8 @@
double** jacobians) {
// If the overall jacobian is not available, use the scratch space.
if (jacobian == NULL) {
- scratch_evaluate_preparer_.Prepare(residual_block,
- residual_block_index,
- jacobian,
- jacobians);
+ scratch_evaluate_preparer_.Prepare(
+ residual_block, residual_block_index, jacobian, jacobians);
return;
}
diff --git a/internal/ceres/block_jacobi_preconditioner.cc b/internal/ceres/block_jacobi_preconditioner.cc
index 772c7af..6f37aca 100644
--- a/internal/ceres/block_jacobi_preconditioner.cc
+++ b/internal/ceres/block_jacobi_preconditioner.cc
@@ -30,9 +30,9 @@
#include "ceres/block_jacobi_preconditioner.h"
+#include "ceres/block_random_access_diagonal_matrix.h"
#include "ceres/block_sparse_matrix.h"
#include "ceres/block_structure.h"
-#include "ceres/block_random_access_diagonal_matrix.h"
#include "ceres/casts.h"
#include "ceres/internal/eigen.h"
@@ -65,13 +65,11 @@
const int col_block_size = bs->cols[block_id].size;
int r, c, row_stride, col_stride;
- CellInfo* cell_info = m_->GetCell(block_id, block_id,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info =
+ m_->GetCell(block_id, block_id, &r, &c, &row_stride, &col_stride);
MatrixRef m(cell_info->values, row_stride, col_stride);
- ConstMatrixRef b(values + cells[j].position,
- row_block_size,
- col_block_size);
+ ConstMatrixRef b(
+ values + cells[j].position, row_block_size, col_block_size);
m.block(r, c, col_block_size, col_block_size) += b.transpose() * b;
}
}
@@ -82,9 +80,7 @@
for (int i = 0; i < bs->cols.size(); ++i) {
const int block_size = bs->cols[i].size;
int r, c, row_stride, col_stride;
- CellInfo* cell_info = m_->GetCell(i, i,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info = m_->GetCell(i, i, &r, &c, &row_stride, &col_stride);
MatrixRef m(cell_info->values, row_stride, col_stride);
m.block(r, c, block_size, block_size).diagonal() +=
ConstVectorRef(D + position, block_size).array().square().matrix();
diff --git a/internal/ceres/block_jacobi_preconditioner.h b/internal/ceres/block_jacobi_preconditioner.h
index 856b506..4ede9b9 100644
--- a/internal/ceres/block_jacobi_preconditioner.h
+++ b/internal/ceres/block_jacobi_preconditioner.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_BLOCK_JACOBI_PRECONDITIONER_H_
#include <memory>
+
#include "ceres/block_random_access_diagonal_matrix.h"
#include "ceres/preconditioner.h"
diff --git a/internal/ceres/block_jacobi_preconditioner_test.cc b/internal/ceres/block_jacobi_preconditioner_test.cc
index 4a9a871..cc582c6 100644
--- a/internal/ceres/block_jacobi_preconditioner_test.cc
+++ b/internal/ceres/block_jacobi_preconditioner_test.cc
@@ -32,16 +32,16 @@
#include <memory>
#include <vector>
-#include "ceres/block_random_access_diagonal_matrix.h"
-#include "ceres/linear_least_squares_problems.h"
-#include "ceres/block_sparse_matrix.h"
-#include "gtest/gtest.h"
+
#include "Eigen/Dense"
+#include "ceres/block_random_access_diagonal_matrix.h"
+#include "ceres/block_sparse_matrix.h"
+#include "ceres/linear_least_squares_problems.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
-
class BlockJacobiPreconditionerTest : public ::testing::Test {
protected:
void SetUpFromProblemId(int problem_id) {
@@ -56,7 +56,10 @@
A->ToDenseMatrix(&dense_a);
dense_ata = dense_a.transpose() * dense_a;
dense_ata += VectorRef(D.get(), A->num_cols())
- .array().square().matrix().asDiagonal();
+ .array()
+ .square()
+ .matrix()
+ .asDiagonal();
}
void VerifyDiagonalBlocks(const int problem_id) {
@@ -73,17 +76,14 @@
for (int i = 0; i < bs->cols.size(); ++i) {
const int block_size = bs->cols[i].size;
int r, c, row_stride, col_stride;
- CellInfo* cell_info = m->GetCell(i, i,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info = m->GetCell(i, i, &r, &c, &row_stride, &col_stride);
MatrixRef m(cell_info->values, row_stride, col_stride);
Matrix actual_block_inverse = m.block(r, c, block_size, block_size);
- Matrix expected_block = dense_ata.block(bs->cols[i].position,
- bs->cols[i].position,
- block_size,
- block_size);
+ Matrix expected_block = dense_ata.block(
+ bs->cols[i].position, bs->cols[i].position, block_size, block_size);
const double residual = (actual_block_inverse * expected_block -
- Matrix::Identity(block_size, block_size)).norm();
+ Matrix::Identity(block_size, block_size))
+ .norm();
EXPECT_NEAR(residual, 0.0, 1e-12) << "Block: " << i;
}
}
@@ -93,13 +93,9 @@
Matrix dense_ata;
};
-TEST_F(BlockJacobiPreconditionerTest, SmallProblem) {
- VerifyDiagonalBlocks(2);
-}
+TEST_F(BlockJacobiPreconditionerTest, SmallProblem) { VerifyDiagonalBlocks(2); }
-TEST_F(BlockJacobiPreconditionerTest, LargeProblem) {
- VerifyDiagonalBlocks(3);
-}
+TEST_F(BlockJacobiPreconditionerTest, LargeProblem) { VerifyDiagonalBlocks(3); }
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/block_jacobian_writer.cc b/internal/ceres/block_jacobian_writer.cc
index 6998bd6..17c157b 100644
--- a/internal/ceres/block_jacobian_writer.cc
+++ b/internal/ceres/block_jacobian_writer.cc
@@ -32,11 +32,11 @@
#include "ceres/block_evaluate_preparer.h"
#include "ceres/block_sparse_matrix.h"
+#include "ceres/internal/eigen.h"
+#include "ceres/internal/port.h"
#include "ceres/parameter_block.h"
#include "ceres/program.h"
#include "ceres/residual_block.h"
-#include "ceres/internal/eigen.h"
-#include "ceres/internal/port.h"
namespace ceres {
namespace internal {
diff --git a/internal/ceres/block_jacobian_writer.h b/internal/ceres/block_jacobian_writer.h
index c94a0d3..8054d7b 100644
--- a/internal/ceres/block_jacobian_writer.h
+++ b/internal/ceres/block_jacobian_writer.h
@@ -39,6 +39,7 @@
#define CERES_INTERNAL_BLOCK_JACOBIAN_WRITER_H_
#include <vector>
+
#include "ceres/evaluator.h"
#include "ceres/internal/port.h"
@@ -52,8 +53,7 @@
// TODO(sameeragarwal): This class needs documemtation.
class BlockJacobianWriter {
public:
- BlockJacobianWriter(const Evaluator::Options& options,
- Program* program);
+ BlockJacobianWriter(const Evaluator::Options& options, Program* program);
// JacobianWriter interface.
diff --git a/internal/ceres/block_random_access_dense_matrix.cc b/internal/ceres/block_random_access_dense_matrix.cc
index f567aa5..386f81e 100644
--- a/internal/ceres/block_random_access_dense_matrix.cc
+++ b/internal/ceres/block_random_access_dense_matrix.cc
@@ -31,6 +31,7 @@
#include "ceres/block_random_access_dense_matrix.h"
#include <vector>
+
#include "ceres/internal/eigen.h"
#include "glog/logging.h"
@@ -59,8 +60,7 @@
// Assume that the user does not hold any locks on any cell blocks
// when they are calling SetZero.
-BlockRandomAccessDenseMatrix::~BlockRandomAccessDenseMatrix() {
-}
+BlockRandomAccessDenseMatrix::~BlockRandomAccessDenseMatrix() {}
CellInfo* BlockRandomAccessDenseMatrix::GetCell(const int row_block_id,
const int col_block_id,
diff --git a/internal/ceres/block_random_access_dense_matrix.h b/internal/ceres/block_random_access_dense_matrix.h
index 8c5e252..be67f34 100644
--- a/internal/ceres/block_random_access_dense_matrix.h
+++ b/internal/ceres/block_random_access_dense_matrix.h
@@ -31,11 +31,10 @@
#ifndef CERES_INTERNAL_BLOCK_RANDOM_ACCESS_DENSE_MATRIX_H_
#define CERES_INTERNAL_BLOCK_RANDOM_ACCESS_DENSE_MATRIX_H_
-#include "ceres/block_random_access_matrix.h"
-
#include <memory>
#include <vector>
+#include "ceres/block_random_access_matrix.h"
#include "ceres/internal/port.h"
namespace ceres {
diff --git a/internal/ceres/block_random_access_dense_matrix_test.cc b/internal/ceres/block_random_access_dense_matrix_test.cc
index 8a5ba59..0736d56 100644
--- a/internal/ceres/block_random_access_dense_matrix_test.cc
+++ b/internal/ceres/block_random_access_dense_matrix_test.cc
@@ -28,10 +28,12 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
-#include <vector>
-#include "gtest/gtest.h"
#include "ceres/block_random_access_dense_matrix.h"
+
+#include <vector>
+
#include "ceres/internal/eigen.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -54,8 +56,7 @@
int col;
int row_stride;
int col_stride;
- CellInfo* cell =
- m.GetCell(i, j, &row, &col, &row_stride, &col_stride);
+ CellInfo* cell = m.GetCell(i, j, &row, &col, &row_stride, &col_stride);
EXPECT_TRUE(cell != NULL);
EXPECT_EQ(row, row_idx);
@@ -84,11 +85,10 @@
int col;
int row_stride;
int col_stride;
- CellInfo* cell = m.GetCell(
- i, j, &row, &col, &row_stride, &col_stride);
- MatrixRef(cell->values, row_stride, col_stride).block(
- row, col, blocks[i], blocks[j]) =
- (i+1) * (j+1) * Matrix::Ones(blocks[i], blocks[j]);
+ CellInfo* cell = m.GetCell(i, j, &row, &col, &row_stride, &col_stride);
+ MatrixRef(cell->values, row_stride, col_stride)
+ .block(row, col, blocks[i], blocks[j]) =
+ (i + 1) * (j + 1) * Matrix::Ones(blocks[i], blocks[j]);
}
}
diff --git a/internal/ceres/block_random_access_diagonal_matrix.cc b/internal/ceres/block_random_access_diagonal_matrix.cc
index 526d173..08f6d7f 100644
--- a/internal/ceres/block_random_access_diagonal_matrix.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix.cc
@@ -63,9 +63,8 @@
num_nonzeros += blocks_[i] * blocks_[i];
}
- VLOG(1) << "Matrix Size [" << num_cols
- << "," << num_cols
- << "] " << num_nonzeros;
+ VLOG(1) << "Matrix Size [" << num_cols << "," << num_cols << "] "
+ << num_nonzeros;
tsm_.reset(new TripletSparseMatrix(num_cols, num_cols, num_nonzeros));
tsm_->set_num_nonzeros(num_nonzeros);
@@ -116,8 +115,7 @@
// when they are calling SetZero.
void BlockRandomAccessDiagonalMatrix::SetZero() {
if (tsm_->num_nonzeros()) {
- VectorRef(tsm_->mutable_values(),
- tsm_->num_nonzeros()).setZero();
+ VectorRef(tsm_->mutable_values(), tsm_->num_nonzeros()).setZero();
}
}
@@ -126,11 +124,8 @@
for (int i = 0; i < blocks_.size(); ++i) {
const int block_size = blocks_[i];
MatrixRef block(values, block_size, block_size);
- block =
- block
- .selfadjointView<Eigen::Upper>()
- .llt()
- .solve(Matrix::Identity(block_size, block_size));
+ block = block.selfadjointView<Eigen::Upper>().llt().solve(
+ Matrix::Identity(block_size, block_size));
values += block_size * block_size;
}
}
diff --git a/internal/ceres/block_random_access_diagonal_matrix.h b/internal/ceres/block_random_access_diagonal_matrix.h
index 3bda7d1..4d3e1cc 100644
--- a/internal/ceres/block_random_access_diagonal_matrix.h
+++ b/internal/ceres/block_random_access_diagonal_matrix.h
@@ -50,7 +50,8 @@
public:
// blocks is an array of block sizes.
explicit BlockRandomAccessDiagonalMatrix(const std::vector<int>& blocks);
- BlockRandomAccessDiagonalMatrix(const BlockRandomAccessDiagonalMatrix&) = delete;
+ BlockRandomAccessDiagonalMatrix(const BlockRandomAccessDiagonalMatrix&) =
+ delete;
void operator=(const BlockRandomAccessDiagonalMatrix&) = delete;
// The destructor is not thread safe. It assumes that no one is
diff --git a/internal/ceres/block_random_access_diagonal_matrix_test.cc b/internal/ceres/block_random_access_diagonal_matrix_test.cc
index a54595c..e384dac 100644
--- a/internal/ceres/block_random_access_diagonal_matrix_test.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix_test.cc
@@ -28,15 +28,16 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/block_random_access_diagonal_matrix.h"
+
#include <limits>
#include <memory>
#include <vector>
-#include "ceres/block_random_access_diagonal_matrix.h"
+#include "Eigen/Cholesky"
#include "ceres/internal/eigen.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
-#include "Eigen/Cholesky"
namespace ceres {
namespace internal {
@@ -49,7 +50,7 @@
blocks.push_back(4);
blocks.push_back(5);
const int num_rows = 3 + 4 + 5;
- num_nonzeros_ = 3 * 3 + 4 * 4 + 5 * 5;
+ num_nonzeros_ = 3 * 3 + 4 * 4 + 5 * 5;
m_.reset(new BlockRandomAccessDiagonalMatrix(blocks));
@@ -66,9 +67,8 @@
for (int j = 0; j < blocks.size(); ++j) {
col_block_id = j;
- CellInfo* cell = m_->GetCell(row_block_id, col_block_id,
- &row, &col,
- &row_stride, &col_stride);
+ CellInfo* cell = m_->GetCell(
+ row_block_id, col_block_id, &row, &col, &row_stride, &col_stride);
// Off diagonal entries are not present.
if (i != j) {
EXPECT_TRUE(cell == NULL);
@@ -82,11 +82,11 @@
EXPECT_EQ(col_stride, blocks[col_block_id]);
// Write into the block
- MatrixRef(cell->values, row_stride, col_stride).block(
- row, col, blocks[row_block_id], blocks[col_block_id]) =
- (row_block_id + 1) * (col_block_id +1) *
- Matrix::Ones(blocks[row_block_id], blocks[col_block_id])
- + Matrix::Identity(blocks[row_block_id], blocks[row_block_id]);
+ MatrixRef(cell->values, row_stride, col_stride)
+ .block(row, col, blocks[row_block_id], blocks[col_block_id]) =
+ (row_block_id + 1) * (col_block_id + 1) *
+ Matrix::Ones(blocks[row_block_id], blocks[col_block_id]) +
+ Matrix::Identity(blocks[row_block_id], blocks[row_block_id]);
}
}
}
@@ -107,28 +107,31 @@
double kTolerance = 1e-14;
// (0,0)
- EXPECT_NEAR((dense.block(0, 0, 3, 3) -
- (Matrix::Ones(3, 3) + Matrix::Identity(3, 3))).norm(),
- 0.0,
- kTolerance);
+ EXPECT_NEAR(
+ (dense.block(0, 0, 3, 3) - (Matrix::Ones(3, 3) + Matrix::Identity(3, 3)))
+ .norm(),
+ 0.0,
+ kTolerance);
// (1,1)
EXPECT_NEAR((dense.block(3, 3, 4, 4) -
- (2 * 2 * Matrix::Ones(4, 4) + Matrix::Identity(4, 4))).norm(),
+ (2 * 2 * Matrix::Ones(4, 4) + Matrix::Identity(4, 4)))
+ .norm(),
0.0,
kTolerance);
// (1,1)
EXPECT_NEAR((dense.block(7, 7, 5, 5) -
- (3 * 3 * Matrix::Ones(5, 5) + Matrix::Identity(5, 5))).norm(),
+ (3 * 3 * Matrix::Ones(5, 5) + Matrix::Identity(5, 5)))
+ .norm(),
0.0,
kTolerance);
// There is nothing else in the matrix besides these four blocks.
- EXPECT_NEAR(dense.norm(),
- sqrt(6 * 1.0 + 3 * 4.0 +
- 12 * 16.0 + 4 * 25.0 +
- 20 * 81.0 + 5 * 100.0), kTolerance);
+ EXPECT_NEAR(
+ dense.norm(),
+ sqrt(6 * 1.0 + 3 * 4.0 + 12 * 16.0 + 4 * 25.0 + 20 * 81.0 + 5 * 100.0),
+ kTolerance);
}
TEST_F(BlockRandomAccessDiagonalMatrixTest, RightMultiply) {
@@ -139,7 +142,7 @@
Vector x = Vector::Random(dense.rows());
Vector expected_y = dense * x;
Vector actual_y = Vector::Zero(dense.rows());
- m_->RightMultiply(x.data(), actual_y.data());
+ m_->RightMultiply(x.data(), actual_y.data());
EXPECT_NEAR((expected_y - actual_y).norm(), 0, kTolerance);
}
diff --git a/internal/ceres/block_random_access_matrix.cc b/internal/ceres/block_random_access_matrix.cc
index 347d765..ea88855 100644
--- a/internal/ceres/block_random_access_matrix.cc
+++ b/internal/ceres/block_random_access_matrix.cc
@@ -33,8 +33,7 @@
namespace ceres {
namespace internal {
-BlockRandomAccessMatrix::~BlockRandomAccessMatrix() {
-}
+BlockRandomAccessMatrix::~BlockRandomAccessMatrix() {}
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/block_random_access_sparse_matrix.cc b/internal/ceres/block_random_access_sparse_matrix.cc
index 9c16454..c28b7ce 100644
--- a/internal/ceres/block_random_access_sparse_matrix.cc
+++ b/internal/ceres/block_random_access_sparse_matrix.cc
@@ -50,10 +50,8 @@
using std::vector;
BlockRandomAccessSparseMatrix::BlockRandomAccessSparseMatrix(
- const vector<int>& blocks,
- const set<pair<int, int>>& block_pairs)
- : kMaxRowBlocks(10 * 1000 * 1000),
- blocks_(blocks) {
+ const vector<int>& blocks, const set<pair<int, int>>& block_pairs)
+ : kMaxRowBlocks(10 * 1000 * 1000), blocks_(blocks) {
CHECK_LT(blocks.size(), kMaxRowBlocks);
// Build the row/column layout vector and count the number of scalar
@@ -75,9 +73,8 @@
num_nonzeros += row_block_size * col_block_size;
}
- VLOG(1) << "Matrix Size [" << num_cols
- << "," << num_cols
- << "] " << num_nonzeros;
+ VLOG(1) << "Matrix Size [" << num_cols << "," << num_cols << "] "
+ << num_nonzeros;
tsm_.reset(new TripletSparseMatrix(num_cols, num_cols, num_nonzeros));
tsm_->set_num_nonzeros(num_nonzeros);
@@ -105,11 +102,11 @@
layout_[IntPairToLong(row_block_id, col_block_id)]->values - values;
for (int r = 0; r < row_block_size; ++r) {
for (int c = 0; c < col_block_size; ++c, ++pos) {
- rows[pos] = block_positions_[row_block_id] + r;
- cols[pos] = block_positions_[col_block_id] + c;
- values[pos] = 1.0;
- DCHECK_LT(rows[pos], tsm_->num_rows());
- DCHECK_LT(cols[pos], tsm_->num_rows());
+ rows[pos] = block_positions_[row_block_id] + r;
+ cols[pos] = block_positions_[col_block_id] + c;
+ values[pos] = 1.0;
+ DCHECK_LT(rows[pos], tsm_->num_rows());
+ DCHECK_LT(cols[pos], tsm_->num_rows());
}
}
}
@@ -129,7 +126,7 @@
int* col,
int* row_stride,
int* col_stride) {
- const LayoutType::iterator it =
+ const LayoutType::iterator it =
layout_.find(IntPairToLong(row_block_id, col_block_id));
if (it == layout_.end()) {
return NULL;
@@ -147,8 +144,7 @@
// when they are calling SetZero.
void BlockRandomAccessSparseMatrix::SetZero() {
if (tsm_->num_nonzeros()) {
- VectorRef(tsm_->mutable_values(),
- tsm_->num_nonzeros()).setZero();
+ VectorRef(tsm_->mutable_values(), tsm_->num_nonzeros()).setZero();
}
}
@@ -164,7 +160,9 @@
const int col_block_pos = block_positions_[col];
MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
- cell_position_and_data.second, row_block_size, col_block_size,
+ cell_position_and_data.second,
+ row_block_size,
+ col_block_size,
x + col_block_pos,
y + row_block_pos);
@@ -174,7 +172,9 @@
// triangular multiply also.
if (row != col) {
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
- cell_position_and_data.second, row_block_size, col_block_size,
+ cell_position_and_data.second,
+ row_block_size,
+ col_block_size,
x + row_block_pos,
y + col_block_pos);
}
diff --git a/internal/ceres/block_random_access_sparse_matrix.h b/internal/ceres/block_random_access_sparse_matrix.h
index d542a3d..ca04163 100644
--- a/internal/ceres/block_random_access_sparse_matrix.h
+++ b/internal/ceres/block_random_access_sparse_matrix.h
@@ -39,10 +39,10 @@
#include <vector>
#include "ceres/block_random_access_matrix.h"
-#include "ceres/triplet_sparse_matrix.h"
#include "ceres/internal/port.h"
-#include "ceres/types.h"
#include "ceres/small_blas.h"
+#include "ceres/triplet_sparse_matrix.h"
+#include "ceres/types.h"
namespace ceres {
namespace internal {
@@ -110,7 +110,7 @@
// A mapping from <row_block_id, col_block_id> to the position in
// the values array of tsm_ where the block is stored.
- typedef std::unordered_map<long int, CellInfo* > LayoutType;
+ typedef std::unordered_map<long int, CellInfo*> LayoutType;
LayoutType layout_;
// In order traversal of contents of the matrix. This allows us to
diff --git a/internal/ceres/block_random_access_sparse_matrix_test.cc b/internal/ceres/block_random_access_sparse_matrix_test.cc
index fa0698f..557b678 100644
--- a/internal/ceres/block_random_access_sparse_matrix_test.cc
+++ b/internal/ceres/block_random_access_sparse_matrix_test.cc
@@ -28,11 +28,12 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/block_random_access_sparse_matrix.h"
+
#include <limits>
#include <memory>
#include <vector>
-#include "ceres/block_random_access_sparse_matrix.h"
#include "ceres/internal/eigen.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
@@ -77,9 +78,8 @@
int col;
int row_stride;
int col_stride;
- CellInfo* cell = m.GetCell(row_block_id, col_block_id,
- &row, &col,
- &row_stride, &col_stride);
+ CellInfo* cell = m.GetCell(
+ row_block_id, col_block_id, &row, &col, &row_stride, &col_stride);
EXPECT_TRUE(cell != NULL);
EXPECT_EQ(row, 0);
EXPECT_EQ(col, 0);
@@ -87,9 +87,9 @@
EXPECT_EQ(col_stride, blocks[col_block_id]);
// Write into the block
- MatrixRef(cell->values, row_stride, col_stride).block(
- row, col, blocks[row_block_id], blocks[col_block_id]) =
- (row_block_id + 1) * (col_block_id +1) *
+ MatrixRef(cell->values, row_stride, col_stride)
+ .block(row, col, blocks[row_block_id], blocks[col_block_id]) =
+ (row_block_id + 1) * (col_block_id + 1) *
Matrix::Ones(blocks[row_block_id], blocks[col_block_id]);
}
@@ -103,9 +103,8 @@
double kTolerance = 1e-14;
// (0, 0)
- EXPECT_NEAR((dense.block(0, 0, 3, 3) - Matrix::Ones(3, 3)).norm(),
- 0.0,
- kTolerance);
+ EXPECT_NEAR(
+ (dense.block(0, 0, 3, 3) - Matrix::Ones(3, 3)).norm(), 0.0, kTolerance);
// (1, 1)
EXPECT_NEAR((dense.block(3, 3, 4, 4) - 2 * 2 * Matrix::Ones(4, 4)).norm(),
0.0,
@@ -120,8 +119,8 @@
kTolerance);
// There is nothing else in the matrix besides these four blocks.
- EXPECT_NEAR(dense.norm(), sqrt(9. + 16. * 16. + 36. * 20. + 9. * 15.),
- kTolerance);
+ EXPECT_NEAR(
+ dense.norm(), sqrt(9. + 16. * 16. + 36. * 20. + 9. * 15.), kTolerance);
Vector x = Vector::Ones(dense.rows());
Vector actual_y = Vector::Zero(dense.rows());
@@ -131,8 +130,7 @@
m.SymmetricRightMultiply(x.data(), actual_y.data());
EXPECT_NEAR((expected_y - actual_y).norm(), 0.0, kTolerance)
<< "actual: " << actual_y.transpose() << "\n"
- << "expected: " << expected_y.transpose()
- << "matrix: \n " << dense;
+ << "expected: " << expected_y.transpose() << "matrix: \n " << dense;
}
// IntPairToLong is private, thus this fixture is needed to access and
@@ -155,14 +153,13 @@
}
void CheckLongToIntPair() {
- uint64_t max_rows = m_->kMaxRowBlocks;
+ uint64_t max_rows = m_->kMaxRowBlocks;
for (int row = max_rows - 10; row < max_rows; ++row) {
for (int col = 0; col < 10; ++col) {
int row_computed;
int col_computed;
- m_->LongToIntPair(m_->IntPairToLong(row, col),
- &row_computed,
- &col_computed);
+ m_->LongToIntPair(
+ m_->IntPairToLong(row, col), &row_computed, &col_computed);
EXPECT_EQ(row, row_computed);
EXPECT_EQ(col, col_computed);
}
diff --git a/internal/ceres/block_sparse_matrix.cc b/internal/ceres/block_sparse_matrix.cc
index 8f50f35..5efd2e1 100644
--- a/internal/ceres/block_sparse_matrix.cc
+++ b/internal/ceres/block_sparse_matrix.cc
@@ -30,9 +30,10 @@
#include "ceres/block_sparse_matrix.h"
-#include <cstddef>
#include <algorithm>
+#include <cstddef>
#include <vector>
+
#include "ceres/block_structure.h"
#include "ceres/internal/eigen.h"
#include "ceres/random.h"
@@ -77,8 +78,8 @@
CHECK_GE(num_rows_, 0);
CHECK_GE(num_cols_, 0);
CHECK_GE(num_nonzeros_, 0);
- VLOG(2) << "Allocating values array with "
- << num_nonzeros_ * sizeof(double) << " bytes."; // NOLINT
+ VLOG(2) << "Allocating values array with " << num_nonzeros_ * sizeof(double)
+ << " bytes."; // NOLINT
values_.reset(new double[num_nonzeros_]);
max_num_nonzeros_ = num_nonzeros_;
CHECK(values_ != nullptr);
@@ -88,7 +89,7 @@
std::fill(values_.get(), values_.get() + num_nonzeros_, 0.0);
}
-void BlockSparseMatrix::RightMultiply(const double* x, double* y) const {
+void BlockSparseMatrix::RightMultiply(const double* x, double* y) const {
CHECK(x != nullptr);
CHECK(y != nullptr);
@@ -101,7 +102,9 @@
int col_block_size = block_structure_->cols[col_block_id].size;
int col_block_pos = block_structure_->cols[col_block_id].position;
MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
- values_.get() + cells[j].position, row_block_size, col_block_size,
+ values_.get() + cells[j].position,
+ row_block_size,
+ col_block_size,
x + col_block_pos,
y + row_block_pos);
}
@@ -121,7 +124,9 @@
int col_block_size = block_structure_->cols[col_block_id].size;
int col_block_pos = block_structure_->cols[col_block_id].position;
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
- values_.get() + cells[j].position, row_block_size, col_block_size,
+ values_.get() + cells[j].position,
+ row_block_size,
+ col_block_size,
x + row_block_pos,
y + col_block_pos);
}
@@ -138,8 +143,8 @@
int col_block_id = cells[j].block_id;
int col_block_size = block_structure_->cols[col_block_id].size;
int col_block_pos = block_structure_->cols[col_block_id].position;
- const MatrixRef m(values_.get() + cells[j].position,
- row_block_size, col_block_size);
+ const MatrixRef m(
+ values_.get() + cells[j].position, row_block_size, col_block_size);
VectorRef(x + col_block_pos, col_block_size) += m.colwise().squaredNorm();
}
}
@@ -155,8 +160,8 @@
int col_block_id = cells[j].block_id;
int col_block_size = block_structure_->cols[col_block_id].size;
int col_block_pos = block_structure_->cols[col_block_id].position;
- MatrixRef m(values_.get() + cells[j].position,
- row_block_size, col_block_size);
+ MatrixRef m(
+ values_.get() + cells[j].position, row_block_size, col_block_size);
m *= ConstVectorRef(scale + col_block_pos, col_block_size).asDiagonal();
}
}
@@ -178,8 +183,8 @@
int col_block_size = block_structure_->cols[col_block_id].size;
int col_block_pos = block_structure_->cols[col_block_id].position;
int jac_pos = cells[j].position;
- m.block(row_block_pos, col_block_pos, row_block_size, col_block_size)
- += MatrixRef(values_.get() + jac_pos, row_block_size, col_block_size);
+ m.block(row_block_pos, col_block_pos, row_block_size, col_block_size) +=
+ MatrixRef(values_.get() + jac_pos, row_block_size, col_block_size);
}
}
}
@@ -201,7 +206,7 @@
int col_block_size = block_structure_->cols[col_block_id].size;
int col_block_pos = block_structure_->cols[col_block_id].position;
int jac_pos = cells[j].position;
- for (int r = 0; r < row_block_size; ++r) {
+ for (int r = 0; r < row_block_size; ++r) {
for (int c = 0; c < col_block_size; ++c, ++jac_pos) {
matrix->mutable_rows()[jac_pos] = row_block_pos + r;
matrix->mutable_cols()[jac_pos] = col_block_pos + c;
@@ -215,8 +220,7 @@
// Return a pointer to the block structure. We continue to hold
// ownership of the object though.
-const CompressedRowBlockStructure* BlockSparseMatrix::block_structure()
- const {
+const CompressedRowBlockStructure* BlockSparseMatrix::block_structure() const {
return block_structure_.get();
}
@@ -233,7 +237,8 @@
int jac_pos = cells[j].position;
for (int r = 0; r < row_block_size; ++r) {
for (int c = 0; c < col_block_size; ++c) {
- fprintf(file, "% 10d % 10d %17f\n",
+ fprintf(file,
+ "% 10d % 10d %17f\n",
row_block_pos + r,
col_block_pos + c,
values_[jac_pos++]);
@@ -369,7 +374,6 @@
int row_block_position = 0;
int value_position = 0;
for (int r = 0; r < options.num_row_blocks; ++r) {
-
const int delta_block_size =
Uniform(options.max_row_block_size - options.min_row_block_size);
const int row_block_size = options.min_row_block_size + delta_block_size;
diff --git a/internal/ceres/block_sparse_matrix.h b/internal/ceres/block_sparse_matrix.h
index d0c255d..fa9e4ed 100644
--- a/internal/ceres/block_sparse_matrix.h
+++ b/internal/ceres/block_sparse_matrix.h
@@ -35,9 +35,10 @@
#define CERES_INTERNAL_BLOCK_SPARSE_MATRIX_H_
#include <memory>
+
#include "ceres/block_structure.h"
-#include "ceres/sparse_matrix.h"
#include "ceres/internal/eigen.h"
+#include "ceres/sparse_matrix.h"
namespace ceres {
namespace internal {
@@ -77,11 +78,13 @@
void ToDenseMatrix(Matrix* dense_matrix) const final;
void ToTextFile(FILE* file) const final;
+ // clang-format off
int num_rows() const final { return num_rows_; }
int num_cols() const final { return num_cols_; }
int num_nonzeros() const final { return num_nonzeros_; }
const double* values() const final { return values_.get(); }
double* mutable_values() final { return values_.get(); }
+ // clang-format on
void ToTripletSparseMatrix(TripletSparseMatrix* matrix) const;
const CompressedRowBlockStructure* block_structure() const;
@@ -94,8 +97,7 @@
void DeleteRowBlocks(int delta_row_blocks);
static BlockSparseMatrix* CreateDiagonalMatrix(
- const double* diagonal,
- const std::vector<Block>& column_blocks);
+ const double* diagonal, const std::vector<Block>& column_blocks);
struct RandomMatrixOptions {
int num_row_blocks = 0;
diff --git a/internal/ceres/block_sparse_matrix_test.cc b/internal/ceres/block_sparse_matrix_test.cc
index 0c88bd9..02d3fb1 100644
--- a/internal/ceres/block_sparse_matrix_test.cc
+++ b/internal/ceres/block_sparse_matrix_test.cc
@@ -32,6 +32,7 @@
#include <memory>
#include <string>
+
#include "ceres/casts.h"
#include "ceres/internal/eigen.h"
#include "ceres/linear_least_squares_problems.h"
@@ -43,7 +44,7 @@
namespace internal {
class BlockSparseMatrixTest : public ::testing::Test {
- protected :
+ protected:
void SetUp() final {
std::unique_ptr<LinearLeastSquaresProblem> problem(
CreateLinearLeastSquaresProblemFromId(2));
@@ -159,13 +160,13 @@
A_->RightMultiply(x.data(), y_a.data());
B_->RightMultiply(x.data(), y_b.data());
- EXPECT_LT((y_a.head(B_->num_rows()) - y_b.head(B_->num_rows())).norm(), 1e-12);
+ EXPECT_LT((y_a.head(B_->num_rows()) - y_b.head(B_->num_rows())).norm(),
+ 1e-12);
Vector expected_tail = Vector::Zero(A_->num_cols());
expected_tail(i) = diagonal(i);
EXPECT_LT((y_a.tail(A_->num_cols()) - expected_tail).norm(), 1e-12);
}
-
A_->DeleteRowBlocks(column_blocks.size());
EXPECT_EQ(A_->num_rows(), B_->num_rows());
EXPECT_EQ(A_->num_cols(), B_->num_cols());
@@ -213,6 +214,5 @@
}
}
-
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/block_structure.cc b/internal/ceres/block_structure.cc
index 6479b60..39ba082 100644
--- a/internal/ceres/block_structure.cc
+++ b/internal/ceres/block_structure.cc
@@ -35,7 +35,7 @@
bool CellLessThan(const Cell& lhs, const Cell& rhs) {
if (lhs.block_id == rhs.block_id) {
- return (lhs.position < rhs.position);
+ return (lhs.position < rhs.position);
}
return (lhs.block_id < rhs.block_id);
}
diff --git a/internal/ceres/block_structure.h b/internal/ceres/block_structure.h
index b5218c0..d49d7d3 100644
--- a/internal/ceres/block_structure.h
+++ b/internal/ceres/block_structure.h
@@ -40,6 +40,7 @@
#include <cstdint>
#include <vector>
+
#include "ceres/internal/port.h"
namespace ceres {
diff --git a/internal/ceres/bundle_adjustment_test_util.h b/internal/ceres/bundle_adjustment_test_util.h
index 7e076eb..074931f 100644
--- a/internal/ceres/bundle_adjustment_test_util.h
+++ b/internal/ceres/bundle_adjustment_test_util.h
@@ -37,9 +37,8 @@
#include <cstdlib>
#include <string>
-#include "ceres/internal/port.h"
-
#include "ceres/autodiff_cost_function.h"
+#include "ceres/internal/port.h"
#include "ceres/ordered_groups.h"
#include "ceres/problem.h"
#include "ceres/rotation.h"
@@ -73,29 +72,31 @@
}
~BundleAdjustmentProblem() {
- delete []point_index_;
- delete []camera_index_;
- delete []observations_;
- delete []parameters_;
+ delete[] point_index_;
+ delete[] camera_index_;
+ delete[] observations_;
+ delete[] parameters_;
}
Problem* mutable_problem() { return &problem_; }
Solver::Options* mutable_solver_options() { return &options_; }
- int num_cameras() const { return num_cameras_; }
- int num_points() const { return num_points_; }
- int num_observations() const { return num_observations_; }
- const int* point_index() const { return point_index_; }
+ // clang-format off
+ int num_cameras() const { return num_cameras_; }
+ int num_points() const { return num_points_; }
+ int num_observations() const { return num_observations_; }
+ const int* point_index() const { return point_index_; }
const int* camera_index() const { return camera_index_; }
const double* observations() const { return observations_; }
- double* mutable_cameras() { return parameters_; }
- double* mutable_points() { return parameters_ + 9 * num_cameras_; }
+ double* mutable_cameras() { return parameters_; }
+ double* mutable_points() { return parameters_ + 9 * num_cameras_; }
+ // clang-format on
static double kResidualTolerance;
private:
void ReadData(const string& filename) {
- FILE * fptr = fopen(filename.c_str(), "r");
+ FILE* fptr = fopen(filename.c_str(), "r");
if (!fptr) {
LOG(FATAL) << "File Error: unable to open file " << filename;
@@ -106,9 +107,8 @@
FscanfOrDie(fptr, "%d", &num_points_);
FscanfOrDie(fptr, "%d", &num_observations_);
- VLOG(1) << "Header: " << num_cameras_
- << " " << num_points_
- << " " << num_observations_;
+ VLOG(1) << "Header: " << num_cameras_ << " " << num_points_ << " "
+ << num_observations_;
point_index_ = new int[num_observations_];
camera_index_ = new int[num_observations_];
@@ -121,7 +121,7 @@
FscanfOrDie(fptr, "%d", camera_index_ + i);
FscanfOrDie(fptr, "%d", point_index_ + i);
for (int j = 0; j < 2; ++j) {
- FscanfOrDie(fptr, "%lf", observations_ + 2*i + j);
+ FscanfOrDie(fptr, "%lf", observations_ + 2 * i + j);
}
}
@@ -141,8 +141,8 @@
// outputs a 2 dimensional residual.
CostFunction* cost_function =
new AutoDiffCostFunction<BundlerResidual, 2, 9, 3>(
- new BundlerResidual(observations_[2*i + 0],
- observations_[2*i + 1]));
+ new BundlerResidual(observations_[2 * i + 0],
+ observations_[2 * i + 1]));
// Each observation corresponds to a pair of a camera and a point
// which are identified by camera_index()[i] and
@@ -170,8 +170,8 @@
options_.parameter_tolerance = 1e-10;
}
- template<typename T>
- void FscanfOrDie(FILE *fptr, const char *format, T *value) {
+ template <typename T>
+ void FscanfOrDie(FILE* fptr, const char* format, T* value) {
int num_scanned = fscanf(fptr, format, value);
if (num_scanned != 1) {
LOG(FATAL) << "Invalid UW data file.";
@@ -186,7 +186,7 @@
struct BundlerResidual {
// (u, v): the position of the observation with respect to the image
// center point.
- BundlerResidual(double u, double v): u(u), v(v) {}
+ BundlerResidual(double u, double v) : u(u), v(v) {}
template <typename T>
bool operator()(const T* const camera,
@@ -207,12 +207,12 @@
// Compute the center of distortion. The sign change comes from
// the camera model that Noah Snavely's Bundler assumes, whereby
// the camera coordinate system has a negative z axis.
- T xp = - focal * p[0] / p[2];
- T yp = - focal * p[1] / p[2];
+ T xp = -focal * p[0] / p[2];
+ T yp = -focal * p[1] / p[2];
// Apply second and fourth order radial distortion.
- T r2 = xp*xp + yp*yp;
- T distortion = T(1.0) + r2 * (l1 + l2 * r2);
+ T r2 = xp * xp + yp * yp;
+ T distortion = T(1.0) + r2 * (l1 + l2 * r2);
residuals[0] = distortion * xp - u;
residuals[1] = distortion * yp - v;
diff --git a/internal/ceres/c_api.cc b/internal/ceres/c_api.cc
index 2244909..251cde4 100644
--- a/internal/ceres/c_api.cc
+++ b/internal/ceres/c_api.cc
@@ -34,9 +34,10 @@
#include "ceres/c_api.h"
-#include <vector>
#include <iostream>
#include <string>
+#include <vector>
+
#include "ceres/cost_function.h"
#include "ceres/loss_function.h"
#include "ceres/problem.h"
@@ -70,8 +71,7 @@
int num_residuals,
int num_parameter_blocks,
int* parameter_block_sizes)
- : cost_function_(cost_function),
- user_data_(user_data) {
+ : cost_function_(cost_function), user_data_(user_data) {
set_num_residuals(num_residuals);
for (int i = 0; i < num_parameter_blocks; ++i) {
mutable_parameter_block_sizes()->push_back(parameter_block_sizes[i]);
@@ -81,12 +81,10 @@
virtual ~CallbackCostFunction() {}
bool Evaluate(double const* const* parameters,
- double* residuals,
- double** jacobians) const final {
- return (*cost_function_)(user_data_,
- const_cast<double**>(parameters),
- residuals,
- jacobians);
+ double* residuals,
+ double** jacobians) const final {
+ return (*cost_function_)(
+ user_data_, const_cast<double**>(parameters), residuals, jacobians);
}
private:
@@ -100,7 +98,7 @@
public:
explicit CallbackLossFunction(ceres_loss_function_t loss_function,
void* user_data)
- : loss_function_(loss_function), user_data_(user_data) {}
+ : loss_function_(loss_function), user_data_(user_data) {}
void Evaluate(double sq_norm, double* rho) const final {
(*loss_function_)(user_data_, sq_norm, rho);
}
@@ -134,8 +132,8 @@
void ceres_stock_loss_function(void* user_data,
double squared_norm,
double out[3]) {
- reinterpret_cast<ceres::LossFunction*>(user_data)
- ->Evaluate(squared_norm, out);
+ reinterpret_cast<ceres::LossFunction*>(user_data)->Evaluate(squared_norm,
+ out);
}
ceres_residual_block_id_t* ceres_problem_add_residual_block(
@@ -159,16 +157,15 @@
ceres::LossFunction* callback_loss_function = NULL;
if (loss_function != NULL) {
- callback_loss_function = new CallbackLossFunction(loss_function,
- loss_function_data);
+ callback_loss_function =
+ new CallbackLossFunction(loss_function, loss_function_data);
}
std::vector<double*> parameter_blocks(parameters,
parameters + num_parameter_blocks);
return reinterpret_cast<ceres_residual_block_id_t*>(
- ceres_problem->AddResidualBlock(callback_cost_function,
- callback_loss_function,
- parameter_blocks));
+ ceres_problem->AddResidualBlock(
+ callback_cost_function, callback_loss_function, parameter_blocks));
}
void ceres_solve(ceres_problem_t* c_problem) {
diff --git a/internal/ceres/c_api_test.cc b/internal/ceres/c_api_test.cc
index fa11249..043f6ab 100644
--- a/internal/ceres/c_api_test.cc
+++ b/internal/ceres/c_api_test.cc
@@ -37,6 +37,7 @@
// Duplicated from curve_fitting.cc.
int num_observations = 67;
+// clang-format off
double data[] = {
0.000000e+00, 1.133898e+00,
7.500000e-02, 1.334902e+00,
@@ -106,13 +107,14 @@
4.875000e+00, 4.727863e+00,
4.950000e+00, 4.669206e+00,
};
+// clang-format on
// A test cost function, similar to the one in curve_fitting.c.
static int exponential_residual(void* user_data,
double** parameters,
double* residuals,
double** jacobians) {
- double* measurement = (double*) user_data;
+ double* measurement = (double*)user_data;
double x = measurement[0];
double y = measurement[1];
double m = parameters[0][0];
@@ -123,10 +125,10 @@
return 1;
}
if (jacobians[0] != NULL) {
- jacobians[0][0] = - x * exp(m * x + c); // dr/dm
+ jacobians[0][0] = -x * exp(m * x + c); // dr/dm
}
if (jacobians[1] != NULL) {
- jacobians[1][0] = - exp(m * x + c); // dr/dc
+ jacobians[1][0] = -exp(m * x + c); // dr/dc
}
return 1;
}
@@ -137,8 +139,8 @@
TEST(C_API, SimpleEndToEndTest) {
double m = 0.0;
double c = 0.0;
- double *parameter_pointers[] = { &m, &c };
- int parameter_sizes[] = { 1, 1 };
+ double* parameter_pointers[] = {&m, &c};
+ int parameter_sizes[] = {1, 1};
ceres_problem_t* problem = ceres_create_problem();
for (int i = 0; i < num_observations; ++i) {
@@ -162,16 +164,14 @@
ceres_free_problem(problem);
}
-template<typename T>
+template <typename T>
class ScopedSetValue {
public:
ScopedSetValue(T* variable, T new_value)
: variable_(variable), old_value_(*variable) {
*variable = new_value;
}
- ~ScopedSetValue() {
- *variable_ = old_value_;
- }
+ ~ScopedSetValue() { *variable_ = old_value_; }
private:
T* variable_;
@@ -181,8 +181,8 @@
TEST(C_API, LossFunctions) {
double m = 0.2;
double c = 0.03;
- double *parameter_pointers[] = { &m, &c };
- int parameter_sizes[] = { 1, 1 };
+ double* parameter_pointers[] = {&m, &c};
+ int parameter_sizes[] = {1, 1};
// Create two outliers, but be careful to leave the data intact.
ScopedSetValue<double> outlier1x(&data[12], 2.5);
@@ -191,19 +191,18 @@
ScopedSetValue<double> outlier2y(&data[15], 30e3);
// Create a cauchy cost function, and reuse it many times.
- void* cauchy_loss_data =
- ceres_create_cauchy_loss_function_data(5.0);
+ void* cauchy_loss_data = ceres_create_cauchy_loss_function_data(5.0);
ceres_problem_t* problem = ceres_create_problem();
for (int i = 0; i < num_observations; ++i) {
ceres_problem_add_residual_block(
problem,
- exponential_residual, // Cost function
- &data[2 * i], // Points to the (x,y) measurement
- ceres_stock_loss_function,
- cauchy_loss_data, // Loss function user data
- 1, // Number of residuals
- 2, // Number of parameter blocks
+ exponential_residual, // Cost function
+ &data[2 * i], // Points to the (x,y) measurement
+ ceres_stock_loss_function, //
+ cauchy_loss_data, // Loss function user data
+ 1, // Number of residuals
+ 2, // Number of parameter blocks
parameter_sizes,
parameter_pointers);
}
diff --git a/internal/ceres/callbacks.cc b/internal/ceres/callbacks.cc
index 84576e4..0e0df9d 100644
--- a/internal/ceres/callbacks.cc
+++ b/internal/ceres/callbacks.cc
@@ -28,8 +28,10 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
-#include <iostream> // NO LINT
#include "ceres/callbacks.h"
+
+#include <iostream> // NO LINT
+
#include "ceres/program.h"
#include "ceres/stringprintf.h"
#include "glog/logging.h"
@@ -76,8 +78,7 @@
LoggingCallback::LoggingCallback(const MinimizerType minimizer_type,
const bool log_to_stdout)
- : minimizer_type(minimizer_type),
- log_to_stdout_(log_to_stdout) {}
+ : minimizer_type(minimizer_type), log_to_stdout_(log_to_stdout) {}
LoggingCallback::~LoggingCallback() {}
@@ -99,11 +100,13 @@
summary.iteration_time_in_seconds,
summary.cumulative_time_in_seconds);
} else if (minimizer_type == TRUST_REGION) {
+ // clang-format off
if (summary.iteration == 0) {
output = "iter cost cost_change |gradient| |step| tr_ratio tr_radius ls_iter iter_time total_time\n"; // NOLINT
}
const char* kReportRowFormat =
"% 4d % 8e % 3.2e % 3.2e % 3.2e % 3.2e % 3.2e % 4d % 3.2e % 3.2e"; // NOLINT
+ // clang-format on
output += StringPrintf(kReportRowFormat,
summary.iteration,
summary.cost,
diff --git a/internal/ceres/callbacks.h b/internal/ceres/callbacks.h
index d68bf7f..47112b8 100644
--- a/internal/ceres/callbacks.h
+++ b/internal/ceres/callbacks.h
@@ -32,8 +32,9 @@
#define CERES_INTERNAL_CALLBACKS_H_
#include <string>
-#include "ceres/iteration_callback.h"
+
#include "ceres/internal/port.h"
+#include "ceres/iteration_callback.h"
namespace ceres {
namespace internal {
@@ -47,6 +48,7 @@
StateUpdatingCallback(Program* program, double* parameters);
virtual ~StateUpdatingCallback();
CallbackReturnType operator()(const IterationSummary& summary) final;
+
private:
Program* program_;
double* parameters_;
@@ -61,6 +63,7 @@
double* user_parameters);
virtual ~GradientProblemSolverStateUpdatingCallback();
CallbackReturnType operator()(const IterationSummary& summary) final;
+
private:
int num_parameters_;
const double* internal_parameters_;
diff --git a/internal/ceres/canonical_views_clustering.cc b/internal/ceres/canonical_views_clustering.cc
index e927e1f..c193735 100644
--- a/internal/ceres/canonical_views_clustering.cc
+++ b/internal/ceres/canonical_views_clustering.cc
@@ -31,8 +31,8 @@
#include "ceres/canonical_views_clustering.h"
-#include <unordered_set>
#include <unordered_map>
+#include <unordered_set>
#include "ceres/graph.h"
#include "ceres/map_util.h"
@@ -126,8 +126,7 @@
// Add canonical view if quality improves, or if minimum is not
// yet met, otherwise break.
- if ((best_difference <= 0) &&
- (centers->size() >= options_.min_views)) {
+ if ((best_difference <= 0) && (centers->size() >= options_.min_views)) {
break;
}
@@ -141,8 +140,7 @@
// Return the set of vertices of the graph which have valid vertex
// weights.
-void CanonicalViewsClustering::FindValidViews(
- IntSet* valid_views) const {
+void CanonicalViewsClustering::FindValidViews(IntSet* valid_views) const {
const IntSet& views = graph_->vertices();
for (const auto& view : views) {
if (graph_->VertexWeight(view) != WeightedGraph<int>::InvalidWeight()) {
@@ -154,8 +152,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 vector<int>& centers) const {
// View score.
double difference =
options_.view_score_weight * graph_->VertexWeight(candidate);
@@ -179,7 +176,7 @@
// Orthogonality.
for (int i = 0; i < centers.size(); ++i) {
difference -= options_.similarity_penalty_weight *
- graph_->EdgeWeight(centers[i], candidate);
+ graph_->EdgeWeight(centers[i], candidate);
}
return difference;
@@ -192,8 +189,7 @@
for (const auto& neighbor : neighbors) {
const double old_similarity =
FindWithDefault(view_to_canonical_view_similarity_, neighbor, 0.0);
- const double new_similarity =
- graph_->EdgeWeight(neighbor, canonical_view);
+ const double new_similarity = graph_->EdgeWeight(neighbor, canonical_view);
if (new_similarity > old_similarity) {
view_to_canonical_view_[neighbor] = canonical_view;
view_to_canonical_view_similarity_[neighbor] = new_similarity;
@@ -203,8 +199,7 @@
// Assign a cluster id to each view.
void CanonicalViewsClustering::ComputeClusterMembership(
- const vector<int>& centers,
- IntMap* membership) const {
+ const vector<int>& centers, IntMap* membership) const {
CHECK(membership != nullptr);
membership->clear();
diff --git a/internal/ceres/canonical_views_clustering_test.cc b/internal/ceres/canonical_views_clustering_test.cc
index 42e05bc..0593d65 100644
--- a/internal/ceres/canonical_views_clustering_test.cc
+++ b/internal/ceres/canonical_views_clustering_test.cc
@@ -32,6 +32,7 @@
#include "ceres/canonical_views_clustering.h"
#include <unordered_map>
+
#include "ceres/graph.h"
#include "gtest/gtest.h"
@@ -110,7 +111,6 @@
EXPECT_EQ(centers_[0], kVertexIds[1]);
}
-
// Increases view score weight so vertex 2 will be chosen.
TEST_F(CanonicalViewsTest, ViewScoreTest) {
options_.min_views = 0;
diff --git a/internal/ceres/casts.h b/internal/ceres/casts.h
index f18fdea..d137071 100644
--- a/internal/ceres/casts.h
+++ b/internal/ceres/casts.h
@@ -56,15 +56,15 @@
//
// base::identity_ is used to make a non-deduced context, which
// forces all callers to explicitly specify the template argument.
-template<typename To>
+template <typename To>
inline To implicit_cast(typename identity_<To>::type to) {
return to;
}
// This version of implicit_cast is used when two template arguments
// are specified. It's obsolete and should not be used.
-template<typename To, typename From>
-inline To implicit_cast(typename identity_<From>::type const &f) {
+template <typename To, typename From>
+inline To implicit_cast(typename identity_<From>::type const& f) {
return f;
}
@@ -86,8 +86,8 @@
// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
// You should design the code some other way not to need this.
-template<typename To, typename From> // use like this: down_cast<T*>(foo);
-inline To down_cast(From* f) { // so we only accept pointers
+template <typename To, typename From> // use like this: down_cast<T*>(foo);
+inline To down_cast(From* f) { // so we only accept pointers
// Ensures that To is a sub-type of From *. This test is here only
// for compile-time type checking, and has no overhead in an
// optimized build at run-time, as it will be optimized away
diff --git a/internal/ceres/cgnr_linear_operator.h b/internal/ceres/cgnr_linear_operator.h
index 8e8febc..beb8bbc 100644
--- a/internal/ceres/cgnr_linear_operator.h
+++ b/internal/ceres/cgnr_linear_operator.h
@@ -33,8 +33,9 @@
#include <algorithm>
#include <memory>
-#include "ceres/linear_operator.h"
+
#include "ceres/internal/eigen.h"
+#include "ceres/linear_operator.h"
namespace ceres {
namespace internal {
@@ -79,9 +80,8 @@
// Note: This class is not thread safe, since it uses some temporary storage.
class CgnrLinearOperator : public LinearOperator {
public:
- CgnrLinearOperator(const LinearOperator& A, const double *D)
- : A_(A), D_(D), z_(new double[A.num_rows()]) {
- }
+ CgnrLinearOperator(const LinearOperator& A, const double* D)
+ : A_(A), D_(D), z_(new double[A.num_rows()]) {}
virtual ~CgnrLinearOperator() {}
void RightMultiply(const double* x, double* y) const final {
@@ -96,8 +96,8 @@
// y = y + DtDx
if (D_ != NULL) {
int n = A_.num_cols();
- VectorRef(y, n).array() += ConstVectorRef(D_, n).array().square() *
- ConstVectorRef(x, n).array();
+ VectorRef(y, n).array() +=
+ ConstVectorRef(D_, n).array().square() * ConstVectorRef(x, n).array();
}
}
diff --git a/internal/ceres/cgnr_solver.h b/internal/ceres/cgnr_solver.h
index 5292733..bc701c0 100644
--- a/internal/ceres/cgnr_solver.h
+++ b/internal/ceres/cgnr_solver.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_CGNR_SOLVER_H_
#include <memory>
+
#include "ceres/linear_solver.h"
namespace ceres {
@@ -55,11 +56,10 @@
void operator=(const CgnrSolver&) = delete;
virtual ~CgnrSolver();
- Summary SolveImpl(
- BlockSparseMatrix* A,
- const double* b,
- const LinearSolver::PerSolveOptions& per_solve_options,
- double* x) final;
+ Summary SolveImpl(BlockSparseMatrix* A,
+ const double* b,
+ const LinearSolver::PerSolveOptions& per_solve_options,
+ double* x) final;
private:
const LinearSolver::Options options_;
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils.cc b/internal/ceres/compressed_col_sparse_matrix_utils.cc
index 3f6672f..e1f6bb8 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils.cc
@@ -30,8 +30,9 @@
#include "ceres/compressed_col_sparse_matrix_utils.h"
-#include <vector>
#include <algorithm>
+#include <vector>
+
#include "ceres/internal/port.h"
#include "glog/logging.h"
@@ -40,13 +41,12 @@
using std::vector;
-void CompressedColumnScalarMatrixToBlockMatrix(
- const int* scalar_rows,
- const int* scalar_cols,
- const vector<int>& row_blocks,
- const vector<int>& col_blocks,
- vector<int>* block_rows,
- vector<int>* block_cols) {
+void CompressedColumnScalarMatrixToBlockMatrix(const int* scalar_rows,
+ const int* scalar_cols,
+ const vector<int>& row_blocks,
+ const vector<int>& col_blocks,
+ vector<int>* block_rows,
+ vector<int>* block_cols) {
CHECK(block_rows != nullptr);
CHECK(block_cols != nullptr);
block_rows->clear();
@@ -71,10 +71,8 @@
for (int col_block = 0; col_block < num_col_blocks; ++col_block) {
int column_size = 0;
for (int idx = scalar_cols[c]; idx < scalar_cols[c + 1]; ++idx) {
- vector<int>::const_iterator it =
- std::lower_bound(row_block_starts.begin(),
- row_block_starts.end(),
- scalar_rows[idx]);
+ vector<int>::const_iterator it = std::lower_bound(
+ row_block_starts.begin(), row_block_starts.end(), scalar_rows[idx]);
// Since we are using lower_bound, it will return the row id
// where the row block starts. For everything but the first row
// of the block, where these values will be the same, we can
@@ -104,7 +102,7 @@
// block_starts = [0, block1, block1 + block2 ..]
vector<int> block_starts(num_blocks);
- for (int i = 0, cursor = 0; i < num_blocks ; ++i) {
+ for (int i = 0, cursor = 0; i < num_blocks; ++i) {
block_starts[i] = cursor;
cursor += blocks[i];
}
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils.h b/internal/ceres/compressed_col_sparse_matrix_utils.h
index da2109f..8e56519 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils.h
+++ b/internal/ceres/compressed_col_sparse_matrix_utils.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_COMPRESSED_COL_SPARSE_MATRIX_UTILS_H_
#include <vector>
+
#include "ceres/internal/port.h"
namespace ceres {
@@ -58,10 +59,9 @@
// Given a set of blocks and a permutation of these blocks, compute
// the corresponding "scalar" ordering, where the scalar ordering of
// size sum(blocks).
-void BlockOrderingToScalarOrdering(
- const std::vector<int>& blocks,
- const std::vector<int>& block_ordering,
- std::vector<int>* scalar_ordering);
+void BlockOrderingToScalarOrdering(const std::vector<int>& blocks,
+ const std::vector<int>& block_ordering,
+ std::vector<int>* scalar_ordering);
// Solve the linear system
//
@@ -101,7 +101,7 @@
const double v = values[idx];
rhs_and_solution[c] -= v * rhs_and_solution[r];
}
- rhs_and_solution[c] = rhs_and_solution[c] / values[cols[c + 1] - 1];
+ rhs_and_solution[c] = rhs_and_solution[c] / values[cols[c + 1] - 1];
}
}
@@ -132,7 +132,7 @@
const double v = values[idx];
solution[c] -= v * solution[r];
}
- solution[c] = solution[c] / values[cols[c + 1] - 1];
+ solution[c] = solution[c] / values[cols[c + 1] - 1];
}
SolveUpperTriangularInPlace(num_cols, rows, cols, values, solution);
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
index ba422a4..339c064 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
@@ -28,15 +28,16 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/compressed_col_sparse_matrix_utils.h"
#include <algorithm>
#include <numeric>
-#include "ceres/compressed_col_sparse_matrix_utils.h"
+
+#include "Eigen/SparseCore"
#include "ceres/internal/port.h"
#include "ceres/triplet_sparse_matrix.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
-#include "Eigen/SparseCore"
namespace ceres {
namespace internal {
@@ -78,9 +79,7 @@
expected_scalar_ordering.push_back(8);
vector<int> scalar_ordering;
- BlockOrderingToScalarOrdering(blocks,
- block_ordering,
- &scalar_ordering);
+ BlockOrderingToScalarOrdering(blocks, block_ordering, &scalar_ordering);
EXPECT_EQ(scalar_ordering.size(), expected_scalar_ordering.size());
for (int i = 0; i < expected_scalar_ordering.size(); ++i) {
EXPECT_EQ(scalar_ordering[i], expected_scalar_ordering[i]);
@@ -92,11 +91,14 @@
const int row_block_id,
const int col_block_id,
vector<Eigen::Triplet<double>>* triplets) {
- const int row_offset = std::accumulate(&row_blocks[0], &row_blocks[row_block_id], 0);
- const int col_offset = std::accumulate(&col_blocks[0], &col_blocks[col_block_id], 0);
+ const int row_offset =
+ std::accumulate(&row_blocks[0], &row_blocks[row_block_id], 0);
+ const int col_offset =
+ std::accumulate(&col_blocks[0], &col_blocks[col_block_id], 0);
for (int r = 0; r < row_blocks[row_block_id]; ++r) {
for (int c = 0; c < col_blocks[col_block_id]; ++c) {
- triplets->push_back(Eigen::Triplet<double>(row_offset + r, col_offset + c, 1.0));
+ triplets->push_back(
+ Eigen::Triplet<double>(row_offset + r, col_offset + c, 1.0));
}
}
}
@@ -110,7 +112,6 @@
// [2] x x
// num_nonzeros = 1 + 3 + 4 + 4 + 1 + 2 = 15
-
vector<int> col_blocks;
col_blocks.push_back(1);
col_blocks.push_back(2);
@@ -122,8 +123,10 @@
row_blocks.push_back(2);
row_blocks.push_back(2);
- const int num_rows = std::accumulate(row_blocks.begin(), row_blocks.end(), 0.0);
- const int num_cols = std::accumulate(col_blocks.begin(), col_blocks.end(), 0.0);
+ const int num_rows =
+ std::accumulate(row_blocks.begin(), row_blocks.end(), 0.0);
+ const int num_cols =
+ std::accumulate(col_blocks.begin(), col_blocks.end(), 0.0);
vector<Eigen::Triplet<double>> triplets;
FillBlock(row_blocks, col_blocks, 0, 0, &triplets);
@@ -152,13 +155,12 @@
vector<int> compressed_block_rows;
vector<int> compressed_block_cols;
- CompressedColumnScalarMatrixToBlockMatrix(
- sparse_matrix.innerIndexPtr(),
- sparse_matrix.outerIndexPtr(),
- row_blocks,
- col_blocks,
- &compressed_block_rows,
- &compressed_block_cols);
+ CompressedColumnScalarMatrixToBlockMatrix(sparse_matrix.innerIndexPtr(),
+ sparse_matrix.outerIndexPtr(),
+ row_blocks,
+ col_blocks,
+ &compressed_block_rows,
+ &compressed_block_cols);
EXPECT_EQ(compressed_block_rows, expected_compressed_block_rows);
EXPECT_EQ(compressed_block_cols, expected_compressed_block_cols);
@@ -203,13 +205,10 @@
TEST_F(SolveUpperTriangularTest, SolveInPlace) {
double rhs_and_solution[] = {1.0, 1.0, 2.0, 2.0};
- const double expected[] = { -1.4706, -1.0962, 6.6667, 2.2477};
+ const double expected[] = {-1.4706, -1.0962, 6.6667, 2.2477};
- SolveUpperTriangularInPlace<int>(cols.size() - 1,
- &rows[0],
- &cols[0],
- &values[0],
- rhs_and_solution);
+ SolveUpperTriangularInPlace<int>(
+ cols.size() - 1, &rows[0], &cols[0], &values[0], rhs_and_solution);
for (int i = 0; i < 4; ++i) {
EXPECT_NEAR(rhs_and_solution[i], expected[i], 1e-4) << i;
@@ -218,13 +217,10 @@
TEST_F(SolveUpperTriangularTest, TransposeSolveInPlace) {
double rhs_and_solution[] = {1.0, 1.0, 2.0, 2.0};
- double expected[] = {1.970288, 1.242498, 6.081864, -0.057255};
+ double expected[] = {1.970288, 1.242498, 6.081864, -0.057255};
- SolveUpperTriangularTransposeInPlace<int>(cols.size() - 1,
- &rows[0],
- &cols[0],
- &values[0],
- rhs_and_solution);
+ SolveUpperTriangularTransposeInPlace<int>(
+ cols.size() - 1, &rows[0], &cols[0], &values[0], rhs_and_solution);
for (int i = 0; i < 4; ++i) {
EXPECT_NEAR(rhs_and_solution[i], expected[i], 1e-4) << i;
@@ -233,18 +229,16 @@
TEST_F(SolveUpperTriangularTest, RTRSolveWithSparseRHS) {
double solution[4];
+ // clang-format off
double expected[] = { 6.8420e+00, 1.0057e+00, -1.4907e-16, -1.9335e+00,
1.0057e+00, 2.2275e+00, -1.9493e+00, -6.5693e-01,
-1.4907e-16, -1.9493e+00, 1.1111e+01, 9.7381e-17,
-1.9335e+00, -6.5693e-01, 9.7381e-17, 1.2631e+00 };
+ // clang-format on
for (int i = 0; i < 4; ++i) {
- SolveRTRWithSparseRHS<int>(cols.size() - 1,
- &rows[0],
- &cols[0],
- &values[0],
- i,
- solution);
+ SolveRTRWithSparseRHS<int>(
+ cols.size() - 1, &rows[0], &cols[0], &values[0], i, solution);
for (int j = 0; j < 4; ++j) {
EXPECT_NEAR(solution[j], expected[4 * i + j], 1e-3) << i;
}
diff --git a/internal/ceres/compressed_row_jacobian_writer.cc b/internal/ceres/compressed_row_jacobian_writer.cc
index 1fc0116..8e7e3e7 100644
--- a/internal/ceres/compressed_row_jacobian_writer.cc
+++ b/internal/ceres/compressed_row_jacobian_writer.cc
@@ -44,23 +44,21 @@
namespace ceres {
namespace internal {
+using std::adjacent_find;
using std::make_pair;
using std::pair;
using std::vector;
-using std::adjacent_find;
void CompressedRowJacobianWriter::PopulateJacobianRowAndColumnBlockVectors(
const Program* program, CompressedRowSparseMatrix* jacobian) {
- const vector<ParameterBlock*>& parameter_blocks =
- program->parameter_blocks();
+ const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
vector<int>& col_blocks = *(jacobian->mutable_col_blocks());
col_blocks.resize(parameter_blocks.size());
for (int i = 0; i < parameter_blocks.size(); ++i) {
col_blocks[i] = parameter_blocks[i]->LocalSize();
}
- const vector<ResidualBlock*>& residual_blocks =
- program->residual_blocks();
+ const vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
vector<int>& row_blocks = *(jacobian->mutable_row_blocks());
row_blocks.resize(residual_blocks.size());
for (int i = 0; i < residual_blocks.size(); ++i) {
@@ -69,11 +67,10 @@
}
void CompressedRowJacobianWriter::GetOrderedParameterBlocks(
- const Program* program,
- int residual_id,
- vector<pair<int, int>>* evaluated_jacobian_blocks) {
- const ResidualBlock* residual_block =
- program->residual_blocks()[residual_id];
+ const Program* program,
+ int residual_id,
+ vector<pair<int, int>>* evaluated_jacobian_blocks) {
+ const ResidualBlock* residual_block = program->residual_blocks()[residual_id];
const int num_parameter_blocks = residual_block->NumParameterBlocks();
for (int j = 0; j < num_parameter_blocks; ++j) {
@@ -88,8 +85,7 @@
}
SparseMatrix* CompressedRowJacobianWriter::CreateJacobian() const {
- const vector<ResidualBlock*>& residual_blocks =
- program_->residual_blocks();
+ const vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
int total_num_residuals = program_->NumResiduals();
int total_num_effective_parameters = program_->NumEffectiveParameters();
@@ -112,11 +108,10 @@
// Allocate more space than needed to store the jacobian so that when the LM
// algorithm adds the diagonal, no reallocation is necessary. This reduces
// peak memory usage significantly.
- CompressedRowSparseMatrix* jacobian =
- new CompressedRowSparseMatrix(
- total_num_residuals,
- total_num_effective_parameters,
- num_jacobian_nonzeros + total_num_effective_parameters);
+ CompressedRowSparseMatrix* jacobian = new CompressedRowSparseMatrix(
+ total_num_residuals,
+ total_num_effective_parameters,
+ num_jacobian_nonzeros + total_num_effective_parameters);
// At this stage, the CompressedRowSparseMatrix is an invalid state. But this
// seems to be the only way to construct it without doing a memory copy.
@@ -148,8 +143,7 @@
std::string parameter_block_description;
for (int j = 0; j < num_parameter_blocks; ++j) {
ParameterBlock* parameter_block = residual_block->parameter_blocks()[j];
- parameter_block_description +=
- parameter_block->ToString() + "\n";
+ parameter_block_description += parameter_block->ToString() + "\n";
}
LOG(FATAL) << "Ceres internal error: "
<< "Duplicate parameter blocks detected in a cost function. "
@@ -196,7 +190,7 @@
void CompressedRowJacobianWriter::Write(int residual_id,
int residual_offset,
- double **jacobians,
+ double** jacobians,
SparseMatrix* base_jacobian) {
CompressedRowSparseMatrix* jacobian =
down_cast<CompressedRowSparseMatrix*>(base_jacobian);
diff --git a/internal/ceres/compressed_row_jacobian_writer.h b/internal/ceres/compressed_row_jacobian_writer.h
index 9fb414e..b1251ca 100644
--- a/internal/ceres/compressed_row_jacobian_writer.h
+++ b/internal/ceres/compressed_row_jacobian_writer.h
@@ -50,8 +50,7 @@
public:
CompressedRowJacobianWriter(Evaluator::Options /* ignored */,
Program* program)
- : program_(program) {
- }
+ : program_(program) {}
// PopulateJacobianRowAndColumnBlockVectors sets col_blocks and
// row_blocks for a CompressedRowSparseMatrix, based on the
@@ -64,8 +63,7 @@
// (Jacobian writers do not fall under any type hierarchy; they only
// have to provide an interface as specified in program_evaluator.h).
static void PopulateJacobianRowAndColumnBlockVectors(
- const Program* program,
- CompressedRowSparseMatrix* jacobian);
+ const Program* program, CompressedRowSparseMatrix* jacobian);
// It is necessary to determine the order of the jacobian blocks
// before copying them into a CompressedRowSparseMatrix (or derived
@@ -99,7 +97,7 @@
void Write(int residual_id,
int residual_offset,
- double **jacobians,
+ double** jacobians,
SparseMatrix* base_jacobian);
private:
diff --git a/internal/ceres/compressed_row_sparse_matrix.cc b/internal/ceres/compressed_row_sparse_matrix.cc
index e56de16..900586c 100644
--- a/internal/ceres/compressed_row_sparse_matrix.cc
+++ b/internal/ceres/compressed_row_sparse_matrix.cc
@@ -33,6 +33,7 @@
#include <algorithm>
#include <numeric>
#include <vector>
+
#include "ceres/crs_matrix.h"
#include "ceres/internal/port.h"
#include "ceres/random.h"
diff --git a/internal/ceres/compressed_row_sparse_matrix.h b/internal/ceres/compressed_row_sparse_matrix.h
index 758b40b..203c7ea 100644
--- a/internal/ceres/compressed_row_sparse_matrix.h
+++ b/internal/ceres/compressed_row_sparse_matrix.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_COMPRESSED_ROW_SPARSE_MATRIX_H_
#include <vector>
+
#include "ceres/internal/port.h"
#include "ceres/sparse_matrix.h"
#include "ceres/types.h"
diff --git a/internal/ceres/compressed_row_sparse_matrix_test.cc b/internal/ceres/compressed_row_sparse_matrix_test.cc
index 214f374..91f3ba4 100644
--- a/internal/ceres/compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/compressed_row_sparse_matrix_test.cc
@@ -32,6 +32,8 @@
#include <memory>
#include <numeric>
+
+#include "Eigen/SparseCore"
#include "ceres/casts.h"
#include "ceres/crs_matrix.h"
#include "ceres/internal/eigen.h"
@@ -41,8 +43,6 @@
#include "glog/logging.h"
#include "gtest/gtest.h"
-#include "Eigen/SparseCore"
-
namespace ceres {
namespace internal {
@@ -445,11 +445,12 @@
0.0,
std::numeric_limits<double>::epsilon() * 10)
<< "\n"
- << dense
- << "x:\n"
+ << dense << "x:\n"
<< x.transpose() << "\n"
- << "expected: \n" << expected_y.transpose() << "\n"
- << "actual: \n" << actual_y.transpose();
+ << "expected: \n"
+ << expected_y.transpose() << "\n"
+ << "actual: \n"
+ << actual_y.transpose();
}
}
}
@@ -513,11 +514,12 @@
0.0,
std::numeric_limits<double>::epsilon() * 10)
<< "\n"
- << dense
- << "x\n"
+ << dense << "x\n"
<< x.transpose() << "\n"
- << "expected: \n" << expected_y.transpose() << "\n"
- << "actual: \n" << actual_y.transpose();
+ << "expected: \n"
+ << expected_y.transpose() << "\n"
+ << "actual: \n"
+ << actual_y.transpose();
}
}
}
@@ -579,9 +581,10 @@
0.0,
std::numeric_limits<double>::epsilon() * 10)
<< "\n"
- << dense
- << "expected: \n" << expected.transpose() << "\n"
- << "actual: \n" << actual.transpose();
+ << dense << "expected: \n"
+ << expected.transpose() << "\n"
+ << "actual: \n"
+ << actual.transpose();
}
}
}
@@ -594,7 +597,6 @@
CompressedRowSparseMatrix::UNSYMMETRIC),
ParamInfoToString);
-
// TODO(sameeragarwal) Add tests for the random matrix creation methods.
} // namespace internal
diff --git a/internal/ceres/concurrent_queue.h b/internal/ceres/concurrent_queue.h
index 52e2903..a04d147 100644
--- a/internal/ceres/concurrent_queue.h
+++ b/internal/ceres/concurrent_queue.h
@@ -152,7 +152,6 @@
bool wait_;
};
-
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/concurrent_queue_test.cc b/internal/ceres/concurrent_queue_test.cc
index ce6d687..430111a 100644
--- a/internal/ceres/concurrent_queue_test.cc
+++ b/internal/ceres/concurrent_queue_test.cc
@@ -37,7 +37,6 @@
#include <thread>
#include "ceres/concurrent_queue.h"
-
#include "gmock/gmock.h"
#include "gtest/gtest.h"
@@ -304,4 +303,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/conditioned_cost_function.cc b/internal/ceres/conditioned_cost_function.cc
index d933ad7..fb4c52a 100644
--- a/internal/ceres/conditioned_cost_function.cc
+++ b/internal/ceres/conditioned_cost_function.cc
@@ -68,7 +68,8 @@
ConditionedCostFunction::~ConditionedCostFunction() {
if (ownership_ == TAKE_OWNERSHIP) {
- STLDeleteUniqueContainerPointers(conditioners_.begin(), conditioners_.end());
+ STLDeleteUniqueContainerPointers(conditioners_.begin(),
+ conditioners_.end());
} else {
wrapped_cost_function_.release();
}
@@ -77,8 +78,8 @@
bool ConditionedCostFunction::Evaluate(double const* const* parameters,
double* residuals,
double** jacobians) const {
- bool success = wrapped_cost_function_->Evaluate(parameters, residuals,
- jacobians);
+ bool success =
+ wrapped_cost_function_->Evaluate(parameters, residuals, jacobians);
if (!success) {
return false;
}
@@ -102,9 +103,8 @@
double unconditioned_residual = residuals[r];
double* parameter_pointer = &unconditioned_residual;
- success = conditioners_[r]->Evaluate(¶meter_pointer,
- &residuals[r],
- conditioner_derivative_pointer2);
+ success = conditioners_[r]->Evaluate(
+ ¶meter_pointer, &residuals[r], conditioner_derivative_pointer2);
if (!success) {
return false;
}
@@ -117,7 +117,8 @@
int parameter_block_size =
wrapped_cost_function_->parameter_block_sizes()[i];
VectorRef jacobian_row(jacobians[i] + r * parameter_block_size,
- parameter_block_size, 1);
+ parameter_block_size,
+ 1);
jacobian_row *= conditioner_derivative;
}
}
diff --git a/internal/ceres/conditioned_cost_function_test.cc b/internal/ceres/conditioned_cost_function_test.cc
index cd15507..f21f84c 100644
--- a/internal/ceres/conditioned_cost_function_test.cc
+++ b/internal/ceres/conditioned_cost_function_test.cc
@@ -125,7 +125,8 @@
// Make a cost function that computes x - v2
double v2[kTestCostFunctionSize];
VectorRef v2_vector(v2, kTestCostFunctionSize, 1);
- Matrix identity = Matrix::Identity(kTestCostFunctionSize, kTestCostFunctionSize);
+ Matrix identity =
+ Matrix::Identity(kTestCostFunctionSize, kTestCostFunctionSize);
NormalPrior* difference_cost_function = new NormalPrior(identity, v2_vector);
CostFunction* conditioner = new LinearCostFunction(2, 7);
std::vector<CostFunction*> conditioners;
diff --git a/internal/ceres/conjugate_gradients_solver.cc b/internal/ceres/conjugate_gradients_solver.cc
index c6f85c1..3019628 100644
--- a/internal/ceres/conjugate_gradients_solver.cc
+++ b/internal/ceres/conjugate_gradients_solver.cc
@@ -41,6 +41,7 @@
#include <cmath>
#include <cstddef>
+
#include "ceres/internal/eigen.h"
#include "ceres/linear_operator.h"
#include "ceres/stringprintf.h"
@@ -51,16 +52,13 @@
namespace internal {
namespace {
-bool IsZeroOrInfinity(double x) {
- return ((x == 0.0) || std::isinf(x));
-}
+bool IsZeroOrInfinity(double x) { return ((x == 0.0) || std::isinf(x)); }
} // namespace
ConjugateGradientsSolver::ConjugateGradientsSolver(
const LinearSolver::Options& options)
- : options_(options) {
-}
+ : options_(options) {}
LinearSolver::Summary ConjugateGradientsSolver::Solve(
LinearOperator* A,
@@ -137,7 +135,10 @@
summary.termination_type = LINEAR_SOLVER_FAILURE;
summary.message = StringPrintf(
"Numerical failure. beta = rho_n / rho_{n-1} = %e, "
- "rho_n = %e, rho_{n-1} = %e", beta, rho, last_rho);
+ "rho_n = %e, rho_{n-1} = %e",
+ beta,
+ rho,
+ last_rho);
break;
}
p = z + beta * p;
@@ -152,16 +153,20 @@
summary.message = StringPrintf(
"Matrix is indefinite, no more progress can be made. "
"p'q = %e. |p| = %e, |q| = %e",
- pq, p.norm(), q.norm());
+ pq,
+ p.norm(),
+ q.norm());
break;
}
const double alpha = rho / pq;
if (std::isinf(alpha)) {
summary.termination_type = LINEAR_SOLVER_FAILURE;
- summary.message =
- StringPrintf("Numerical failure. alpha = rho / pq = %e, "
- "rho = %e, pq = %e.", alpha, rho, pq);
+ summary.message = StringPrintf(
+ "Numerical failure. alpha = rho / pq = %e, rho = %e, pq = %e.",
+ alpha,
+ rho,
+ pq);
break;
}
@@ -223,7 +228,7 @@
Q0 = Q1;
// Residual based termination.
- norm_r = r. norm();
+ norm_r = r.norm();
if (norm_r <= tol_r &&
summary.num_iterations >= options_.min_num_iterations) {
summary.termination_type = LINEAR_SOLVER_SUCCESS;
diff --git a/internal/ceres/conjugate_gradients_solver_test.cc b/internal/ceres/conjugate_gradients_solver_test.cc
index 9311998..b11e522 100644
--- a/internal/ceres/conjugate_gradients_solver_test.cc
+++ b/internal/ceres/conjugate_gradients_solver_test.cc
@@ -31,21 +31,23 @@
// TODO(sameeragarwal): More comprehensive testing with larger and
// more badly conditioned problem.
-#include <memory>
-#include "gtest/gtest.h"
#include "ceres/conjugate_gradients_solver.h"
+
+#include <memory>
+
+#include "ceres/internal/eigen.h"
#include "ceres/linear_solver.h"
#include "ceres/triplet_sparse_matrix.h"
-#include "ceres/internal/eigen.h"
#include "ceres/types.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
TEST(ConjugateGradientTest, Solves3x3IdentitySystem) {
- double diagonal[] = { 1.0, 1.0, 1.0 };
- std::unique_ptr<TripletSparseMatrix>
- A(TripletSparseMatrix::CreateSparseDiagonalMatrix(diagonal, 3));
+ double diagonal[] = {1.0, 1.0, 1.0};
+ std::unique_ptr<TripletSparseMatrix> A(
+ TripletSparseMatrix::CreateSparseDiagonalMatrix(diagonal, 3));
Vector b(3);
Vector x(3);
@@ -75,7 +77,6 @@
ASSERT_DOUBLE_EQ(3, x(2));
}
-
TEST(ConjuateGradientTest, Solves3x3SymmetricSystem) {
std::unique_ptr<TripletSparseMatrix> A(new TripletSparseMatrix(3, 3, 9));
Vector b(3);
diff --git a/internal/ceres/context.cc b/internal/ceres/context.cc
index e223201..55e7635 100644
--- a/internal/ceres/context.cc
+++ b/internal/ceres/context.cc
@@ -34,8 +34,6 @@
namespace ceres {
-Context* Context::Create() {
- return new internal::ContextImpl();
-}
+Context* Context::Create() { return new internal::ContextImpl(); }
} // namespace ceres
diff --git a/internal/ceres/context_impl.cc b/internal/ceres/context_impl.cc
index 622f33a..20fe5cb 100644
--- a/internal/ceres/context_impl.cc
+++ b/internal/ceres/context_impl.cc
@@ -37,7 +37,6 @@
#ifdef CERES_USE_CXX_THREADS
thread_pool.Resize(num_threads);
#endif // CERES_USE_CXX_THREADS
-
}
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/context_impl.h b/internal/ceres/context_impl.h
index 5c03ad7..90ba344 100644
--- a/internal/ceres/context_impl.h
+++ b/internal/ceres/context_impl.h
@@ -32,7 +32,9 @@
#define CERES_INTERNAL_CONTEXT_IMPL_H_
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clanf-format on
#include "ceres/context.h"
diff --git a/internal/ceres/coordinate_descent_minimizer.cc b/internal/ceres/coordinate_descent_minimizer.cc
index c5d56f3..93096ac 100644
--- a/internal/ceres/coordinate_descent_minimizer.cc
+++ b/internal/ceres/coordinate_descent_minimizer.cc
@@ -64,8 +64,7 @@
CHECK(context_ != nullptr);
}
-CoordinateDescentMinimizer::~CoordinateDescentMinimizer() {
-}
+CoordinateDescentMinimizer::~CoordinateDescentMinimizer() {}
bool CoordinateDescentMinimizer::Init(
const Program& program,
@@ -82,13 +81,13 @@
map<int, 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) {
+ for (double* parameter_block : elements) {
parameter_blocks_.push_back(parameter_map.find(parameter_block)->second);
parameter_block_index[parameter_blocks_.back()] =
parameter_blocks_.size() - 1;
}
- independent_set_offsets_.push_back(
- independent_set_offsets_.back() + elements.size());
+ independent_set_offsets_.push_back(independent_set_offsets_.back() +
+ elements.size());
}
// The ordering does not have to contain all parameter blocks, so
@@ -126,10 +125,9 @@
return true;
}
-void CoordinateDescentMinimizer::Minimize(
- const Minimizer::Options& options,
- double* parameters,
- Solver::Summary* summary) {
+void CoordinateDescentMinimizer::Minimize(const Minimizer::Options& options,
+ double* parameters,
+ Solver::Summary* summary) {
// Set the state and mark all parameter blocks constant.
for (int i = 0; i < parameter_blocks_.size(); ++i) {
ParameterBlock* parameter_block = parameter_blocks_[i];
@@ -202,7 +200,7 @@
});
}
- for (int i = 0; i < parameter_blocks_.size(); ++i) {
+ for (int i = 0; i < parameter_blocks_.size(); ++i) {
parameter_blocks_[i]->SetVarying();
}
@@ -251,10 +249,10 @@
// Verify that each group is an independent set
for (const auto& g_t_e : group_to_elements) {
if (!program.IsParameterBlockSetIndependent(g_t_e.second)) {
- *message =
- StringPrintf("The user-provided "
- "parameter_blocks_for_inner_iterations does not "
- "form an independent set. Group Id: %d", g_t_e.first);
+ *message = StringPrintf(
+ "The user-provided parameter_blocks_for_inner_iterations does not "
+ "form an independent set. Group Id: %d",
+ g_t_e.first);
return false;
}
}
diff --git a/internal/ceres/corrector.cc b/internal/ceres/corrector.cc
index 4ac0dc3..6a79a06 100644
--- a/internal/ceres/corrector.cc
+++ b/internal/ceres/corrector.cc
@@ -30,8 +30,9 @@
#include "ceres/corrector.h"
-#include <cstddef>
#include <cmath>
+#include <cstddef>
+
#include "ceres/internal/eigen.h"
#include "glog/logging.h"
@@ -147,9 +148,9 @@
}
for (int r = 0; r < num_rows; ++r) {
- jacobian[r * num_cols + c] = sqrt_rho1_ *
- (jacobian[r * num_cols + c] -
- alpha_sq_norm_ * residuals[r] * r_transpose_j);
+ jacobian[r * num_cols + c] =
+ sqrt_rho1_ * (jacobian[r * num_cols + c] -
+ alpha_sq_norm_ * residuals[r] * r_transpose_j);
}
}
}
diff --git a/internal/ceres/corrector_test.cc b/internal/ceres/corrector_test.cc
index a6581fd..951041e 100644
--- a/internal/ceres/corrector_test.cc
+++ b/internal/ceres/corrector_test.cc
@@ -32,11 +32,12 @@
#include <algorithm>
#include <cmath>
-#include <cstring>
#include <cstdlib>
-#include "gtest/gtest.h"
-#include "ceres/random.h"
+#include <cstring>
+
#include "ceres/internal/eigen.h"
+#include "ceres/random.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -44,15 +45,13 @@
// If rho[1] is zero, the Corrector constructor should crash.
TEST(Corrector, ZeroGradientDeathTest) {
const double kRho[] = {0.0, 0.0, 1.0};
- EXPECT_DEATH_IF_SUPPORTED({Corrector c(1.0, kRho);},
- ".*");
+ EXPECT_DEATH_IF_SUPPORTED({ Corrector c(1.0, kRho); }, ".*");
}
// If rho[1] is negative, the Corrector constructor should crash.
TEST(Corrector, NegativeGradientDeathTest) {
const double kRho[] = {0.0, -0.1, 1.0};
- EXPECT_DEATH_IF_SUPPORTED({Corrector c(1.0, kRho);},
- ".*");
+ EXPECT_DEATH_IF_SUPPORTED({ Corrector c(1.0, kRho); }, ".*");
}
TEST(Corrector, ScalarCorrection) {
@@ -68,8 +67,7 @@
// Thus the expected value of the residual is
// residual[i] * sqrt(kRho[1]) / (1.0 - kAlpha).
- const double kExpectedResidual =
- residuals * sqrt(kRho[1]) / (1 - kAlpha);
+ const double kExpectedResidual = residuals * sqrt(kRho[1]) / (1 - kAlpha);
// The jacobian in this case will be
// sqrt(kRho[1]) * (1 - kAlpha) * jacobian.
@@ -123,13 +121,11 @@
// Thus the expected value of the residual is
// residual[i] * sqrt(kRho[1]) / (1.0 - kAlpha).
- const double kExpectedResidual =
- residuals * sqrt(kRho[1]) / (1.0 - kAlpha);
+ const double kExpectedResidual = residuals * sqrt(kRho[1]) / (1.0 - kAlpha);
// The jacobian in this case will be scaled by
// sqrt(rho[1]) * (1 - alpha) * J.
- const double kExpectedJacobian = sqrt(kRho[1]) *
- (1.0 - kAlpha) * jacobian;
+ const double kExpectedJacobian = sqrt(kRho[1]) * (1.0 - kAlpha) * jacobian;
Corrector c(sq_norm, kRho);
c.CorrectJacobian(1, 1, &residuals, &jacobian);
@@ -168,10 +164,8 @@
srand(5);
for (int iter = 0; iter < 10000; ++iter) {
// Initialize the jacobian and residual.
- for (int i = 0; i < 2 * 3; ++i)
- jacobian[i] = RandDouble();
- for (int i = 0; i < 3; ++i)
- residuals[i] = RandDouble();
+ for (int i = 0; i < 2 * 3; ++i) jacobian[i] = RandDouble();
+ for (int i = 0; i < 3; ++i) residuals[i] = RandDouble();
const double sq_norm = res.dot(res);
@@ -188,19 +182,19 @@
// Ground truth values.
g_res = sqrt(rho[1]) / (1.0 - kAlpha) * res;
- g_jac = sqrt(rho[1]) * (jac - kAlpha / sq_norm *
- res * res.transpose() * jac);
+ g_jac =
+ sqrt(rho[1]) * (jac - kAlpha / sq_norm * res * res.transpose() * jac);
g_grad = rho[1] * jac.transpose() * res;
g_hess = rho[1] * jac.transpose() * jac +
- 2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
+ 2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
Corrector c(sq_norm, rho);
c.CorrectJacobian(3, 2, residuals, jacobian);
c.CorrectResiduals(3, residuals);
// Corrected gradient and hessian.
- c_grad = jac.transpose() * res;
+ c_grad = jac.transpose() * res;
c_hess = jac.transpose() * jac;
ASSERT_NEAR((g_res - res).norm(), 0.0, 1e-10);
@@ -236,8 +230,7 @@
srand(5);
for (int iter = 0; iter < 10000; ++iter) {
// Initialize the jacobian.
- for (int i = 0; i < 2 * 3; ++i)
- jacobian[i] = RandDouble();
+ for (int i = 0; i < 2 * 3; ++i) jacobian[i] = RandDouble();
// Zero residuals
res.setZero();
@@ -254,7 +247,7 @@
g_grad = rho[1] * jac.transpose() * res;
g_hess = rho[1] * jac.transpose() * jac +
- 2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
+ 2.0 * rho[2] * jac.transpose() * res * res.transpose() * jac;
Corrector c(sq_norm, rho);
c.CorrectJacobian(3, 2, residuals, jacobian);
diff --git a/internal/ceres/cost_function_to_functor_test.cc b/internal/ceres/cost_function_to_functor_test.cc
index 0a6d86c..11f47e3 100644
--- a/internal/ceres/cost_function_to_functor_test.cc
+++ b/internal/ceres/cost_function_to_functor_test.cc
@@ -32,9 +32,10 @@
#include <cstdint>
#include <memory>
+
+#include "ceres/autodiff_cost_function.h"
#include "ceres/dynamic_autodiff_cost_function.h"
#include "ceres/dynamic_cost_function_to_functor.h"
-#include "ceres/autodiff_cost_function.h"
#include "gtest/gtest.h"
namespace ceres {
@@ -53,8 +54,7 @@
cost_function.parameter_block_sizes();
const vector<int32_t>& actual_parameter_block_sizes =
actual_cost_function.parameter_block_sizes();
- EXPECT_EQ(parameter_block_sizes.size(),
- actual_parameter_block_sizes.size());
+ EXPECT_EQ(parameter_block_sizes.size(), actual_parameter_block_sizes.size());
int num_parameters = 0;
for (int i = 0; i < parameter_block_sizes.size(); ++i) {
@@ -68,11 +68,12 @@
}
std::unique_ptr<double[]> residuals(new double[num_residuals]);
- std::unique_ptr<double[]> jacobians(new double[num_parameters * num_residuals]);
+ std::unique_ptr<double[]> jacobians(
+ new double[num_parameters * num_residuals]);
std::unique_ptr<double[]> actual_residuals(new double[num_residuals]);
- std::unique_ptr<double[]> actual_jacobians
- (new double[num_parameters * num_residuals]);
+ std::unique_ptr<double[]> actual_jacobians(
+ new double[num_parameters * num_residuals]);
std::unique_ptr<double*[]> parameter_blocks(
new double*[parameter_block_sizes.size()]);
@@ -90,19 +91,17 @@
num_parameters += parameter_block_sizes[i];
}
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.get(),
- residuals.get(), NULL));
- EXPECT_TRUE(actual_cost_function.Evaluate(parameter_blocks.get(),
- actual_residuals.get(), NULL));
+ EXPECT_TRUE(
+ cost_function.Evaluate(parameter_blocks.get(), residuals.get(), NULL));
+ EXPECT_TRUE(actual_cost_function.Evaluate(
+ parameter_blocks.get(), actual_residuals.get(), NULL));
for (int i = 0; i < num_residuals; ++i) {
EXPECT_NEAR(residuals[i], actual_residuals[i], kTolerance)
<< "residual id: " << i;
}
-
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.get(),
- residuals.get(),
- jacobian_blocks.get()));
+ EXPECT_TRUE(cost_function.Evaluate(
+ parameter_blocks.get(), residuals.get(), jacobian_blocks.get()));
EXPECT_TRUE(actual_cost_function.Evaluate(parameter_blocks.get(),
actual_residuals.get(),
actual_jacobian_blocks.get()));
@@ -113,8 +112,8 @@
for (int i = 0; i < num_residuals * num_parameters; ++i) {
EXPECT_NEAR(jacobians[i], actual_jacobians[i], kTolerance)
- << "jacobian : " << i << " "
- << jacobians[i] << " " << actual_jacobians[i];
+ << "jacobian : " << i << " " << jacobians[i] << " "
+ << actual_jacobians[i];
}
}
@@ -132,8 +131,8 @@
public:
template <typename T>
bool operator()(const T* x1, const T* x2, T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1];
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1];
return true;
}
};
@@ -142,8 +141,8 @@
public:
template <typename T>
bool operator()(const T* x1, const T* x2, const T* x3, T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1];
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1];
return true;
}
};
@@ -151,12 +150,12 @@
struct FourParameterBlockFunctor {
public:
template <typename T>
- bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
- T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0]
- + x4[0] * x4[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1]
- + x4[1] * x4[1];
+ bool operator()(
+ const T* x1, const T* x2, const T* x3, const T* x4, T* residuals) const {
+ residuals[0] =
+ x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] + x4[0] * x4[0];
+ residuals[1] =
+ x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] + x4[1] * x4[1];
return true;
}
};
@@ -164,12 +163,16 @@
struct FiveParameterBlockFunctor {
public:
template <typename T>
- bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
- const T* x5, T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0]
- + x4[0] * x4[0] + x5[0] * x5[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1]
- + x4[1] * x4[1] + x5[1] * x5[1];
+ bool operator()(const T* x1,
+ const T* x2,
+ const T* x3,
+ const T* x4,
+ const T* x5,
+ T* residuals) const {
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+ x4[0] * x4[0] + x5[0] * x5[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+ x4[1] * x4[1] + x5[1] * x5[1];
return true;
}
};
@@ -177,12 +180,17 @@
struct SixParameterBlockFunctor {
public:
template <typename T>
- bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
- const T* x5, const T* x6, T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0]
- + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1]
- + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1];
+ bool operator()(const T* x1,
+ const T* x2,
+ const T* x3,
+ const T* x4,
+ const T* x5,
+ const T* x6,
+ T* residuals) const {
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+ x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+ x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1];
return true;
}
};
@@ -190,12 +198,20 @@
struct SevenParameterBlockFunctor {
public:
template <typename T>
- bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
- const T* x5, const T* x6, const T* x7, T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0]
- + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1]
- + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1];
+ bool operator()(const T* x1,
+ const T* x2,
+ const T* x3,
+ const T* x4,
+ const T* x5,
+ const T* x6,
+ const T* x7,
+ T* residuals) const {
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+ x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+ x7[0] * x7[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+ x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+ x7[1] * x7[1];
return true;
}
};
@@ -203,15 +219,21 @@
struct EightParameterBlockFunctor {
public:
template <typename T>
- bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
- const T* x5, const T* x6, const T* x7, const T* x8,
+ bool operator()(const T* x1,
+ const T* x2,
+ const T* x3,
+ const T* x4,
+ const T* x5,
+ const T* x6,
+ const T* x7,
+ const T* x8,
T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0]
- + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0]
- + x8[0] * x8[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1]
- + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1]
- + x8[1] * x8[1];
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+ x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+ x7[0] * x7[0] + x8[0] * x8[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+ x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+ x7[1] * x7[1] + x8[1] * x8[1];
return true;
}
};
@@ -219,15 +241,22 @@
struct NineParameterBlockFunctor {
public:
template <typename T>
- bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
- const T* x5, const T* x6, const T* x7, const T* x8,
- const T* x9, T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0]
- + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0]
- + x8[0] * x8[0] + x9[0] * x9[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1]
- + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1]
- + x8[1] * x8[1] + x9[1] * x9[1];
+ bool operator()(const T* x1,
+ const T* x2,
+ const T* x3,
+ const T* x4,
+ const T* x5,
+ const T* x6,
+ const T* x7,
+ const T* x8,
+ const T* x9,
+ T* residuals) const {
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+ x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+ x7[0] * x7[0] + x8[0] * x8[0] + x9[0] * x9[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+ x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+ x7[1] * x7[1] + x8[1] * x8[1] + x9[1] * x9[1];
return true;
}
};
@@ -235,15 +264,25 @@
struct TenParameterBlockFunctor {
public:
template <typename T>
- bool operator()(const T* x1, const T* x2, const T* x3, const T* x4,
- const T* x5, const T* x6, const T* x7, const T* x8,
- const T* x9, const T* x10, T* residuals) const {
- residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0]
- + x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] + x7[0] * x7[0]
- + x8[0] * x8[0] + x9[0] * x9[0] + x10[0] * x10[0];
- residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1]
- + x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] + x7[1] * x7[1]
- + x8[1] * x8[1] + x9[1] * x9[1] + x10[1] * x10[1];
+ bool operator()(const T* x1,
+ const T* x2,
+ const T* x3,
+ const T* x4,
+ const T* x5,
+ const T* x6,
+ const T* x7,
+ const T* x8,
+ const T* x9,
+ const T* x10,
+ T* residuals) const {
+ residuals[0] = x1[0] * x1[0] + x2[0] * x2[0] + x3[0] * x3[0] +
+ x4[0] * x4[0] + x5[0] * x5[0] + x6[0] * x6[0] +
+ x7[0] * x7[0] + x8[0] * x8[0] + x9[0] * x9[0] +
+ x10[0] * x10[0];
+ residuals[1] = x1[1] * x1[1] + x2[1] * x2[1] + x3[1] * x3[1] +
+ x4[1] * x4[1] + x5[1] * x5[1] + x6[1] * x6[1] +
+ x7[1] * x7[1] + x8[1] * x8[1] + x9[1] * x9[1] +
+ x10[1] * x10[1];
return true;
}
};
@@ -281,39 +320,39 @@
TEST_BODY(OneParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2
+#define PARAMETER_BLOCK_SIZES 2, 2
TEST_BODY(TwoParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2
TEST_BODY(ThreeParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2
TEST_BODY(FourParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2
TEST_BODY(FiveParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2
TEST_BODY(SixParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2
TEST_BODY(SevenParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2, 2
TEST_BODY(EightParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2, 2, 2
TEST_BODY(NineParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
-#define PARAMETER_BLOCK_SIZES 2,2,2,2,2,2,2,2,2,2
+#define PARAMETER_BLOCK_SIZES 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
TEST_BODY(TenParameterBlockFunctor)
#undef PARAMETER_BLOCK_SIZES
@@ -321,14 +360,17 @@
TEST(CostFunctionToFunctor, DynamicNumberOfResiduals) {
std::unique_ptr<CostFunction> cost_function(
- new AutoDiffCostFunction<
- CostFunctionToFunctor<ceres::DYNAMIC, 2, 2 >, ceres::DYNAMIC, 2, 2>(
- new CostFunctionToFunctor<ceres::DYNAMIC, 2, 2 >(
- new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2 >(
- new TwoParameterBlockFunctor)), 2));
+ new AutoDiffCostFunction<CostFunctionToFunctor<ceres::DYNAMIC, 2, 2>,
+ ceres::DYNAMIC,
+ 2,
+ 2>(
+ new CostFunctionToFunctor<ceres::DYNAMIC, 2, 2>(
+ new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2>(
+ new TwoParameterBlockFunctor)),
+ 2));
std::unique_ptr<CostFunction> actual_cost_function(
- new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2 >(
+ new AutoDiffCostFunction<TwoParameterBlockFunctor, 2, 2, 2>(
new TwoParameterBlockFunctor));
ExpectCostFunctionsAreEqual(*cost_function, *actual_cost_function);
}
@@ -336,8 +378,8 @@
TEST(CostFunctionToFunctor, DynamicCostFunctionToFunctor) {
DynamicAutoDiffCostFunction<DynamicTwoParameterBlockFunctor>*
actual_cost_function(
- new DynamicAutoDiffCostFunction<DynamicTwoParameterBlockFunctor>(
- new DynamicTwoParameterBlockFunctor));
+ new DynamicAutoDiffCostFunction<DynamicTwoParameterBlockFunctor>(
+ new DynamicTwoParameterBlockFunctor));
actual_cost_function->AddParameterBlock(2);
actual_cost_function->AddParameterBlock(2);
actual_cost_function->SetNumResiduals(2);
diff --git a/internal/ceres/covariance.cc b/internal/ceres/covariance.cc
index 8256078..8e240ff 100644
--- a/internal/ceres/covariance.cc
+++ b/internal/ceres/covariance.cc
@@ -32,6 +32,7 @@
#include <utility>
#include <vector>
+
#include "ceres/covariance_impl.h"
#include "ceres/problem.h"
#include "ceres/problem_impl.h"
@@ -46,8 +47,7 @@
impl_.reset(new internal::CovarianceImpl(options));
}
-Covariance::~Covariance() {
-}
+Covariance::~Covariance() {}
bool Covariance::Compute(
const vector<pair<const double*, const double*>>& covariance_blocks,
@@ -55,9 +55,8 @@
return impl_->Compute(covariance_blocks, problem->impl_.get());
}
-bool Covariance::Compute(
- const vector<const double*>& parameter_blocks,
- Problem* problem) {
+bool Covariance::Compute(const vector<const double*>& parameter_blocks,
+ Problem* problem) {
return impl_->Compute(parameter_blocks, problem->impl_.get());
}
@@ -89,8 +88,8 @@
}
bool Covariance::GetCovarianceMatrixInTangentSpace(
- const std::vector<const double *>& parameter_blocks,
- double *covariance_matrix) const {
+ const std::vector<const double*>& parameter_blocks,
+ double* covariance_matrix) const {
return impl_->GetCovarianceMatrixInTangentOrAmbientSpace(parameter_blocks,
false, // tangent
covariance_matrix);
diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 34a36c6..229173f 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -31,8 +31,8 @@
#include "ceres/covariance.h"
#include <algorithm>
-#include <cstdint>
#include <cmath>
+#include <cstdint>
#include <map>
#include <memory>
#include <utility>
@@ -54,7 +54,7 @@
using std::pair;
using std::vector;
-class UnaryCostFunction: public CostFunction {
+class UnaryCostFunction : public CostFunction {
public:
UnaryCostFunction(const int num_residuals,
const int32_t parameter_block_size,
@@ -86,8 +86,7 @@
vector<double> jacobian_;
};
-
-class BinaryCostFunction: public CostFunction {
+class BinaryCostFunction : public CostFunction {
public:
BinaryCostFunction(const int num_residuals,
const int32_t parameter_block1_size,
@@ -193,6 +192,7 @@
// . . . . . . X X X X
// . . . . . . X X X X
+ // clang-format off
int expected_rows[] = {0, 5, 10, 15, 18, 21, 24, 28, 32, 36, 40};
int expected_cols[] = {0, 6, 7, 8, 9,
1, 2, 3, 4, 5,
@@ -204,7 +204,7 @@
6, 7, 8, 9,
6, 7, 8, 9,
6, 7, 8, 9};
-
+ // clang-format on
vector<pair<const double*, const double*>> covariance_blocks;
covariance_blocks.push_back(make_pair(block1, block1));
@@ -216,8 +216,8 @@
Covariance::Options options;
CovarianceImpl covariance_impl(options);
- EXPECT_TRUE(covariance_impl
- .ComputeCovarianceSparsity(covariance_blocks, &problem));
+ EXPECT_TRUE(
+ covariance_impl.ComputeCovarianceSparsity(covariance_blocks, &problem));
const CompressedRowSparseMatrix* crsm = covariance_impl.covariance_matrix();
@@ -228,17 +228,13 @@
const int* rows = crsm->rows();
for (int r = 0; r < crsm->num_rows() + 1; ++r) {
EXPECT_EQ(rows[r], expected_rows[r])
- << r << " "
- << rows[r] << " "
- << expected_rows[r];
+ << r << " " << rows[r] << " " << expected_rows[r];
}
const int* cols = crsm->cols();
for (int c = 0; c < crsm->num_nonzeros(); ++c) {
EXPECT_EQ(cols[c], expected_cols[c])
- << c << " "
- << cols[c] << " "
- << expected_cols[c];
+ << c << " " << cols[c] << " " << expected_cols[c];
}
}
@@ -280,6 +276,7 @@
// . . . X X X X
// . . . X X X X
+ // clang-format off
int expected_rows[] = {0, 5, 7, 9, 13, 17, 21, 25};
int expected_cols[] = {0, 3, 4, 5, 6,
1, 2,
@@ -288,6 +285,7 @@
3, 4, 5, 6,
3, 4, 5, 6,
3, 4, 5, 6};
+ // clang-format on
vector<pair<const double*, const double*>> covariance_blocks;
covariance_blocks.push_back(make_pair(block1, block1));
@@ -299,8 +297,8 @@
Covariance::Options options;
CovarianceImpl covariance_impl(options);
- EXPECT_TRUE(covariance_impl
- .ComputeCovarianceSparsity(covariance_blocks, &problem));
+ EXPECT_TRUE(
+ covariance_impl.ComputeCovarianceSparsity(covariance_blocks, &problem));
const CompressedRowSparseMatrix* crsm = covariance_impl.covariance_matrix();
@@ -311,17 +309,13 @@
const int* rows = crsm->rows();
for (int r = 0; r < crsm->num_rows() + 1; ++r) {
EXPECT_EQ(rows[r], expected_rows[r])
- << r << " "
- << rows[r] << " "
- << expected_rows[r];
+ << r << " " << rows[r] << " " << expected_rows[r];
}
const int* cols = crsm->cols();
for (int c = 0; c < crsm->num_nonzeros(); ++c) {
EXPECT_EQ(cols[c], expected_cols[c])
- << c << " "
- << cols[c] << " "
- << expected_cols[c];
+ << c << " " << cols[c] << " " << expected_cols[c];
}
}
@@ -361,6 +355,7 @@
// . . . X X X X
// . . . X X X X
+ // clang-format off
int expected_rows[] = {0, 5, 7, 9, 13, 17, 21, 25};
int expected_cols[] = {0, 3, 4, 5, 6,
1, 2,
@@ -369,6 +364,7 @@
3, 4, 5, 6,
3, 4, 5, 6,
3, 4, 5, 6};
+ // clang-format on
vector<pair<const double*, const double*>> covariance_blocks;
covariance_blocks.push_back(make_pair(block1, block1));
@@ -380,8 +376,8 @@
Covariance::Options options;
CovarianceImpl covariance_impl(options);
- EXPECT_TRUE(covariance_impl
- .ComputeCovarianceSparsity(covariance_blocks, &problem));
+ EXPECT_TRUE(
+ covariance_impl.ComputeCovarianceSparsity(covariance_blocks, &problem));
const CompressedRowSparseMatrix* crsm = covariance_impl.covariance_matrix();
@@ -392,17 +388,13 @@
const int* rows = crsm->rows();
for (int r = 0; r < crsm->num_rows() + 1; ++r) {
EXPECT_EQ(rows[r], expected_rows[r])
- << r << " "
- << rows[r] << " "
- << expected_rows[r];
+ << r << " " << rows[r] << " " << expected_rows[r];
}
const int* cols = crsm->cols();
for (int c = 0; c < crsm->num_nonzeros(); ++c) {
EXPECT_EQ(cols[c], expected_cols[c])
- << c << " "
- << cols[c] << " "
- << expected_cols[c];
+ << c << " " << cols[c] << " " << expected_cols[c];
}
}
@@ -423,40 +415,33 @@
z[0] = 3;
{
- double jacobian[] = { 1.0, 0.0, 0.0, 1.0};
+ double jacobian[] = {1.0, 0.0, 0.0, 1.0};
problem_.AddResidualBlock(new UnaryCostFunction(2, 2, jacobian), NULL, x);
}
{
- double jacobian[] = { 2.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 2.0 };
+ double jacobian[] = {2.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 2.0};
problem_.AddResidualBlock(new UnaryCostFunction(3, 3, jacobian), NULL, y);
}
{
double jacobian = 5.0;
- problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian),
- NULL,
- z);
+ problem_.AddResidualBlock(
+ new UnaryCostFunction(1, 1, &jacobian), NULL, z);
}
{
- double jacobian1[] = { 1.0, 2.0, 3.0 };
- double jacobian2[] = { -5.0, -6.0 };
+ double jacobian1[] = {1.0, 2.0, 3.0};
+ double jacobian2[] = {-5.0, -6.0};
problem_.AddResidualBlock(
- new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2),
- NULL,
- y,
- x);
+ new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2), NULL, y, x);
}
{
- double jacobian1[] = {2.0 };
- double jacobian2[] = { 3.0, -2.0 };
+ double jacobian1[] = {2.0};
+ double jacobian2[] = {3.0, -2.0};
problem_.AddResidualBlock(
- new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2),
- NULL,
- z,
- x);
+ new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2), NULL, z, x);
}
all_covariance_blocks_.push_back(make_pair(x, x));
@@ -482,8 +467,7 @@
// Computes covariance in tangent space.
void ComputeAndCompareCovarianceBlocksInTangentSpace(
- const Covariance::Options& options,
- const double* expected_covariance) {
+ const Covariance::Options& options, const double* expected_covariance) {
ComputeAndCompareCovarianceBlocksInTangentOrAmbientSpace(
options,
false, // tangent
@@ -549,8 +533,9 @@
bool lift_covariance_to_ambient_space,
const Covariance& covariance,
const double* expected_covariance) {
- const BoundsMap& column_bounds = lift_covariance_to_ambient_space ?
- column_bounds_ : local_column_bounds_;
+ const BoundsMap& column_bounds = lift_covariance_to_ambient_space
+ ? column_bounds_
+ : local_column_bounds_;
const int row_begin = FindOrDie(column_bounds, block1).first;
const int row_end = FindOrDie(column_bounds, block1).second;
const int col_begin = FindOrDie(column_bounds, block2).first;
@@ -558,13 +543,10 @@
Matrix actual(row_end - row_begin, col_end - col_begin);
if (lift_covariance_to_ambient_space) {
- EXPECT_TRUE(covariance.GetCovarianceBlock(block1,
- block2,
- actual.data()));
+ EXPECT_TRUE(covariance.GetCovarianceBlock(block1, block2, actual.data()));
} else {
- EXPECT_TRUE(covariance.GetCovarianceBlockInTangentSpace(block1,
- block2,
- actual.data()));
+ EXPECT_TRUE(covariance.GetCovarianceBlockInTangentSpace(
+ block1, block2, actual.data()));
}
int dof = 0; // degrees of freedom = sum of LocalSize()s
@@ -572,22 +554,22 @@
dof = std::max(dof, bound.second.second);
}
ConstMatrixRef expected(expected_covariance, dof, dof);
- double diff_norm = (expected.block(row_begin,
- col_begin,
- row_end - row_begin,
- col_end - col_begin) - actual).norm();
+ double diff_norm =
+ (expected.block(
+ row_begin, col_begin, row_end - row_begin, col_end - col_begin) -
+ actual)
+ .norm();
diff_norm /= (row_end - row_begin) * (col_end - col_begin);
const double kTolerance = 1e-5;
EXPECT_NEAR(diff_norm, 0.0, kTolerance)
<< "rows: " << row_begin << " " << row_end << " "
<< "cols: " << col_begin << " " << col_end << " "
- << "\n\n expected: \n " << expected.block(row_begin,
- col_begin,
- row_end - row_begin,
- col_end - col_begin)
- << "\n\n actual: \n " << actual
- << "\n\n full expected: \n" << expected;
+ << "\n\n expected: \n "
+ << expected.block(
+ row_begin, col_begin, row_end - row_begin, col_end - col_begin)
+ << "\n\n actual: \n " << actual << "\n\n full expected: \n"
+ << expected;
}
double parameters_[6];
@@ -597,7 +579,6 @@
BoundsMap local_column_bounds_;
};
-
TEST_F(CovarianceTest, NormalBehavior) {
// J
//
@@ -620,6 +601,7 @@
// 6 -4 0 0 0 29
// inv(J'J) computed using octave.
+ // clang-format off
double expected_covariance[] = {
7.0747e-02, -8.4923e-03, 1.6821e-02, 3.3643e-02, 5.0464e-02, -1.5809e-02, // NOLINT
-8.4923e-03, 8.1352e-02, 2.4758e-02, 4.9517e-02, 7.4275e-02, 1.2978e-02, // NOLINT
@@ -628,6 +610,7 @@
5.0464e-02, 7.4275e-02, -2.8906e-03, -5.7813e-03, 2.4133e-01, -1.9598e-04, // NOLINT
-1.5809e-02, 1.2978e-02, -6.5325e-05, -1.3065e-04, -1.9598e-04, 3.9544e-02, // NOLINT
};
+ // clang-format on
Covariance::Options options;
@@ -669,6 +652,7 @@
// 6 -4 0 0 0 29
// inv(J'J) computed using octave.
+ // clang-format off
double expected_covariance[] = {
7.0747e-02, -8.4923e-03, 1.6821e-02, 3.3643e-02, 5.0464e-02, -1.5809e-02, // NOLINT
-8.4923e-03, 8.1352e-02, 2.4758e-02, 4.9517e-02, 7.4275e-02, 1.2978e-02, // NOLINT
@@ -677,6 +661,7 @@
5.0464e-02, 7.4275e-02, -2.8906e-03, -5.7813e-03, 2.4133e-01, -1.9598e-04, // NOLINT
-1.5809e-02, 1.2978e-02, -6.5325e-05, -1.3065e-04, -1.9598e-04, 3.9544e-02, // NOLINT
};
+ // clang-format on
Covariance::Options options;
options.num_threads = 4;
@@ -721,6 +706,7 @@
// 0 0 0 0 0 29
// pinv(J'J) computed using octave.
+ // clang-format off
double expected_covariance[] = {
0, 0, 0, 0, 0, 0, // NOLINT
0, 0, 0, 0, 0, 0, // NOLINT
@@ -728,6 +714,7 @@
0, 0, -0.02778, 0.19444, -0.08333, -0.00000, // NOLINT
0, 0, -0.04167, -0.08333, 0.12500, -0.00000, // NOLINT
0, 0, -0.00000, -0.00000, -0.00000, 0.03448 // NOLINT
+ // clang-format on
};
Covariance::Options options;
@@ -778,6 +765,7 @@
// A * inv((J*A)'*(J*A)) * A'
// Computed using octave.
+ // clang-format off
double expected_covariance[] = {
0.01766, 0.01766, 0.02158, 0.04316, 0.00000, -0.00122,
0.01766, 0.01766, 0.02158, 0.04316, 0.00000, -0.00122,
@@ -786,6 +774,7 @@
0.00000, 0.00000, 0.00000, 0.00000, 0.00000, 0.00000,
-0.00122, -0.00122, -0.00149, -0.00298, 0.00000, 0.03457
};
+ // clang-format on
Covariance::Options options;
@@ -840,12 +829,14 @@
// inv((J*A)'*(J*A))
// Computed using octave.
+ // clang-format off
double expected_covariance[] = {
0.01766, 0.02158, 0.04316, -0.00122,
0.02158, 0.24860, -0.00281, -0.00149,
0.04316, -0.00281, 0.24439, -0.00298,
-0.00122, -0.00149, -0.00298, 0.03457 // NOLINT
};
+ // clang-format on
Covariance::Options options;
@@ -903,12 +894,14 @@
// pinv((J*A)'*(J*A))
// Computed using octave.
+ // clang-format off
double expected_covariance[] = {
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.034482 // NOLINT
};
+ // clang-format on
Covariance::Options options;
@@ -951,6 +944,7 @@
// 3.4142 is the smallest eigen value of J'J. The following matrix
// was obtained by dropping the eigenvector corresponding to this
// eigenvalue.
+ // clang-format off
double expected_covariance[] = {
5.4135e-02, -3.5121e-02, 1.7257e-04, 3.4514e-04, 5.1771e-04, -1.6076e-02, // NOLINT
-3.5121e-02, 3.8667e-02, -1.9288e-03, -3.8576e-03, -5.7864e-03, 1.2549e-02, // NOLINT
@@ -959,7 +953,7 @@
5.1771e-04, -5.7864e-03, -5.2946e-02, -1.0589e-01, 9.1162e-02, -9.9988e-04, // NOLINT
-1.6076e-02, 1.2549e-02, -3.3329e-04, -6.6659e-04, -9.9988e-04, 3.9539e-02 // NOLINT
};
-
+ // clang-format on
{
Covariance::Options options;
@@ -1109,40 +1103,33 @@
double* z = y + 3;
{
- double jacobian[] = { 1.0, 0.0, 0.0, 1.0};
+ double jacobian[] = {1.0, 0.0, 0.0, 1.0};
problem_.AddResidualBlock(new UnaryCostFunction(2, 2, jacobian), NULL, x);
}
{
- double jacobian[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+ double jacobian[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
problem_.AddResidualBlock(new UnaryCostFunction(3, 3, jacobian), NULL, y);
}
{
double jacobian = 5.0;
- problem_.AddResidualBlock(new UnaryCostFunction(1, 1, &jacobian),
- NULL,
- z);
+ problem_.AddResidualBlock(
+ new UnaryCostFunction(1, 1, &jacobian), NULL, z);
}
{
- double jacobian1[] = { 0.0, 0.0, 0.0 };
- double jacobian2[] = { -5.0, -6.0 };
+ double jacobian1[] = {0.0, 0.0, 0.0};
+ double jacobian2[] = {-5.0, -6.0};
problem_.AddResidualBlock(
- new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2),
- NULL,
- y,
- x);
+ new BinaryCostFunction(1, 3, 2, jacobian1, jacobian2), NULL, y, x);
}
{
- double jacobian1[] = {2.0 };
- double jacobian2[] = { 3.0, -2.0 };
+ double jacobian1[] = {2.0};
+ double jacobian2[] = {3.0, -2.0};
problem_.AddResidualBlock(
- new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2),
- NULL,
- z,
- x);
+ new BinaryCostFunction(1, 1, 2, jacobian1, jacobian2), NULL, z, x);
}
all_covariance_blocks_.push_back(make_pair(x, x));
@@ -1180,6 +1167,7 @@
// 6 -4 0 0 0 29
// pinv(J'J) computed using octave.
+ // clang-format off
double expected_covariance[] = {
0.053998, -0.033145, 0.000000, 0.000000, 0.000000, -0.015744,
-0.033145, 0.045067, 0.000000, 0.000000, 0.000000, 0.013074,
@@ -1188,6 +1176,7 @@
0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
-0.015744, 0.013074, 0.000000, 0.000000, 0.000000, 0.039543
};
+ // clang-format on
Covariance::Options options;
options.algorithm_type = DENSE_SVD;
@@ -1290,11 +1279,11 @@
jacobian *= (i + 1);
double* block_i = parameters_.get() + i * parameter_block_size_;
- problem_.AddResidualBlock(new UnaryCostFunction(parameter_block_size_,
- parameter_block_size_,
- jacobian.data()),
- NULL,
- block_i);
+ problem_.AddResidualBlock(
+ new UnaryCostFunction(
+ parameter_block_size_, parameter_block_size_, jacobian.data()),
+ NULL,
+ block_i);
for (int j = i; j < num_parameter_blocks_; ++j) {
double* block_j = parameters_.get() + j * parameter_block_size_;
all_covariance_blocks_.push_back(make_pair(block_i, block_j));
@@ -1326,8 +1315,10 @@
covariance.GetCovarianceBlock(block_i, block_i, actual.data());
EXPECT_NEAR((expected - actual).norm(), 0.0, kTolerance)
<< "block: " << i << ", " << i << "\n"
- << "expected: \n" << expected << "\n"
- << "actual: \n" << actual;
+ << "expected: \n"
+ << expected << "\n"
+ << "actual: \n"
+ << actual;
expected.setZero();
for (int j = i + 1; j < num_parameter_blocks_; ++j) {
@@ -1335,8 +1326,10 @@
covariance.GetCovarianceBlock(block_i, block_j, actual.data());
EXPECT_NEAR((expected - actual).norm(), 0.0, kTolerance)
<< "block: " << i << ", " << j << "\n"
- << "expected: \n" << expected << "\n"
- << "actual: \n" << actual;
+ << "expected: \n"
+ << expected << "\n"
+ << "actual: \n"
+ << actual;
}
}
}
diff --git a/internal/ceres/cubic_interpolation_test.cc b/internal/ceres/cubic_interpolation_test.cc
index 4cf27ff..3907d22 100644
--- a/internal/ceres/cubic_interpolation_test.cc
+++ b/internal/ceres/cubic_interpolation_test.cc
@@ -31,6 +31,7 @@
#include "ceres/cubic_interpolation.h"
#include <memory>
+
#include "ceres/jet.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
@@ -65,9 +66,11 @@
}
TEST(Grid1D, TwoDataDimensionIntegerDataInterleaved) {
+ // clang-format off
int x[] = {1, 5,
2, 6,
3, 7};
+ // clang-format on
Grid1D<int, 2, true> grid(x, 0, 3);
for (int i = 0; i < 3; ++i) {
@@ -78,10 +81,11 @@
}
}
-
TEST(Grid1D, TwoDataDimensionIntegerDataStacked) {
+ // clang-format off
int x[] = {1, 2, 3,
5, 6, 7};
+ // clang-format on
Grid1D<int, 2, false> grid(x, 0, 3);
for (int i = 0; i < 3; ++i) {
@@ -93,8 +97,10 @@
}
TEST(Grid2D, OneDataDimensionRowMajor) {
+ // clang-format off
int x[] = {1, 2, 3,
2, 3, 4};
+ // clang-format on
Grid2D<int, 1, true, true> grid(x, 0, 2, 0, 3);
for (int r = 0; r < 2; ++r) {
for (int c = 0; c < 3; ++c) {
@@ -106,8 +112,10 @@
}
TEST(Grid2D, OneDataDimensionRowMajorOutOfBounds) {
+ // clang-format off
int x[] = {1, 2, 3,
2, 3, 4};
+ // clang-format on
Grid2D<int, 1, true, true> grid(x, 0, 2, 0, 3);
double value;
grid.GetValue(-1, -1, &value);
@@ -141,64 +149,72 @@
}
TEST(Grid2D, TwoDataDimensionRowMajorInterleaved) {
+ // clang-format off
int x[] = {1, 4, 2, 8, 3, 12,
2, 8, 3, 12, 4, 16};
+ // clang-format on
Grid2D<int, 2, true, true> grid(x, 0, 2, 0, 3);
for (int r = 0; r < 2; ++r) {
for (int c = 0; c < 3; ++c) {
double value[2];
grid.GetValue(r, c, value);
EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
- EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+ EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
}
}
}
TEST(Grid2D, TwoDataDimensionRowMajorStacked) {
+ // clang-format off
int x[] = {1, 2, 3,
2, 3, 4,
4, 8, 12,
8, 12, 16};
+ // clang-format on
Grid2D<int, 2, true, false> grid(x, 0, 2, 0, 3);
for (int r = 0; r < 2; ++r) {
for (int c = 0; c < 3; ++c) {
double value[2];
grid.GetValue(r, c, value);
EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
- EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+ EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
}
}
}
TEST(Grid2D, TwoDataDimensionColMajorInterleaved) {
+ // clang-format off
int x[] = { 1, 4, 2, 8,
2, 8, 3, 12,
3, 12, 4, 16};
+ // clang-format on
Grid2D<int, 2, false, true> grid(x, 0, 2, 0, 3);
for (int r = 0; r < 2; ++r) {
for (int c = 0; c < 3; ++c) {
double value[2];
grid.GetValue(r, c, value);
EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
- EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+ EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
}
}
}
TEST(Grid2D, TwoDataDimensionColMajorStacked) {
+ // clang-format off
int x[] = {1, 2,
2, 3,
3, 4,
4, 8,
8, 12,
12, 16};
+ // clang-format on
Grid2D<int, 2, false, false> grid(x, 0, 2, 0, 3);
for (int r = 0; r < 2; ++r) {
for (int c = 0; c < 3; ++c) {
double value[2];
grid.GetValue(r, c, value);
EXPECT_EQ(value[0], static_cast<double>(r + c + 1));
- EXPECT_EQ(value[1], static_cast<double>(4 *(r + c + 1)));
+ EXPECT_EQ(value[1], static_cast<double>(4 * (r + c + 1)));
}
}
}
@@ -214,8 +230,8 @@
for (int x = 0; x < kNumSamples; ++x) {
for (int dim = 0; dim < kDataDimension; ++dim) {
- values_[x * kDataDimension + dim] =
- (dim * dim + 1) * (a * x * x * x + b * x * x + c * x + d);
+ values_[x * kDataDimension + dim] =
+ (dim * dim + 1) * (a * x * x * x + b * x * x + c * x + d);
}
}
@@ -236,8 +252,9 @@
for (int dim = 0; dim < kDataDimension; ++dim) {
expected_f[dim] =
- (dim * dim + 1) * (a * x * x * x + b * x * x + c * x + d);
- expected_dfdx[dim] = (dim * dim + 1) * (3.0 * a * x * x + 2.0 * b * x + c);
+ (dim * dim + 1) * (a * x * x * x + b * x * x + c * x + d);
+ expected_dfdx[dim] =
+ (dim * dim + 1) * (3.0 * a * x * x + 2.0 * b * x + c);
}
interpolator.Evaluate(x, f, dfdx);
@@ -278,7 +295,6 @@
RunPolynomialInterpolationTest<3>(0.0, 0.4, 1.0, 0.5);
}
-
TEST(CubicInterpolator, JetEvaluation) {
const double values[] = {1.0, 2.0, 2.0, 5.0, 3.0, 9.0, 2.0, 7.0};
@@ -330,7 +346,8 @@
}
}
- Grid2D<double, kDataDimension> grid(values_.get(), 0, kNumRows, 0, kNumCols);
+ Grid2D<double, kDataDimension> grid(
+ values_.get(), 0, kNumRows, 0, kNumCols);
BiCubicInterpolator<Grid2D<double, kDataDimension>> interpolator(grid);
for (int j = 0; j < kNumRowSamples; ++j) {
@@ -341,8 +358,10 @@
interpolator.Evaluate(r, c, f, dfdr, dfdc);
for (int dim = 0; dim < kDataDimension; ++dim) {
EXPECT_NEAR(f[dim], (dim * dim + 1) * EvaluateF(r, c), kTolerance);
- EXPECT_NEAR(dfdr[dim], (dim * dim + 1) * EvaluatedFdr(r, c), kTolerance);
- EXPECT_NEAR(dfdc[dim], (dim * dim + 1) * EvaluatedFdc(r, c), kTolerance);
+ EXPECT_NEAR(
+ dfdr[dim], (dim * dim + 1) * EvaluatedFdr(r, c), kTolerance);
+ EXPECT_NEAR(
+ dfdc[dim], (dim * dim + 1) * EvaluatedFdc(r, c), kTolerance);
}
}
}
@@ -373,7 +392,6 @@
return (coeff_.row(1) + coeff_.col(1).transpose()) * x;
}
-
Eigen::Matrix3d coeff_;
static constexpr int kNumRows = 10;
static constexpr int kNumCols = 10;
@@ -471,8 +489,10 @@
}
TEST(BiCubicInterpolator, JetEvaluation) {
+ // clang-format off
const double values[] = {1.0, 5.0, 2.0, 10.0, 2.0, 6.0, 3.0, 5.0,
1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 3.0, 1.0};
+ // clang-format on
Grid2D<double, 2> grid(values, 0, 2, 0, 4);
BiCubicInterpolator<Grid2D<double, 2>> interpolator(grid);
diff --git a/internal/ceres/cxsparse.cc b/internal/ceres/cxsparse.cc
index 5a02877..0167f98 100644
--- a/internal/ceres/cxsparse.cc
+++ b/internal/ceres/cxsparse.cc
@@ -33,13 +33,12 @@
#ifndef CERES_NO_CXSPARSE
-#include "ceres/cxsparse.h"
-
#include <string>
#include <vector>
#include "ceres/compressed_col_sparse_matrix_utils.h"
#include "ceres/compressed_row_sparse_matrix.h"
+#include "ceres/cxsparse.h"
#include "ceres/triplet_sparse_matrix.h"
#include "glog/logging.h"
diff --git a/internal/ceres/cxsparse.h b/internal/ceres/cxsparse.h
index dc4740c..d3f76e0 100644
--- a/internal/ceres/cxsparse.h
+++ b/internal/ceres/cxsparse.h
@@ -166,7 +166,7 @@
} // namespace internal
} // namespace ceres
-#else // CERES_NO_CXSPARSE
+#else
typedef void cs_dis;
diff --git a/internal/ceres/dense_jacobian_writer.h b/internal/ceres/dense_jacobian_writer.h
index 1b04f38..28c60e2 100644
--- a/internal/ceres/dense_jacobian_writer.h
+++ b/internal/ceres/dense_jacobian_writer.h
@@ -35,21 +35,19 @@
#include "ceres/casts.h"
#include "ceres/dense_sparse_matrix.h"
+#include "ceres/internal/eigen.h"
#include "ceres/parameter_block.h"
#include "ceres/program.h"
#include "ceres/residual_block.h"
#include "ceres/scratch_evaluate_preparer.h"
-#include "ceres/internal/eigen.h"
namespace ceres {
namespace internal {
class DenseJacobianWriter {
public:
- DenseJacobianWriter(Evaluator::Options /* ignored */,
- Program* program)
- : program_(program) {
- }
+ DenseJacobianWriter(Evaluator::Options /* ignored */, Program* program)
+ : program_(program) {}
// JacobianWriter interface.
@@ -61,14 +59,13 @@
}
SparseMatrix* CreateJacobian() const {
- return new DenseSparseMatrix(program_->NumResiduals(),
- program_->NumEffectiveParameters(),
- true);
+ return new DenseSparseMatrix(
+ program_->NumResiduals(), program_->NumEffectiveParameters(), true);
}
void Write(int residual_id,
int residual_offset,
- double **jacobians,
+ double** jacobians,
SparseMatrix* jacobian) {
DenseSparseMatrix* dense_jacobian = down_cast<DenseSparseMatrix*>(jacobian);
const ResidualBlock* residual_block =
@@ -86,15 +83,14 @@
}
const int parameter_block_size = parameter_block->LocalSize();
- ConstMatrixRef parameter_jacobian(jacobians[j],
- num_residuals,
- parameter_block_size);
+ ConstMatrixRef parameter_jacobian(
+ jacobians[j], num_residuals, parameter_block_size);
- dense_jacobian->mutable_matrix().block(
- residual_offset,
- parameter_block->delta_offset(),
- num_residuals,
- parameter_block_size) = parameter_jacobian;
+ dense_jacobian->mutable_matrix().block(residual_offset,
+ parameter_block->delta_offset(),
+ num_residuals,
+ parameter_block_size) =
+ parameter_jacobian;
}
}
diff --git a/internal/ceres/dense_linear_solver_test.cc b/internal/ceres/dense_linear_solver_test.cc
index 4de745f..3929a6f 100644
--- a/internal/ceres/dense_linear_solver_test.cc
+++ b/internal/ceres/dense_linear_solver_test.cc
@@ -29,6 +29,7 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include <memory>
+
#include "ceres/casts.h"
#include "ceres/context_impl.h"
#include "ceres/linear_least_squares_problems.h"
diff --git a/internal/ceres/dense_normal_cholesky_solver.cc b/internal/ceres/dense_normal_cholesky_solver.cc
index fe7d931..51c6390 100644
--- a/internal/ceres/dense_normal_cholesky_solver.cc
+++ b/internal/ceres/dense_normal_cholesky_solver.cc
@@ -132,13 +132,8 @@
//
// Note: This is a bit delicate, it assumes that the stride on this
// matrix is the same as the number of rows.
- BLAS::SymmetricRankKUpdate(A->num_rows(),
- num_cols,
- A->values(),
- true,
- 1.0,
- 0.0,
- lhs.data());
+ BLAS::SymmetricRankKUpdate(
+ A->num_rows(), num_cols, A->values(), true, 1.0, 0.0, lhs.data());
if (per_solve_options.D != NULL) {
// Undo the modifications to the matrix A.
@@ -153,13 +148,10 @@
LinearSolver::Summary summary;
summary.num_iterations = 1;
- summary.termination_type =
- LAPACK::SolveInPlaceUsingCholesky(num_cols,
- lhs.data(),
- x,
- &summary.message);
+ summary.termination_type = LAPACK::SolveInPlaceUsingCholesky(
+ num_cols, lhs.data(), x, &summary.message);
event_logger.AddEvent("Solve");
return summary;
}
-} // namespace internal
-} // namespace ceres
+} // namespace internal
+} // namespace ceres
diff --git a/internal/ceres/dense_normal_cholesky_solver.h b/internal/ceres/dense_normal_cholesky_solver.h
index 976718e..68ea611 100644
--- a/internal/ceres/dense_normal_cholesky_solver.h
+++ b/internal/ceres/dense_normal_cholesky_solver.h
@@ -73,7 +73,7 @@
// library. This solver always returns a solution, it is the user's
// responsibility to judge if the solution is good enough for their
// purposes.
-class DenseNormalCholeskySolver: public DenseSparseMatrixSolver {
+class DenseNormalCholeskySolver : public DenseSparseMatrixSolver {
public:
explicit DenseNormalCholeskySolver(const LinearSolver::Options& options);
diff --git a/internal/ceres/dense_qr_solver.cc b/internal/ceres/dense_qr_solver.cc
index 161e9c6..44388f3 100644
--- a/internal/ceres/dense_qr_solver.cc
+++ b/internal/ceres/dense_qr_solver.cc
@@ -31,6 +31,7 @@
#include "ceres/dense_qr_solver.h"
#include <cstddef>
+
#include "Eigen/Dense"
#include "ceres/dense_sparse_matrix.h"
#include "ceres/internal/eigen.h"
@@ -77,7 +78,7 @@
// TODO(sameeragarwal): Since we are copying anyways, the diagonal
// can be appended to the matrix instead of doing it on A.
- lhs_ = A->matrix();
+ lhs_ = A->matrix();
if (per_solve_options.D != NULL) {
// Undo the modifications to the matrix A.
@@ -164,5 +165,5 @@
return summary;
}
-} // namespace internal
-} // namespace ceres
+} // namespace internal
+} // namespace ceres
diff --git a/internal/ceres/dense_qr_solver.h b/internal/ceres/dense_qr_solver.h
index 9ea959d..a30cd1c 100644
--- a/internal/ceres/dense_qr_solver.h
+++ b/internal/ceres/dense_qr_solver.h
@@ -32,8 +32,8 @@
#ifndef CERES_INTERNAL_DENSE_QR_SOLVER_H_
#define CERES_INTERNAL_DENSE_QR_SOLVER_H_
-#include "ceres/linear_solver.h"
#include "ceres/internal/eigen.h"
+#include "ceres/linear_solver.h"
namespace ceres {
namespace internal {
@@ -78,7 +78,7 @@
// library. This solver always returns a solution, it is the user's
// responsibility to judge if the solution is good enough for their
// purposes.
-class DenseQRSolver: public DenseSparseMatrixSolver {
+class DenseQRSolver : public DenseSparseMatrixSolver {
public:
explicit DenseQRSolver(const LinearSolver::Options& options);
diff --git a/internal/ceres/dense_sparse_matrix.cc b/internal/ceres/dense_sparse_matrix.cc
index 72e0836..53207fe 100644
--- a/internal/ceres/dense_sparse_matrix.cc
+++ b/internal/ceres/dense_sparse_matrix.cc
@@ -31,17 +31,17 @@
#include "ceres/dense_sparse_matrix.h"
#include <algorithm>
-#include "ceres/triplet_sparse_matrix.h"
+
#include "ceres/internal/eigen.h"
#include "ceres/internal/port.h"
+#include "ceres/triplet_sparse_matrix.h"
#include "glog/logging.h"
namespace ceres {
namespace internal {
DenseSparseMatrix::DenseSparseMatrix(int num_rows, int num_cols)
- : has_diagonal_appended_(false),
- has_diagonal_reserved_(false) {
+ : has_diagonal_appended_(false), has_diagonal_reserved_(false) {
m_.resize(num_rows, num_cols);
m_.setZero();
}
@@ -49,11 +49,10 @@
DenseSparseMatrix::DenseSparseMatrix(int num_rows,
int num_cols,
bool reserve_diagonal)
- : has_diagonal_appended_(false),
- has_diagonal_reserved_(reserve_diagonal) {
+ : has_diagonal_appended_(false), has_diagonal_reserved_(reserve_diagonal) {
if (reserve_diagonal) {
// Allocate enough space for the diagonal.
- m_.resize(num_rows + num_cols, num_cols);
+ m_.resize(num_rows + num_cols, num_cols);
} else {
m_.resize(num_rows, num_cols);
}
@@ -64,9 +63,9 @@
: m_(Eigen::MatrixXd::Zero(m.num_rows(), m.num_cols())),
has_diagonal_appended_(false),
has_diagonal_reserved_(false) {
- const double *values = m.values();
- const int *rows = m.rows();
- const int *cols = m.cols();
+ const double* values = m.values();
+ const int* rows = m.rows();
+ const int* cols = m.cols();
int num_nonzeros = m.num_nonzeros();
for (int i = 0; i < num_nonzeros; ++i) {
@@ -75,14 +74,9 @@
}
DenseSparseMatrix::DenseSparseMatrix(const ColMajorMatrix& m)
- : m_(m),
- has_diagonal_appended_(false),
- has_diagonal_reserved_(false) {
-}
+ : m_(m), has_diagonal_appended_(false), has_diagonal_reserved_(false) {}
-void DenseSparseMatrix::SetZero() {
- m_.setZero();
-}
+void DenseSparseMatrix::SetZero() { m_.setZero(); }
void DenseSparseMatrix::RightMultiply(const double* x, double* y) const {
VectorRef(y, num_rows()) += matrix() * ConstVectorRef(x, num_cols());
@@ -105,7 +99,7 @@
*dense_matrix = m_.block(0, 0, num_rows(), num_cols());
}
-void DenseSparseMatrix::AppendDiagonal(double *d) {
+void DenseSparseMatrix::AppendDiagonal(double* d) {
CHECK(!has_diagonal_appended_);
if (!has_diagonal_reserved_) {
ColMajorMatrix tmp = m_;
@@ -133,9 +127,7 @@
return m_.rows();
}
-int DenseSparseMatrix::num_cols() const {
- return m_.cols();
-}
+int DenseSparseMatrix::num_cols() const { return m_.cols(); }
int DenseSparseMatrix::num_nonzeros() const {
if (has_diagonal_reserved_ && !has_diagonal_appended_) {
@@ -148,33 +140,30 @@
return ConstColMajorMatrixRef(
m_.data(),
((has_diagonal_reserved_ && !has_diagonal_appended_)
- ? m_.rows() - m_.cols()
- : m_.rows()),
+ ? m_.rows() - m_.cols()
+ : m_.rows()),
m_.cols(),
Eigen::Stride<Eigen::Dynamic, 1>(m_.rows(), 1));
}
ColMajorMatrixRef DenseSparseMatrix::mutable_matrix() {
- return ColMajorMatrixRef(
- m_.data(),
- ((has_diagonal_reserved_ && !has_diagonal_appended_)
- ? m_.rows() - m_.cols()
- : m_.rows()),
- m_.cols(),
- Eigen::Stride<Eigen::Dynamic, 1>(m_.rows(), 1));
+ return ColMajorMatrixRef(m_.data(),
+ ((has_diagonal_reserved_ && !has_diagonal_appended_)
+ ? m_.rows() - m_.cols()
+ : m_.rows()),
+ m_.cols(),
+ Eigen::Stride<Eigen::Dynamic, 1>(m_.rows(), 1));
}
-
void DenseSparseMatrix::ToTextFile(FILE* file) const {
CHECK(file != nullptr);
- const int active_rows =
- (has_diagonal_reserved_ && !has_diagonal_appended_)
- ? (m_.rows() - m_.cols())
- : m_.rows();
+ const int active_rows = (has_diagonal_reserved_ && !has_diagonal_appended_)
+ ? (m_.rows() - m_.cols())
+ : m_.rows();
for (int r = 0; r < active_rows; ++r) {
for (int c = 0; c < m_.cols(); ++c) {
- fprintf(file, "% 10d % 10d %17f\n", r, c, m_(r, c));
+ fprintf(file, "% 10d % 10d %17f\n", r, c, m_(r, c));
}
}
}
diff --git a/internal/ceres/dense_sparse_matrix.h b/internal/ceres/dense_sparse_matrix.h
index 6d3d504..34a3be2 100644
--- a/internal/ceres/dense_sparse_matrix.h
+++ b/internal/ceres/dense_sparse_matrix.h
@@ -92,7 +92,7 @@
// Calling RemoveDiagonal removes the block. It is a fatal error to append a
// diagonal to a matrix that already has an appended diagonal, and it is also
// a fatal error to remove a diagonal from a matrix that has none.
- void AppendDiagonal(double *d);
+ void AppendDiagonal(double* d);
void RemoveDiagonal();
private:
diff --git a/internal/ceres/dense_sparse_matrix_test.cc b/internal/ceres/dense_sparse_matrix_test.cc
index a0c1cd6..2fa7216 100644
--- a/internal/ceres/dense_sparse_matrix_test.cc
+++ b/internal/ceres/dense_sparse_matrix_test.cc
@@ -35,10 +35,11 @@
#include "ceres/dense_sparse_matrix.h"
#include <memory>
+
#include "ceres/casts.h"
+#include "ceres/internal/eigen.h"
#include "ceres/linear_least_squares_problems.h"
#include "ceres/triplet_sparse_matrix.h"
-#include "ceres/internal/eigen.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
@@ -67,7 +68,7 @@
}
class DenseSparseMatrixTest : public ::testing::Test {
- protected :
+ protected:
void SetUp() final {
std::unique_ptr<LinearLeastSquaresProblem> problem(
CreateLinearLeastSquaresProblemFromId(1));
diff --git a/internal/ceres/detect_structure.cc b/internal/ceres/detect_structure.cc
index 959a0ee..4aac445 100644
--- a/internal/ceres/detect_structure.cc
+++ b/internal/ceres/detect_structure.cc
@@ -29,6 +29,7 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/detect_structure.h"
+
#include "ceres/internal/eigen.h"
#include "glog/logging.h"
@@ -61,8 +62,7 @@
} else if (*row_block_size != Eigen::Dynamic &&
*row_block_size != row.block.size) {
VLOG(2) << "Dynamic row block size because the block size changed from "
- << *row_block_size << " to "
- << row.block.size;
+ << *row_block_size << " to " << row.block.size;
*row_block_size = Eigen::Dynamic;
}
@@ -73,8 +73,7 @@
} else if (*e_block_size != Eigen::Dynamic &&
*e_block_size != bs.cols[e_block_id].size) {
VLOG(2) << "Dynamic e block size because the block size changed from "
- << *e_block_size << " to "
- << bs.cols[e_block_id].size;
+ << *e_block_size << " to " << bs.cols[e_block_id].size;
*e_block_size = Eigen::Dynamic;
}
@@ -100,9 +99,11 @@
}
}
+ // clang-format off
const bool is_everything_dynamic = (*row_block_size == Eigen::Dynamic &&
*e_block_size == Eigen::Dynamic &&
*f_block_size == Eigen::Dynamic);
+ // clang-format on
if (is_everything_dynamic) {
break;
}
@@ -110,10 +111,12 @@
CHECK_NE(*row_block_size, 0) << "No rows found";
CHECK_NE(*e_block_size, 0) << "No e type blocks found";
+ // clang-format off
VLOG(1) << "Schur complement static structure <"
<< *row_block_size << ","
<< *e_block_size << ","
<< *f_block_size << ">.";
+ // clang-format on
}
} // namespace internal
diff --git a/internal/ceres/detect_structure_test.cc b/internal/ceres/detect_structure_test.cc
index a701a19..8f9c5ed 100644
--- a/internal/ceres/detect_structure_test.cc
+++ b/internal/ceres/detect_structure_test.cc
@@ -28,11 +28,12 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/detect_structure.h"
+
#include "Eigen/Core"
+#include "ceres/block_structure.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
-#include "ceres/block_structure.h"
-#include "ceres/detect_structure.h"
namespace ceres {
namespace internal {
@@ -78,11 +79,8 @@
int e_block_size = 0;
int f_block_size = 0;
const int num_eliminate_blocks = 1;
- DetectStructure(bs,
- num_eliminate_blocks,
- &row_block_size,
- &e_block_size,
- &f_block_size);
+ DetectStructure(
+ bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
EXPECT_EQ(row_block_size, expected_row_block_size);
EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -130,11 +128,8 @@
int e_block_size = 0;
int f_block_size = 0;
const int num_eliminate_blocks = 1;
- DetectStructure(bs,
- num_eliminate_blocks,
- &row_block_size,
- &e_block_size,
- &f_block_size);
+ DetectStructure(
+ bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
EXPECT_EQ(row_block_size, expected_row_block_size);
EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -146,7 +141,6 @@
const int expected_e_block_size = 3;
const int expected_f_block_size = Eigen::Dynamic;
-
CompressedRowBlockStructure bs;
bs.cols.push_back(Block());
@@ -183,11 +177,8 @@
int e_block_size = 0;
int f_block_size = 0;
const int num_eliminate_blocks = 1;
- DetectStructure(bs,
- num_eliminate_blocks,
- &row_block_size,
- &e_block_size,
- &f_block_size);
+ DetectStructure(
+ bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
EXPECT_EQ(row_block_size, expected_row_block_size);
EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -235,11 +226,8 @@
int e_block_size = 0;
int f_block_size = 0;
const int num_eliminate_blocks = 2;
- DetectStructure(bs,
- num_eliminate_blocks,
- &row_block_size,
- &e_block_size,
- &f_block_size);
+ DetectStructure(
+ bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
EXPECT_EQ(row_block_size, expected_row_block_size);
EXPECT_EQ(e_block_size, expected_e_block_size);
@@ -279,11 +267,8 @@
int e_block_size = 0;
int f_block_size = 0;
const int num_eliminate_blocks = 1;
- DetectStructure(bs,
- num_eliminate_blocks,
- &row_block_size,
- &e_block_size,
- &f_block_size);
+ DetectStructure(
+ bs, num_eliminate_blocks, &row_block_size, &e_block_size, &f_block_size);
EXPECT_EQ(row_block_size, expected_row_block_size);
EXPECT_EQ(e_block_size, expected_e_block_size);
diff --git a/internal/ceres/dogleg_strategy.cc b/internal/ceres/dogleg_strategy.cc
index ecc6b88..03ae22f 100644
--- a/internal/ceres/dogleg_strategy.cc
+++ b/internal/ceres/dogleg_strategy.cc
@@ -49,7 +49,7 @@
namespace {
const double kMaxMu = 1.0;
const double kMinMu = 1e-8;
-}
+} // namespace
DoglegStrategy::DoglegStrategy(const TrustRegionStrategy::Options& options)
: linear_solver_(options.linear_solver),
@@ -122,8 +122,8 @@
//
jacobian->SquaredColumnNorm(diagonal_.data());
for (int i = 0; i < n; ++i) {
- diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_),
- max_diagonal_);
+ diagonal_[i] =
+ std::min(std::max(diagonal_[i], min_diagonal_), max_diagonal_);
}
diagonal_ = diagonal_.array().sqrt();
@@ -171,9 +171,8 @@
// The gradient, the Gauss-Newton step, the Cauchy point,
// and all calculations involving the Jacobian have to
// be adjusted accordingly.
-void DoglegStrategy::ComputeGradient(
- SparseMatrix* jacobian,
- const double* residuals) {
+void DoglegStrategy::ComputeGradient(SparseMatrix* jacobian,
+ const double* residuals) {
gradient_.setZero();
jacobian->LeftMultiply(residuals, gradient_.data());
gradient_.array() /= diagonal_.array();
@@ -187,8 +186,7 @@
Jg.setZero();
// The Jacobian is scaled implicitly by computing J * (D^-1 * (D^-1 * g))
// instead of (J * D^-1) * (D^-1 * g).
- Vector scaled_gradient =
- (gradient_.array() / diagonal_.array()).matrix();
+ Vector scaled_gradient = (gradient_.array() / diagonal_.array()).matrix();
jacobian->RightMultiply(scaled_gradient.data(), Jg.data());
alpha_ = gradient_.squaredNorm() / Jg.squaredNorm();
}
@@ -217,7 +215,7 @@
// Case 2. The Cauchy point and the Gauss-Newton steps lie outside
// the trust region. Rescale the Cauchy point to the trust region
// and return.
- if (gradient_norm * alpha_ >= radius_) {
+ if (gradient_norm * alpha_ >= radius_) {
dogleg_step = -(radius_ / gradient_norm) * gradient_;
dogleg_step_norm_ = radius_;
dogleg_step.array() /= diagonal_.array();
@@ -242,14 +240,12 @@
// = alpha * -gradient' gauss_newton_step - alpha^2 |gradient|^2
const double c = b_dot_a - a_squared_norm;
const double d = sqrt(c * c + b_minus_a_squared_norm *
- (pow(radius_, 2.0) - a_squared_norm));
+ (pow(radius_, 2.0) - a_squared_norm));
- double beta =
- (c <= 0)
- ? (d - c) / b_minus_a_squared_norm
- : (radius_ * radius_ - a_squared_norm) / (d + c);
- dogleg_step = (-alpha_ * (1.0 - beta)) * gradient_
- + beta * gauss_newton_step_;
+ double beta = (c <= 0) ? (d - c) / b_minus_a_squared_norm
+ : (radius_ * radius_ - a_squared_norm) / (d + c);
+ dogleg_step =
+ (-alpha_ * (1.0 - beta)) * gradient_ + beta * gauss_newton_step_;
dogleg_step_norm_ = dogleg_step.norm();
dogleg_step.array() /= diagonal_.array();
VLOG(3) << "Dogleg step size: " << dogleg_step_norm_
@@ -345,13 +341,13 @@
// correctly determined.
const double kCosineThreshold = 0.99;
const Vector2d grad_minimum = subspace_B_ * minimum + subspace_g_;
- const double cosine_angle = -minimum.dot(grad_minimum) /
- (minimum.norm() * grad_minimum.norm());
+ const double cosine_angle =
+ -minimum.dot(grad_minimum) / (minimum.norm() * grad_minimum.norm());
if (cosine_angle < kCosineThreshold) {
LOG(WARNING) << "First order optimality seems to be violated "
<< "in the subspace method!\n"
- << "Cosine of angle between x and B x + g is "
- << cosine_angle << ".\n"
+ << "Cosine of angle between x and B x + g is " << cosine_angle
+ << ".\n"
<< "Taking a regular dogleg step instead.\n"
<< "Please consider filing a bug report if this "
<< "happens frequently or consistently.\n";
@@ -423,15 +419,17 @@
const double trB = subspace_B_.trace();
const double r2 = radius_ * radius_;
Matrix2d B_adj;
+ // clang-format off
B_adj << subspace_B_(1, 1) , -subspace_B_(0, 1),
- -subspace_B_(1, 0) , subspace_B_(0, 0);
+ -subspace_B_(1, 0) , subspace_B_(0, 0);
+ // clang-format on
Vector polynomial(5);
polynomial(0) = r2;
polynomial(1) = 2.0 * r2 * trB;
polynomial(2) = r2 * (trB * trB + 2.0 * detB) - subspace_g_.squaredNorm();
- polynomial(3) = -2.0 * (subspace_g_.transpose() * B_adj * subspace_g_
- - r2 * detB * trB);
+ polynomial(3) =
+ -2.0 * (subspace_g_.transpose() * B_adj * subspace_g_ - r2 * detB * trB);
polynomial(4) = r2 * detB * detB - (B_adj * subspace_g_).squaredNorm();
return polynomial;
@@ -565,10 +563,8 @@
// of Jx = -r and later set x = -y to avoid having to modify
// either jacobian or residuals.
InvalidateArray(n, gauss_newton_step_.data());
- linear_solver_summary = linear_solver_->Solve(jacobian,
- residuals,
- solve_options,
- gauss_newton_step_.data());
+ linear_solver_summary = linear_solver_->Solve(
+ jacobian, residuals, solve_options, gauss_newton_step_.data());
if (per_solve_options.dump_format_type == CONSOLE ||
(per_solve_options.dump_format_type != CONSOLE &&
@@ -641,9 +637,7 @@
reuse_ = false;
}
-double DoglegStrategy::Radius() const {
- return radius_;
-}
+double DoglegStrategy::Radius() const { return radius_; }
bool DoglegStrategy::ComputeSubspaceModel(SparseMatrix* jacobian) {
// Compute an orthogonal basis for the subspace using QR decomposition.
@@ -701,8 +695,8 @@
subspace_g_ = subspace_basis_.transpose() * gradient_;
- Eigen::Matrix<double, 2, Eigen::Dynamic, Eigen::RowMajor>
- Jb(2, jacobian->num_rows());
+ Eigen::Matrix<double, 2, Eigen::Dynamic, Eigen::RowMajor> Jb(
+ 2, jacobian->num_rows());
Jb.setZero();
Vector tmp;
diff --git a/internal/ceres/dogleg_strategy.h b/internal/ceres/dogleg_strategy.h
index 1150940..9616ffe 100644
--- a/internal/ceres/dogleg_strategy.h
+++ b/internal/ceres/dogleg_strategy.h
@@ -59,9 +59,9 @@
// TrustRegionStrategy interface
Summary ComputeStep(const PerSolveOptions& per_solve_options,
- SparseMatrix* jacobian,
- const double* residuals,
- double* step) final;
+ SparseMatrix* jacobian,
+ const double* residuals,
+ double* step) final;
void StepAccepted(double step_quality) final;
void StepRejected(double step_quality) final;
void StepIsInvalid();
diff --git a/internal/ceres/dogleg_strategy_test.cc b/internal/ceres/dogleg_strategy_test.cc
index af5b3e8..0c20f25 100644
--- a/internal/ceres/dogleg_strategy_test.cc
+++ b/internal/ceres/dogleg_strategy_test.cc
@@ -28,11 +28,13 @@
//
// Author: moll.markus@arcor.de (Markus Moll)
+#include "ceres/dogleg_strategy.h"
+
#include <limits>
#include <memory>
-#include "ceres/internal/eigen.h"
+
#include "ceres/dense_qr_solver.h"
-#include "ceres/dogleg_strategy.h"
+#include "ceres/internal/eigen.h"
#include "ceres/linear_solver.h"
#include "ceres/trust_region_strategy.h"
#include "glog/logging.h"
@@ -63,12 +65,14 @@
void SetUp() final {
Matrix basis(6, 6);
// The following lines exceed 80 characters for better readability.
+ // clang-format off
basis << -0.1046920933796121, -0.7449367449921986, -0.4190744502875876, -0.4480450716142566, 0.2375351607929440, -0.0363053418882862, // NOLINT
0.4064975684355914, 0.2681113508511354, -0.7463625494601520, -0.0803264850508117, -0.4463149623021321, 0.0130224954867195, // NOLINT
-0.5514387729089798, 0.1026621026168657, -0.5008316122125011, 0.5738122212666414, 0.2974664724007106, 0.1296020877535158, // NOLINT
0.5037835370947156, 0.2668479925183712, -0.1051754618492798, -0.0272739396578799, 0.7947481647088278, -0.1776623363955670, // NOLINT
-0.4005458426625444, 0.2939330589634109, -0.0682629380550051, -0.2895448882503687, -0.0457239396341685, -0.8139899477847840, // NOLINT
-0.3247764582762654, 0.4528151365941945, -0.0276683863102816, -0.6155994592510784, 0.1489240599972848, 0.5362574892189350; // NOLINT
+ // clang-format on
Vector Ddiag(6);
Ddiag << 1.0, 2.0, 4.0, 8.0, 16.0, 32.0;
@@ -139,10 +143,8 @@
DoglegStrategy strategy(options_);
TrustRegionStrategy::PerSolveOptions pso;
- TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
- jacobian_.get(),
- residual_.data(),
- x_.data());
+ TrustRegionStrategy::Summary summary =
+ strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
EXPECT_LE(x_.norm(), options_.initial_radius * (1.0 + 4.0 * kEpsilon));
@@ -159,10 +161,8 @@
DoglegStrategy strategy(options_);
TrustRegionStrategy::PerSolveOptions pso;
- TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
- jacobian_.get(),
- residual_.data(),
- x_.data());
+ TrustRegionStrategy::Summary summary =
+ strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
EXPECT_LE(x_.norm(), options_.initial_radius * (1.0 + 4.0 * kEpsilon));
@@ -179,10 +179,8 @@
DoglegStrategy strategy(options_);
TrustRegionStrategy::PerSolveOptions pso;
- TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
- jacobian_.get(),
- residual_.data(),
- x_.data());
+ TrustRegionStrategy::Summary summary =
+ strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
EXPECT_NEAR(x_(0), 1.0, kToleranceLoose);
@@ -216,15 +214,13 @@
// Check if the gradient projects onto itself.
const Vector gradient = strategy.gradient();
- EXPECT_NEAR((gradient - basis*(basis.transpose()*gradient)).norm(),
+ EXPECT_NEAR((gradient - basis * (basis.transpose() * gradient)).norm(),
0.0,
kTolerance);
// Check if the Gauss-Newton point projects onto itself.
const Vector gn = strategy.gauss_newton_step();
- EXPECT_NEAR((gn - basis*(basis.transpose()*gn)).norm(),
- 0.0,
- kTolerance);
+ EXPECT_NEAR((gn - basis * (basis.transpose() * gn)).norm(), 0.0, kTolerance);
}
// Test if the step is correct if the gradient and the Gauss-Newton step point
@@ -241,10 +237,8 @@
DoglegStrategy strategy(options_);
TrustRegionStrategy::PerSolveOptions pso;
- TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
- jacobian_.get(),
- residual_.data(),
- x_.data());
+ TrustRegionStrategy::Summary summary =
+ strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
EXPECT_NEAR(x_(0), 0.0, kToleranceLoose);
@@ -269,10 +263,8 @@
DoglegStrategy strategy(options_);
TrustRegionStrategy::PerSolveOptions pso;
- TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
- jacobian_.get(),
- residual_.data(),
- x_.data());
+ TrustRegionStrategy::Summary summary =
+ strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
EXPECT_NE(summary.termination_type, LINEAR_SOLVER_FAILURE);
EXPECT_NEAR(x_(0), 0.0, kToleranceLoose);
diff --git a/internal/ceres/dynamic_autodiff_cost_function_test.cc b/internal/ceres/dynamic_autodiff_cost_function_test.cc
index 6b57fd3..55d3fe1 100644
--- a/internal/ceres/dynamic_autodiff_cost_function_test.cc
+++ b/internal/ceres/dynamic_autodiff_cost_function_test.cc
@@ -30,10 +30,11 @@
// mierle@gmail.com (Keir Mierle)
// sameeragarwal@google.com (Sameer Agarwal)
-#include <cstddef>
-
-#include <memory>
#include "ceres/dynamic_autodiff_cost_function.h"
+
+#include <cstddef>
+#include <memory>
+
#include "gtest/gtest.h"
namespace ceres {
@@ -87,9 +88,8 @@
vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
- EXPECT_TRUE(cost_function.Evaluate(¶meter_blocks[0],
- residuals.data(),
- NULL));
+ EXPECT_TRUE(
+ cost_function.Evaluate(¶meter_blocks[0], residuals.data(), NULL));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(1.0 * r, residuals.at(r * 2));
EXPECT_EQ(-1.0 * r, residuals.at(r * 2 + 1));
@@ -127,9 +127,8 @@
jacobian.push_back(jacobian_vect[1].data());
// Test jacobian computation.
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function.Evaluate(
+ parameter_blocks.data(), residuals.data(), jacobian.data()));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -138,11 +137,11 @@
EXPECT_EQ(420, residuals.at(20));
for (int p = 0; p < 10; ++p) {
// Check "A" Jacobian.
- EXPECT_EQ(-1.0, jacobian_vect[0][2*p * 10 + p]);
+ EXPECT_EQ(-1.0, jacobian_vect[0][2 * p * 10 + p]);
// Check "B" Jacobian.
- EXPECT_EQ(+1.0, jacobian_vect[0][(2*p+1) * 10 + p]);
- jacobian_vect[0][2*p * 10 + p] = 0.0;
- jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+ EXPECT_EQ(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p]);
+ jacobian_vect[0][2 * p * 10 + p] = 0.0;
+ jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
}
// Check "C" Jacobian for first parameter block.
@@ -194,9 +193,8 @@
jacobian.push_back(jacobian_vect[1].data());
// Test jacobian computation.
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function.Evaluate(
+ parameter_blocks.data(), residuals.data(), jacobian.data()));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -214,7 +212,8 @@
}
}
-TEST(DynamicAutodiffCostFunctionTest, JacobianWithSecondParameterBlockConstant) { // NOLINT
+TEST(DynamicAutodiffCostFunctionTest,
+ JacobianWithSecondParameterBlockConstant) { // NOLINT
// Test the residual counting.
vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
@@ -244,9 +243,8 @@
jacobian.push_back(NULL);
// Test jacobian computation.
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function.Evaluate(
+ parameter_blocks.data(), residuals.data(), jacobian.data()));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -255,11 +253,11 @@
EXPECT_EQ(420, residuals.at(20));
for (int p = 0; p < 10; ++p) {
// Check "A" Jacobian.
- EXPECT_EQ(-1.0, jacobian_vect[0][2*p * 10 + p]);
+ EXPECT_EQ(-1.0, jacobian_vect[0][2 * p * 10 + p]);
// Check "B" Jacobian.
- EXPECT_EQ(+1.0, jacobian_vect[0][(2*p+1) * 10 + p]);
- jacobian_vect[0][2*p * 10 + p] = 0.0;
- jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+ EXPECT_EQ(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p]);
+ jacobian_vect[0][2 * p * 10 + p] = 0.0;
+ jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
}
// Check "C" Jacobian for first parameter block.
@@ -330,10 +328,10 @@
// Prepare the cost function.
typedef DynamicAutoDiffCostFunction<MyThreeParameterCostFunctor, 3>
- DynamicMyThreeParameterCostFunction;
- DynamicMyThreeParameterCostFunction * cost_function =
- new DynamicMyThreeParameterCostFunction(
- new MyThreeParameterCostFunctor());
+ DynamicMyThreeParameterCostFunction;
+ DynamicMyThreeParameterCostFunction* cost_function =
+ new DynamicMyThreeParameterCostFunction(
+ new MyThreeParameterCostFunctor());
cost_function->AddParameterBlock(1);
cost_function->AddParameterBlock(2);
cost_function->AddParameterBlock(3);
@@ -431,9 +429,8 @@
TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
vector<double> residuals(7, -100000);
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- NULL));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), NULL));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
}
@@ -447,9 +444,8 @@
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(jacobian_vect_[2].data());
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -477,9 +473,8 @@
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(NULL);
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -499,9 +494,8 @@
jacobian.push_back(NULL);
jacobian.push_back(jacobian_vect_[2].data());
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -567,10 +561,9 @@
// Prepare the cost function.
typedef DynamicAutoDiffCostFunction<MySixParameterCostFunctor, 3>
- DynamicMySixParameterCostFunction;
- DynamicMySixParameterCostFunction * cost_function =
- new DynamicMySixParameterCostFunction(
- new MySixParameterCostFunctor());
+ DynamicMySixParameterCostFunction;
+ DynamicMySixParameterCostFunction* cost_function =
+ new DynamicMySixParameterCostFunction(new MySixParameterCostFunctor());
for (int i = 0; i < 6; ++i) {
cost_function->AddParameterBlock(1);
}
@@ -675,9 +668,8 @@
TEST_F(SixParameterCostFunctorTest, TestSixParameterResiduals) {
vector<double> residuals(7, -100000);
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- NULL));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), NULL));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
}
@@ -694,9 +686,8 @@
jacobian.push_back(jacobian_vect_[4].data());
jacobian.push_back(jacobian_vect_[5].data());
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -720,9 +711,8 @@
jacobian.push_back(jacobian_vect_[4].data());
jacobian.push_back(NULL);
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -751,9 +741,8 @@
jacobian.push_back(NULL);
jacobian.push_back(jacobian_vect_[5].data());
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
diff --git a/internal/ceres/dynamic_compressed_row_finalizer.h b/internal/ceres/dynamic_compressed_row_finalizer.h
index a25a308..30c98d8 100644
--- a/internal/ceres/dynamic_compressed_row_finalizer.h
+++ b/internal/ceres/dynamic_compressed_row_finalizer.h
@@ -40,7 +40,7 @@
struct DynamicCompressedRowJacobianFinalizer {
void operator()(SparseMatrix* base_jacobian, int num_parameters) {
DynamicCompressedRowSparseMatrix* jacobian =
- down_cast<DynamicCompressedRowSparseMatrix*>(base_jacobian);
+ down_cast<DynamicCompressedRowSparseMatrix*>(base_jacobian);
jacobian->Finalize(num_parameters);
}
};
diff --git a/internal/ceres/dynamic_compressed_row_jacobian_writer.h b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
index 6e5ac38..ef8fa25 100644
--- a/internal/ceres/dynamic_compressed_row_jacobian_writer.h
+++ b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
@@ -47,8 +47,7 @@
public:
DynamicCompressedRowJacobianWriter(Evaluator::Options /* ignored */,
Program* program)
- : program_(program) {
- }
+ : program_(program) {}
// JacobianWriter interface.
@@ -70,7 +69,7 @@
// This method is thread-safe over residual blocks (each `residual_id`).
void Write(int residual_id,
int residual_offset,
- double **jacobians,
+ double** jacobians,
SparseMatrix* base_jacobian);
private:
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
index f020768..936e682 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
@@ -28,22 +28,19 @@
//
// Author: richie.stebbing@gmail.com (Richard Stebbing)
-#include <cstring>
#include "ceres/dynamic_compressed_row_sparse_matrix.h"
+#include <cstring>
+
namespace ceres {
namespace internal {
DynamicCompressedRowSparseMatrix::DynamicCompressedRowSparseMatrix(
- int num_rows,
- int num_cols,
- int initial_max_num_nonzeros)
- : CompressedRowSparseMatrix(num_rows,
- num_cols,
- initial_max_num_nonzeros) {
- dynamic_cols_.resize(num_rows);
- dynamic_values_.resize(num_rows);
- }
+ int num_rows, int num_cols, int initial_max_num_nonzeros)
+ : CompressedRowSparseMatrix(num_rows, num_cols, initial_max_num_nonzeros) {
+ dynamic_cols_.resize(num_rows);
+ dynamic_values_.resize(num_rows);
+}
void DynamicCompressedRowSparseMatrix::InsertEntry(int row,
int col,
@@ -56,8 +53,7 @@
dynamic_values_[row].push_back(value);
}
-void DynamicCompressedRowSparseMatrix::ClearRows(int row_start,
- int num_rows) {
+void DynamicCompressedRowSparseMatrix::ClearRows(int row_start, int num_rows) {
for (int r = 0; r < num_rows; ++r) {
const int i = row_start + r;
CHECK_GE(i, 0);
@@ -99,8 +95,8 @@
mutable_rows()[num_rows()] = index_into_values_and_cols;
CHECK_EQ(index_into_values_and_cols, num_jacobian_nonzeros)
- << "Ceres bug: final index into values_ and cols_ should be equal to "
- << "the number of jacobian nonzeros. Please contact the developers!";
+ << "Ceres bug: final index into values_ and cols_ should be equal to "
+ << "the number of jacobian nonzeros. Please contact the developers!";
}
} // namespace internal
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
index 25b51ce..95dc807 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
@@ -31,6 +31,7 @@
#include "ceres/dynamic_compressed_row_sparse_matrix.h"
#include <memory>
+
#include "ceres/casts.h"
#include "ceres/compressed_row_sparse_matrix.h"
#include "ceres/internal/eigen.h"
@@ -60,14 +61,10 @@
InitialiseDenseReference();
InitialiseSparseMatrixReferences();
- dcrsm.reset(new DynamicCompressedRowSparseMatrix(num_rows,
- num_cols,
- 0));
+ dcrsm.reset(new DynamicCompressedRowSparseMatrix(num_rows, num_cols, 0));
}
- void Finalize() {
- dcrsm->Finalize(num_additional_elements);
- }
+ void Finalize() { dcrsm->Finalize(num_additional_elements); }
void InitialiseDenseReference() {
dense.resize(num_rows, num_cols);
@@ -96,9 +93,8 @@
}
ASSERT_EQ(values.size(), expected_num_nonzeros);
- tsm.reset(new TripletSparseMatrix(num_rows,
- num_cols,
- expected_num_nonzeros));
+ tsm.reset(
+ new 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());
diff --git a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
index d86cc95..0150f5e 100644
--- a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
+++ b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
@@ -29,10 +29,11 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
// mierle@gmail.com (Keir Mierle)
-#include <cstddef>
-
-#include <memory>
#include "ceres/dynamic_numeric_diff_cost_function.h"
+
+#include <cstddef>
+#include <memory>
+
#include "gtest/gtest.h"
namespace ceres {
@@ -87,9 +88,8 @@
vector<double*> parameter_blocks(2);
parameter_blocks[0] = ¶m_block_0[0];
parameter_blocks[1] = ¶m_block_1[0];
- EXPECT_TRUE(cost_function.Evaluate(¶meter_blocks[0],
- residuals.data(),
- NULL));
+ EXPECT_TRUE(
+ cost_function.Evaluate(¶meter_blocks[0], residuals.data(), NULL));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(1.0 * r, residuals.at(r * 2));
EXPECT_EQ(-1.0 * r, residuals.at(r * 2 + 1));
@@ -97,7 +97,6 @@
EXPECT_EQ(0, residuals.at(20));
}
-
TEST(DynamicNumericdiffCostFunctionTest, TestJacobian) {
// Test the residual counting.
vector<double> param_block_0(10, 0.0);
@@ -128,9 +127,8 @@
jacobian.push_back(jacobian_vect[1].data());
// Test jacobian computation.
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function.Evaluate(
+ parameter_blocks.data(), residuals.data(), jacobian.data()));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -139,11 +137,11 @@
EXPECT_EQ(420, residuals.at(20));
for (int p = 0; p < 10; ++p) {
// Check "A" Jacobian.
- EXPECT_NEAR(-1.0, jacobian_vect[0][2*p * 10 + p], kTolerance);
+ EXPECT_NEAR(-1.0, jacobian_vect[0][2 * p * 10 + p], kTolerance);
// Check "B" Jacobian.
- EXPECT_NEAR(+1.0, jacobian_vect[0][(2*p+1) * 10 + p], kTolerance);
- jacobian_vect[0][2*p * 10 + p] = 0.0;
- jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+ EXPECT_NEAR(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p], kTolerance);
+ jacobian_vect[0][2 * p * 10 + p] = 0.0;
+ jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
}
// Check "C" Jacobian for first parameter block.
@@ -165,7 +163,8 @@
}
}
-TEST(DynamicNumericdiffCostFunctionTest, JacobianWithFirstParameterBlockConstant) { // NOLINT
+TEST(DynamicNumericdiffCostFunctionTest,
+ JacobianWithFirstParameterBlockConstant) { // NOLINT
// Test the residual counting.
vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
@@ -195,9 +194,8 @@
jacobian.push_back(jacobian_vect[1].data());
// Test jacobian computation.
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function.Evaluate(
+ parameter_blocks.data(), residuals.data(), jacobian.data()));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -215,7 +213,8 @@
}
}
-TEST(DynamicNumericdiffCostFunctionTest, JacobianWithSecondParameterBlockConstant) { // NOLINT
+TEST(DynamicNumericdiffCostFunctionTest,
+ JacobianWithSecondParameterBlockConstant) { // NOLINT
// Test the residual counting.
vector<double> param_block_0(10, 0.0);
for (int i = 0; i < 10; ++i) {
@@ -245,9 +244,8 @@
jacobian.push_back(NULL);
// Test jacobian computation.
- EXPECT_TRUE(cost_function.Evaluate(parameter_blocks.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function.Evaluate(
+ parameter_blocks.data(), residuals.data(), jacobian.data()));
for (int r = 0; r < 10; ++r) {
EXPECT_EQ(-1.0 * r, residuals.at(r * 2));
@@ -256,11 +254,11 @@
EXPECT_EQ(420, residuals.at(20));
for (int p = 0; p < 10; ++p) {
// Check "A" Jacobian.
- EXPECT_NEAR(-1.0, jacobian_vect[0][2*p * 10 + p], kTolerance);
+ EXPECT_NEAR(-1.0, jacobian_vect[0][2 * p * 10 + p], kTolerance);
// Check "B" Jacobian.
- EXPECT_NEAR(+1.0, jacobian_vect[0][(2*p+1) * 10 + p], kTolerance);
- jacobian_vect[0][2*p * 10 + p] = 0.0;
- jacobian_vect[0][(2*p+1) * 10 + p] = 0.0;
+ EXPECT_NEAR(+1.0, jacobian_vect[0][(2 * p + 1) * 10 + p], kTolerance);
+ jacobian_vect[0][2 * p * 10 + p] = 0.0;
+ jacobian_vect[0][(2 * p + 1) * 10 + p] = 0.0;
}
// Check "C" Jacobian for first parameter block.
@@ -331,10 +329,10 @@
// Prepare the cost function.
typedef DynamicNumericDiffCostFunction<MyThreeParameterCostFunctor>
- DynamicMyThreeParameterCostFunction;
- DynamicMyThreeParameterCostFunction * cost_function =
- new DynamicMyThreeParameterCostFunction(
- new MyThreeParameterCostFunctor());
+ DynamicMyThreeParameterCostFunction;
+ DynamicMyThreeParameterCostFunction* cost_function =
+ new DynamicMyThreeParameterCostFunction(
+ new MyThreeParameterCostFunctor());
cost_function->AddParameterBlock(1);
cost_function->AddParameterBlock(2);
cost_function->AddParameterBlock(3);
@@ -432,9 +430,8 @@
TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
vector<double> residuals(7, -100000);
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- NULL));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), NULL));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
}
@@ -448,9 +445,8 @@
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(jacobian_vect_[2].data());
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -478,9 +474,8 @@
jacobian.push_back(jacobian_vect_[1].data());
jacobian.push_back(NULL);
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
@@ -500,9 +495,8 @@
jacobian.push_back(NULL);
jacobian.push_back(jacobian_vect_[2].data());
- EXPECT_TRUE(cost_function_->Evaluate(parameter_blocks_.data(),
- residuals.data(),
- jacobian.data()));
+ EXPECT_TRUE(cost_function_->Evaluate(
+ parameter_blocks_.data(), residuals.data(), jacobian.data()));
for (int i = 0; i < 7; ++i) {
EXPECT_EQ(expected_residuals_[i], residuals[i]);
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc b/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
index 25d5417..d31c422 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
@@ -95,7 +95,7 @@
LOG(FATAL) << "Unsupported sparse linear algebra library for "
<< "dynamic sparsity: "
<< SparseLinearAlgebraLibraryTypeToString(
- options_.sparse_linear_algebra_library_type);
+ options_.sparse_linear_algebra_library_type);
}
if (per_solve_options.D != nullptr) {
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver.h b/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
index 4e31c7a..36118ba 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
@@ -35,7 +35,9 @@
#define CERES_INTERNAL_DYNAMIC_SPARSE_NORMAL_CHOLESKY_SOLVER_H_
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
#include "ceres/linear_solver.h"
@@ -59,23 +61,19 @@
virtual ~DynamicSparseNormalCholeskySolver() {}
private:
- LinearSolver::Summary SolveImpl(
- CompressedRowSparseMatrix* A,
- const double* b,
- const LinearSolver::PerSolveOptions& options,
- double* x) final;
+ LinearSolver::Summary SolveImpl(CompressedRowSparseMatrix* A,
+ const double* b,
+ const LinearSolver::PerSolveOptions& options,
+ double* x) final;
- LinearSolver::Summary SolveImplUsingSuiteSparse(
- CompressedRowSparseMatrix* A,
- double* rhs_and_solution);
+ LinearSolver::Summary SolveImplUsingSuiteSparse(CompressedRowSparseMatrix* A,
+ double* rhs_and_solution);
- LinearSolver::Summary SolveImplUsingCXSparse(
- CompressedRowSparseMatrix* A,
- double* rhs_and_solution);
+ LinearSolver::Summary SolveImplUsingCXSparse(CompressedRowSparseMatrix* A,
+ double* rhs_and_solution);
- LinearSolver::Summary SolveImplUsingEigen(
- CompressedRowSparseMatrix* A,
- double* rhs_and_solution);
+ LinearSolver::Summary SolveImplUsingEigen(CompressedRowSparseMatrix* A,
+ double* rhs_and_solution);
const LinearSolver::Options options_;
};
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc b/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
index 3d0d46d..8bf609e 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
@@ -29,6 +29,8 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include <memory>
+
+#include "Eigen/Cholesky"
#include "ceres/casts.h"
#include "ceres/compressed_row_sparse_matrix.h"
#include "ceres/context_impl.h"
@@ -39,8 +41,6 @@
#include "glog/logging.h"
#include "gtest/gtest.h"
-#include "Eigen/Cholesky"
-
namespace ceres {
namespace internal {
diff --git a/internal/ceres/dynamic_sparsity_test.cc b/internal/ceres/dynamic_sparsity_test.cc
index 94ed173..12e62ef 100644
--- a/internal/ceres/dynamic_sparsity_test.cc
+++ b/internal/ceres/dynamic_sparsity_test.cc
@@ -33,6 +33,7 @@
#include <cmath>
#include <vector>
+
#include "ceres/ceres.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
@@ -53,6 +54,7 @@
const int kYRows = 212;
const int kYCols = 2;
+// clang-format off
const double kYData[kYRows * kYCols] = {
+3.871364e+00, +9.916027e-01,
+3.864003e+00, +1.034148e+00,
@@ -267,6 +269,7 @@
+3.870542e+00, +9.996121e-01,
+3.865424e+00, +1.028474e+00
};
+// clang-format on
ConstMatrixRef kY(kYData, kYRows, kYCols);
@@ -327,7 +330,8 @@
return true;
}
- static CostFunction* Create(const int num_segments, const Eigen::Vector2d& y) {
+ static CostFunction* Create(const int num_segments,
+ const Eigen::Vector2d& y) {
return new PointToLineSegmentContourCostFunction(num_segments, y);
}
diff --git a/internal/ceres/eigensparse.h b/internal/ceres/eigensparse.h
index 2e6c6f0..bb89c2c 100644
--- a/internal/ceres/eigensparse.h
+++ b/internal/ceres/eigensparse.h
@@ -56,8 +56,8 @@
// SparseCholesky interface.
virtual ~EigenSparseCholesky();
- virtual LinearSolverTerminationType Factorize(
- CompressedRowSparseMatrix* lhs, std::string* message) = 0;
+ virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+ std::string* message) = 0;
virtual CompressedRowSparseMatrix::StorageType StorageType() const = 0;
virtual LinearSolverTerminationType Solve(const double* rhs,
double* solution,
@@ -74,8 +74,8 @@
// SparseCholesky interface.
virtual ~FloatEigenSparseCholesky();
- virtual LinearSolverTerminationType Factorize(
- CompressedRowSparseMatrix* lhs, std::string* message) = 0;
+ virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+ std::string* message) = 0;
virtual CompressedRowSparseMatrix::StorageType StorageType() const = 0;
virtual LinearSolverTerminationType Solve(const double* rhs,
double* solution,
diff --git a/internal/ceres/evaluation_callback_test.cc b/internal/ceres/evaluation_callback_test.cc
index ccca942..0ca2625 100644
--- a/internal/ceres/evaluation_callback_test.cc
+++ b/internal/ceres/evaluation_callback_test.cc
@@ -34,10 +34,10 @@
#include <limits>
#include <vector>
+#include "ceres/autodiff_cost_function.h"
#include "ceres/problem.h"
#include "ceres/problem_impl.h"
#include "ceres/sized_cost_function.h"
-#include "ceres/autodiff_cost_function.h"
#include "ceres/solver.h"
#include "gtest/gtest.h"
@@ -249,8 +249,8 @@
public:
void PrepareForEvaluation(bool evaluate_jacobians,
bool new_evaluation_point) final {
- (void) evaluate_jacobians;
- (void) new_evaluation_point;
+ (void)evaluate_jacobians;
+ (void)new_evaluation_point;
counter_ += 1.0;
}
diff --git a/internal/ceres/evaluator.cc b/internal/ceres/evaluator.cc
index 8387983..5168741 100644
--- a/internal/ceres/evaluator.cc
+++ b/internal/ceres/evaluator.cc
@@ -28,7 +28,10 @@
//
// Author: keir@google.com (Keir Mierle)
+#include "ceres/evaluator.h"
+
#include <vector>
+
#include "ceres/block_evaluate_preparer.h"
#include "ceres/block_jacobian_writer.h"
#include "ceres/compressed_row_jacobian_writer.h"
@@ -37,7 +40,6 @@
#include "ceres/dense_jacobian_writer.h"
#include "ceres/dynamic_compressed_row_finalizer.h"
#include "ceres/dynamic_compressed_row_jacobian_writer.h"
-#include "ceres/evaluator.h"
#include "ceres/internal/port.h"
#include "ceres/program_evaluator.h"
#include "ceres/scratch_evaluate_preparer.h"
@@ -56,26 +58,23 @@
switch (options.linear_solver_type) {
case DENSE_QR:
case DENSE_NORMAL_CHOLESKY:
- return new ProgramEvaluator<ScratchEvaluatePreparer,
- DenseJacobianWriter>(options,
- program);
+ return new ProgramEvaluator<ScratchEvaluatePreparer, DenseJacobianWriter>(
+ options, program);
case DENSE_SCHUR:
case SPARSE_SCHUR:
case ITERATIVE_SCHUR:
case CGNR:
- return new ProgramEvaluator<BlockEvaluatePreparer,
- BlockJacobianWriter>(options,
- program);
+ return new ProgramEvaluator<BlockEvaluatePreparer, BlockJacobianWriter>(
+ options, program);
case SPARSE_NORMAL_CHOLESKY:
if (options.dynamic_sparsity) {
return new ProgramEvaluator<ScratchEvaluatePreparer,
DynamicCompressedRowJacobianWriter,
DynamicCompressedRowJacobianFinalizer>(
- options, program);
+ options, program);
} else {
- return new ProgramEvaluator<BlockEvaluatePreparer,
- BlockJacobianWriter>(options,
- program);
+ return new ProgramEvaluator<BlockEvaluatePreparer, BlockJacobianWriter>(
+ options, program);
}
default:
diff --git a/internal/ceres/evaluator.h b/internal/ceres/evaluator.h
index b820958..a668445 100644
--- a/internal/ceres/evaluator.h
+++ b/internal/ceres/evaluator.h
@@ -124,12 +124,8 @@
double* residuals,
double* gradient,
SparseMatrix* jacobian) {
- return Evaluate(EvaluateOptions(),
- state,
- cost,
- residuals,
- gradient,
- jacobian);
+ return Evaluate(
+ EvaluateOptions(), state, cost, residuals, gradient, jacobian);
}
// Make a change delta (of size NumEffectiveParameters()) to state (of size
@@ -152,7 +148,7 @@
// This is the effective number of parameters that the optimizer may adjust.
// This applies when there are parameterizations on some of the parameters.
- virtual int NumEffectiveParameters() const = 0;
+ virtual int NumEffectiveParameters() const = 0;
// The number of residuals in the optimization problem.
virtual int NumResiduals() const = 0;
diff --git a/internal/ceres/evaluator_test.cc b/internal/ceres/evaluator_test.cc
index 4f023d1..5ddb733 100644
--- a/internal/ceres/evaluator_test.cc
+++ b/internal/ceres/evaluator_test.cc
@@ -34,6 +34,7 @@
#include "ceres/evaluator.h"
#include <memory>
+
#include "ceres/casts.h"
#include "ceres/cost_function.h"
#include "ceres/crs_matrix.h"
@@ -105,17 +106,16 @@
EvaluatorTestOptions(LinearSolverType linear_solver_type,
int num_eliminate_blocks,
bool dynamic_sparsity = false)
- : linear_solver_type(linear_solver_type),
- num_eliminate_blocks(num_eliminate_blocks),
- dynamic_sparsity(dynamic_sparsity) {}
+ : linear_solver_type(linear_solver_type),
+ num_eliminate_blocks(num_eliminate_blocks),
+ dynamic_sparsity(dynamic_sparsity) {}
LinearSolverType linear_solver_type;
int num_eliminate_blocks;
bool dynamic_sparsity;
};
-struct EvaluatorTest
- : public ::testing::TestWithParam<EvaluatorTestOptions> {
+struct EvaluatorTest : public ::testing::TestWithParam<EvaluatorTestOptions> {
Evaluator* CreateEvaluator(Program* program) {
// This program is straight from the ProblemImpl, and so has no index/offset
// yet; compute it here as required by the evaluator implementations.
@@ -123,13 +123,15 @@
if (VLOG_IS_ON(1)) {
string report;
- StringAppendF(&report, "Creating evaluator with type: %d",
+ StringAppendF(&report,
+ "Creating evaluator with type: %d",
GetParam().linear_solver_type);
if (GetParam().linear_solver_type == SPARSE_NORMAL_CHOLESKY) {
- StringAppendF(&report, ", dynamic_sparsity: %d",
- GetParam().dynamic_sparsity);
+ StringAppendF(
+ &report, ", dynamic_sparsity: %d", GetParam().dynamic_sparsity);
}
- StringAppendF(&report, " and num_eliminate_blocks: %d",
+ StringAppendF(&report,
+ " and num_eliminate_blocks: %d",
GetParam().num_eliminate_blocks);
VLOG(1) << report;
}
@@ -142,7 +144,7 @@
return Evaluator::Create(options, program, &error);
}
- void EvaluateAndCompare(ProblemImpl *problem,
+ void EvaluateAndCompare(ProblemImpl* problem,
int expected_num_rows,
int expected_num_cols,
double expected_cost,
@@ -171,12 +173,14 @@
vector<double> state(evaluator->NumParameters());
+ // clang-format off
ASSERT_TRUE(evaluator->Evaluate(
&state[0],
&cost,
expected_residuals != nullptr ? &residuals[0] : nullptr,
expected_gradient != nullptr ? &gradient[0] : nullptr,
expected_jacobian != nullptr ? jacobian.get() : nullptr));
+ // clang-format on
Matrix actual_jacobian;
if (expected_jacobian != nullptr) {
@@ -196,15 +200,15 @@
}
// Try all combinations of parameters for the evaluator.
- void CheckAllEvaluationCombinations(const ExpectedEvaluation &expected) {
+ void CheckAllEvaluationCombinations(const ExpectedEvaluation& expected) {
for (int i = 0; i < 8; ++i) {
EvaluateAndCompare(&problem,
expected.num_rows,
expected.num_cols,
expected.cost,
(i & 1) ? expected.residuals : nullptr,
- (i & 2) ? expected.gradient : nullptr,
- (i & 4) ? expected.jacobian : nullptr);
+ (i & 2) ? expected.gradient : nullptr,
+ (i & 4) ? expected.jacobian : nullptr);
}
}
@@ -217,15 +221,15 @@
};
static void SetSparseMatrixConstant(SparseMatrix* sparse_matrix, double value) {
- VectorRef(sparse_matrix->mutable_values(),
- sparse_matrix->num_nonzeros()).setConstant(value);
+ VectorRef(sparse_matrix->mutable_values(), sparse_matrix->num_nonzeros())
+ .setConstant(value);
}
TEST_P(EvaluatorTest, SingleResidualProblem) {
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>,
- nullptr,
- x, y, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>, nullptr, x, y, z);
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
3, 9,
@@ -245,14 +249,15 @@
1, 2, 1, 2, 3, 1, 2, 3, 4
}
};
+ // clang-format on
CheckAllEvaluationCombinations(expected);
}
TEST_P(EvaluatorTest, SingleResidualProblemWithPermutedParameters) {
// Add the parameters in explicit order to force the ordering in the program.
- problem.AddParameterBlock(x, 2);
- problem.AddParameterBlock(y, 3);
- problem.AddParameterBlock(z, 4);
+ problem.AddParameterBlock(x, 2);
+ problem.AddParameterBlock(y, 3);
+ problem.AddParameterBlock(z, 4);
// Then use a cost function which is similar to the others, but swap around
// the ordering of the parameters to the cost function. This shouldn't affect
@@ -260,10 +265,10 @@
// At one point the compressed row evaluator had a bug that went undetected
// for a long time, since by chance most users added parameters to the problem
// in the same order that they occurred as parameters to a cost function.
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 3, 4, 3, 2>,
- nullptr,
- z, y, x);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<1, 3, 4, 3, 2>, nullptr, z, y, x);
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
3, 9,
@@ -283,6 +288,7 @@
1, 2, 1, 2, 3, 1, 2, 3, 4
}
};
+ // clang-format on
CheckAllEvaluationCombinations(expected);
}
@@ -303,10 +309,10 @@
problem.AddParameterBlock(z, 4);
problem.AddParameterBlock(d, 3);
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>,
- nullptr,
- x, y, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<1, 3, 2, 3, 4>, nullptr, x, y, z);
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
3, 16,
@@ -330,30 +336,29 @@
0, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 0, 0
}
};
+ // clang-format on
CheckAllEvaluationCombinations(expected);
}
TEST_P(EvaluatorTest, MultipleResidualProblem) {
// Add the parameters in explicit order to force the ordering in the program.
- problem.AddParameterBlock(x, 2);
- problem.AddParameterBlock(y, 3);
- problem.AddParameterBlock(z, 4);
+ problem.AddParameterBlock(x, 2);
+ problem.AddParameterBlock(y, 3);
+ problem.AddParameterBlock(z, 4);
// f(x, y) in R^2
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 2, 2, 3>,
- nullptr,
- x, y);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<1, 2, 2, 3>, nullptr, x, y);
// g(x, z) in R^3
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<2, 3, 2, 4>,
- nullptr,
- x, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<2, 3, 2, 4>, nullptr, x, z);
// h(y, z) in R^4
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<3, 4, 3, 4>,
- nullptr,
- y, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<3, 4, 3, 4>, nullptr, y, z);
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
9, 9,
@@ -385,12 +390,13 @@
0, 0, 3, 6, 9, 3, 6, 9, 12
}
};
+ // clang-format on
CheckAllEvaluationCombinations(expected);
}
TEST_P(EvaluatorTest, MultipleResidualsWithLocalParameterizations) {
// Add the parameters in explicit order to force the ordering in the program.
- problem.AddParameterBlock(x, 2);
+ problem.AddParameterBlock(x, 2);
// Fix y's first dimension.
vector<int> y_fixed;
@@ -403,20 +409,18 @@
problem.AddParameterBlock(z, 4, new SubsetParameterization(4, z_fixed));
// f(x, y) in R^2
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 2, 2, 3>,
- nullptr,
- x, y);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<1, 2, 2, 3>, nullptr, x, y);
// g(x, z) in R^3
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<2, 3, 2, 4>,
- nullptr,
- x, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<2, 3, 2, 4>, nullptr, x, z);
// h(y, z) in R^4
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<3, 4, 3, 4>,
- nullptr,
- y, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<3, 4, 3, 4>, nullptr, y, z);
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
9, 7,
@@ -448,6 +452,7 @@
0, 0, 6, 9, 3, 9, 12
}
};
+ // clang-format on
CheckAllEvaluationCombinations(expected);
}
@@ -458,24 +463,21 @@
double z[4];
// Add the parameters in explicit order to force the ordering in the program.
- problem.AddParameterBlock(x, 2);
- problem.AddParameterBlock(y, 3);
- problem.AddParameterBlock(z, 4);
+ problem.AddParameterBlock(x, 2);
+ problem.AddParameterBlock(y, 3);
+ problem.AddParameterBlock(z, 4);
// f(x, y) in R^2
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<1, 2, 2, 3>,
- nullptr,
- x, y);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<1, 2, 2, 3>, nullptr, x, y);
// g(x, z) in R^3
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<2, 3, 2, 4>,
- nullptr,
- x, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<2, 3, 2, 4>, nullptr, x, z);
// h(y, z) in R^4
- problem.AddResidualBlock(new ParameterIgnoringCostFunction<3, 4, 3, 4>,
- nullptr,
- y, z);
+ problem.AddResidualBlock(
+ new ParameterIgnoringCostFunction<3, 4, 3, 4>, nullptr, y, z);
// For this test, "z" is constant.
problem.SetParameterBlockConstant(z);
@@ -493,6 +495,7 @@
ParameterBlock* parameter_block_z = parameter_blocks->back();
parameter_blocks->pop_back();
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
9, 5,
@@ -523,6 +526,7 @@
0, 0, 3, 6, 9
}
};
+ // clang-format on
CheckAllEvaluationCombinations(expected);
// Restore parameter block z, so it will get freed in a consistent way.
diff --git a/internal/ceres/evaluator_test_utils.cc b/internal/ceres/evaluator_test_utils.cc
index 36dc21c..25801db 100644
--- a/internal/ceres/evaluator_test_utils.cc
+++ b/internal/ceres/evaluator_test_utils.cc
@@ -30,6 +30,7 @@
// sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/evaluator_test_utils.h"
+
#include "ceres/internal/eigen.h"
#include "gtest/gtest.h"
@@ -51,37 +52,39 @@
if (expected_residuals != NULL) {
ConstVectorRef expected_residuals_vector(expected_residuals,
expected_num_rows);
- ConstVectorRef actual_residuals_vector(actual_residuals,
- expected_num_rows);
- EXPECT_TRUE((actual_residuals_vector.array() ==
- expected_residuals_vector.array()).all())
- << "Actual:\n" << actual_residuals_vector
- << "\nExpected:\n" << expected_residuals_vector;
+ ConstVectorRef actual_residuals_vector(actual_residuals, expected_num_rows);
+ EXPECT_TRUE(
+ (actual_residuals_vector.array() == expected_residuals_vector.array())
+ .all())
+ << "Actual:\n"
+ << actual_residuals_vector << "\nExpected:\n"
+ << expected_residuals_vector;
}
if (expected_gradient != NULL) {
ConstVectorRef expected_gradient_vector(expected_gradient,
expected_num_cols);
- ConstVectorRef actual_gradient_vector(actual_gradient,
- expected_num_cols);
+ ConstVectorRef actual_gradient_vector(actual_gradient, expected_num_cols);
- EXPECT_TRUE((actual_gradient_vector.array() ==
- expected_gradient_vector.array()).all())
- << "Actual:\n" << actual_gradient_vector.transpose()
- << "\nExpected:\n" << expected_gradient_vector.transpose();
+ EXPECT_TRUE(
+ (actual_gradient_vector.array() == expected_gradient_vector.array())
+ .all())
+ << "Actual:\n"
+ << actual_gradient_vector.transpose() << "\nExpected:\n"
+ << expected_gradient_vector.transpose();
}
if (expected_jacobian != NULL) {
- ConstMatrixRef expected_jacobian_matrix(expected_jacobian,
- expected_num_rows,
- expected_num_cols);
- ConstMatrixRef actual_jacobian_matrix(actual_jacobian,
- expected_num_rows,
- expected_num_cols);
- EXPECT_TRUE((actual_jacobian_matrix.array() ==
- expected_jacobian_matrix.array()).all())
- << "Actual:\n" << actual_jacobian_matrix
- << "\nExpected:\n" << expected_jacobian_matrix;
+ ConstMatrixRef expected_jacobian_matrix(
+ expected_jacobian, expected_num_rows, expected_num_cols);
+ ConstMatrixRef actual_jacobian_matrix(
+ actual_jacobian, expected_num_rows, expected_num_cols);
+ EXPECT_TRUE(
+ (actual_jacobian_matrix.array() == expected_jacobian_matrix.array())
+ .all())
+ << "Actual:\n"
+ << actual_jacobian_matrix << "\nExpected:\n"
+ << expected_jacobian_matrix;
}
}
diff --git a/internal/ceres/file.cc b/internal/ceres/file.cc
index c95a44d..94f2135 100644
--- a/internal/ceres/file.cc
+++ b/internal/ceres/file.cc
@@ -33,6 +33,7 @@
#include "ceres/file.h"
#include <cstdio>
+
#include "glog/logging.h"
namespace ceres {
@@ -40,7 +41,7 @@
using std::string;
-void WriteStringToFileOrDie(const string &data, const string &filename) {
+void WriteStringToFileOrDie(const string& data, const string& filename) {
FILE* file_descriptor = fopen(filename.c_str(), "wb");
if (!file_descriptor) {
LOG(FATAL) << "Couldn't write to file: " << filename;
@@ -49,7 +50,7 @@
fclose(file_descriptor);
}
-void ReadFileToStringOrDie(const string &filename, string *data) {
+void ReadFileToStringOrDie(const string& filename, string* data) {
FILE* file_descriptor = fopen(filename.c_str(), "r");
if (!file_descriptor) {
@@ -63,10 +64,8 @@
// Read the data.
fseek(file_descriptor, 0L, SEEK_SET);
- int num_read = fread(&((*data)[0]),
- sizeof((*data)[0]),
- num_bytes,
- file_descriptor);
+ int num_read =
+ fread(&((*data)[0]), sizeof((*data)[0]), num_bytes, file_descriptor);
if (num_read != num_bytes) {
LOG(FATAL) << "Couldn't read all of " << filename
<< "expected bytes: " << num_bytes * sizeof((*data)[0])
@@ -77,9 +76,9 @@
string JoinPath(const string& dirname, const string& basename) {
#ifdef _WIN32
- static const char separator = '\\';
+ static const char separator = '\\';
#else
- static const char separator = '/';
+ static const char separator = '/';
#endif // _WIN32
if ((!basename.empty() && basename[0] == separator) || dirname.empty()) {
diff --git a/internal/ceres/file.h b/internal/ceres/file.h
index 219b459..30c0225 100644
--- a/internal/ceres/file.h
+++ b/internal/ceres/file.h
@@ -34,14 +34,15 @@
#define CERES_INTERNAL_FILE_H_
#include <string>
+
#include "ceres/internal/port.h"
namespace ceres {
namespace internal {
-void WriteStringToFileOrDie(const std::string &data,
- const std::string &filename);
-void ReadFileToStringOrDie(const std::string &filename, std::string *data);
+void WriteStringToFileOrDie(const std::string& data,
+ const std::string& filename);
+void ReadFileToStringOrDie(const std::string& filename, std::string* data);
// Join two path components, adding a slash if necessary. If basename is an
// absolute path then JoinPath ignores dirname and simply returns basename.
diff --git a/internal/ceres/fixed_array_test.cc b/internal/ceres/fixed_array_test.cc
index 95cba7f..d418786 100644
--- a/internal/ceres/fixed_array_test.cc
+++ b/internal/ceres/fixed_array_test.cc
@@ -15,6 +15,7 @@
#include "ceres/internal/fixed_array.h"
#include <stdio.h>
+
#include <cstring>
#include <list>
#include <memory>
diff --git a/internal/ceres/float_cxsparse.h b/internal/ceres/float_cxsparse.h
index 57fc5e4..9a274c2 100644
--- a/internal/ceres/float_cxsparse.h
+++ b/internal/ceres/float_cxsparse.h
@@ -37,6 +37,7 @@
#if !defined(CERES_NO_CXSPARSE)
#include <memory>
+
#include "ceres/sparse_cholesky.h"
namespace ceres {
@@ -46,8 +47,7 @@
// CXSparse.
class FloatCXSparseCholesky : public SparseCholesky {
public:
- static std::unique_ptr<SparseCholesky> Create(
- OrderingType ordering_type);
+ static std::unique_ptr<SparseCholesky> Create(OrderingType ordering_type);
};
} // namespace internal
diff --git a/internal/ceres/float_suitesparse.h b/internal/ceres/float_suitesparse.h
index ac4d409..c436da4 100644
--- a/internal/ceres/float_suitesparse.h
+++ b/internal/ceres/float_suitesparse.h
@@ -32,9 +32,12 @@
#define CERES_INTERNAL_FLOAT_SUITESPARSE_H_
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
#include <memory>
+
#include "ceres/sparse_cholesky.h"
#if !defined(CERES_NO_SUITESPARSE)
@@ -46,8 +49,7 @@
// SuiteSparse.
class FloatSuiteSparseCholesky : public SparseCholesky {
public:
- static std::unique_ptr<SparseCholesky> Create(
- OrderingType ordering_type);
+ static std::unique_ptr<SparseCholesky> Create(OrderingType ordering_type);
};
} // namespace internal
diff --git a/internal/ceres/function_sample.cc b/internal/ceres/function_sample.cc
index 2fd3dbd..3e0ae60 100644
--- a/internal/ceres/function_sample.cc
+++ b/internal/ceres/function_sample.cc
@@ -29,6 +29,7 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/function_sample.h"
+
#include "ceres/stringprintf.h"
namespace ceres {
@@ -64,9 +65,14 @@
gradient_is_valid(true) {}
std::string FunctionSample::ToDebugString() const {
- return StringPrintf("[x: %.8e, value: %.8e, gradient: %.8e, "
- "value_is_valid: %d, gradient_is_valid: %d]",
- x, value, gradient, value_is_valid, gradient_is_valid);
+ return StringPrintf(
+ "[x: %.8e, value: %.8e, gradient: %.8e, "
+ "value_is_valid: %d, gradient_is_valid: %d]",
+ x,
+ value,
+ gradient,
+ value_is_valid,
+ gradient_is_valid);
}
} // namespace internal
diff --git a/internal/ceres/function_sample.h b/internal/ceres/function_sample.h
index df79aef..8889f76 100644
--- a/internal/ceres/function_sample.h
+++ b/internal/ceres/function_sample.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_FUNCTION_SAMPLE_H_
#include <string>
+
#include "ceres/internal/eigen.h"
namespace ceres {
@@ -85,9 +86,6 @@
bool gradient_is_valid;
};
-
-
-
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/generated/.clang-format b/internal/ceres/generated/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/generated/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/generated_bundle_adjustment_tests/.clang-format b/internal/ceres/generated_bundle_adjustment_tests/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/generated_bundle_adjustment_tests/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/gmock/.clang-format b/internal/ceres/gmock/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/gmock/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/gradient_checker.cc b/internal/ceres/gradient_checker.cc
index ef56666..dadaaa0 100644
--- a/internal/ceres/gradient_checker.cc
+++ b/internal/ceres/gradient_checker.cc
@@ -56,7 +56,7 @@
// the local space of the respective local parameterizations.
bool EvaluateCostFunction(
const ceres::CostFunction* function,
- double const* const * parameters,
+ double const* const* parameters,
const std::vector<const ceres::LocalParameterization*>&
local_parameterizations,
Vector* residuals,
@@ -95,8 +95,8 @@
CHECK_NE(0, function->num_residuals());
residuals->resize(function->num_residuals());
residuals->setZero();
- if (!function->Evaluate(parameters, residuals->data(),
- jacobian_data.data())) {
+ if (!function->Evaluate(
+ parameters, residuals->data(), jacobian_data.data())) {
return false;
}
@@ -109,20 +109,20 @@
int local_size = local_parameterizations.at(i)->LocalSize();
CHECK_EQ(jacobians->at(i).cols(), global_size);
Matrix global_J_local(global_size, local_size);
- local_parameterizations.at(i)->ComputeJacobian(
- parameters[i], global_J_local.data());
+ local_parameterizations.at(i)->ComputeJacobian(parameters[i],
+ global_J_local.data());
local_jacobians->at(i).noalias() = jacobians->at(i) * global_J_local;
}
}
return true;
}
-} // namespace
+} // namespace
GradientChecker::GradientChecker(
- const CostFunction* function,
- const vector<const LocalParameterization*>* local_parameterizations,
- const NumericDiffOptions& options) :
- function_(function) {
+ const CostFunction* function,
+ const vector<const LocalParameterization*>* local_parameterizations,
+ const NumericDiffOptions& options)
+ : function_(function) {
CHECK(function != nullptr);
if (local_parameterizations != NULL) {
local_parameterizations_ = *local_parameterizations;
@@ -132,8 +132,8 @@
}
DynamicNumericDiffCostFunction<CostFunction, RIDDERS>*
finite_diff_cost_function =
- new DynamicNumericDiffCostFunction<CostFunction, RIDDERS>(
- function, DO_NOT_TAKE_OWNERSHIP, options);
+ new DynamicNumericDiffCostFunction<CostFunction, RIDDERS>(
+ function, DO_NOT_TAKE_OWNERSHIP, options);
finite_diff_cost_function_.reset(finite_diff_cost_function);
const vector<int32_t>& parameter_block_sizes =
@@ -145,7 +145,7 @@
finite_diff_cost_function->SetNumResiduals(function->num_residuals());
}
-bool GradientChecker::Probe(double const* const * parameters,
+bool GradientChecker::Probe(double const* const* parameters,
double relative_precision,
ProbeResults* results_param) const {
int num_residuals = function_->num_residuals();
@@ -171,8 +171,12 @@
// Evaluate the derivative using the user supplied code.
vector<Matrix>& jacobians = results->jacobians;
vector<Matrix>& local_jacobians = results->local_jacobians;
- if (!EvaluateCostFunction(function_, parameters, local_parameterizations_,
- &results->residuals, &jacobians, &local_jacobians)) {
+ if (!EvaluateCostFunction(function_,
+ parameters,
+ local_parameterizations_,
+ &results->residuals,
+ &jacobians,
+ &local_jacobians)) {
results->error_log = "Function evaluation with Jacobians failed.";
results->return_value = false;
}
@@ -181,10 +185,14 @@
vector<Matrix>& numeric_jacobians = results->numeric_jacobians;
vector<Matrix>& local_numeric_jacobians = results->local_numeric_jacobians;
Vector finite_diff_residuals;
- if (!EvaluateCostFunction(finite_diff_cost_function_.get(), parameters,
- local_parameterizations_, &finite_diff_residuals,
- &numeric_jacobians, &local_numeric_jacobians)) {
- results->error_log += "\nFunction evaluation with numerical "
+ if (!EvaluateCostFunction(finite_diff_cost_function_.get(),
+ parameters,
+ local_parameterizations_,
+ &finite_diff_residuals,
+ &numeric_jacobians,
+ &local_numeric_jacobians)) {
+ results->error_log +=
+ "\nFunction evaluation with numerical "
"differentiation failed.";
results->return_value = false;
}
@@ -194,13 +202,13 @@
}
for (int i = 0; i < num_residuals; ++i) {
- if (!IsClose(
- results->residuals[i],
- finite_diff_residuals[i],
- relative_precision,
- NULL,
- NULL)) {
- results->error_log = "Function evaluation with and without Jacobians "
+ if (!IsClose(results->residuals[i],
+ finite_diff_residuals[i],
+ relative_precision,
+ NULL,
+ NULL)) {
+ results->error_log =
+ "Function evaluation with and without Jacobians "
"resulted in different residuals.";
LOG(INFO) << results->residuals.transpose();
LOG(INFO) << finite_diff_residuals.transpose();
@@ -219,7 +227,7 @@
for (int k = 0; k < function_->parameter_block_sizes().size(); k++) {
StringAppendF(&error_log,
"========== "
- "Jacobian for " "block %d: (%ld by %ld)) "
+ "Jacobian for block %d: (%ld by %ld)) "
"==========\n",
k,
static_cast<long>(local_jacobians[k].rows()),
@@ -234,28 +242,33 @@
double term_jacobian = local_jacobians[k](i, j);
double finite_jacobian = local_numeric_jacobians[k](i, j);
double relative_error, absolute_error;
- bool bad_jacobian_entry =
- !IsClose(term_jacobian,
- finite_jacobian,
- relative_precision,
- &relative_error,
- &absolute_error);
+ bool bad_jacobian_entry = !IsClose(term_jacobian,
+ finite_jacobian,
+ relative_precision,
+ &relative_error,
+ &absolute_error);
worst_relative_error = std::max(worst_relative_error, relative_error);
StringAppendF(&error_log,
"%6d %4d %4d %17g %17g %17g %17g %17g %17g",
- k, i, j,
- term_jacobian, finite_jacobian,
- absolute_error, relative_error,
+ k,
+ i,
+ j,
+ term_jacobian,
+ finite_jacobian,
+ absolute_error,
+ relative_error,
parameters[k][j],
results->residuals[i]);
if (bad_jacobian_entry) {
num_bad_jacobian_components++;
- StringAppendF(
- &error_log,
- " ------ (%d,%d,%d) Relative error worse than %g",
- k, i, j, relative_precision);
+ StringAppendF(&error_log,
+ " ------ (%d,%d,%d) Relative error worse than %g",
+ k,
+ i,
+ j,
+ relative_precision);
}
error_log += "\n";
}
@@ -264,11 +277,12 @@
// Since there were some bad errors, dump comprehensive debug info.
if (num_bad_jacobian_components) {
- string header = StringPrintf("\nDetected %d bad Jacobian component(s). "
+ string header = StringPrintf(
+ "\nDetected %d bad Jacobian component(s). "
"Worst relative error was %g.\n",
num_bad_jacobian_components,
worst_relative_error);
- results->error_log = header + "\n" + error_log;
+ results->error_log = header + "\n" + error_log;
return false;
}
return true;
diff --git a/internal/ceres/gradient_checker_test.cc b/internal/ceres/gradient_checker_test.cc
index b2dd35e..31dc97b 100644
--- a/internal/ceres/gradient_checker_test.cc
+++ b/internal/ceres/gradient_checker_test.cc
@@ -169,8 +169,6 @@
vector<vector<double>> a_; // our vectors.
};
-
-
static void CheckDimensions(const GradientChecker::ProbeResults& results,
const std::vector<int>& parameter_sizes,
const std::vector<int>& local_parameter_sizes,
diff --git a/internal/ceres/gradient_checking_cost_function.cc b/internal/ceres/gradient_checking_cost_function.cc
index 13d6c58..2eb6d62 100644
--- a/internal/ceres/gradient_checking_cost_function.cc
+++ b/internal/ceres/gradient_checking_cost_function.cc
@@ -38,6 +38,7 @@
#include <string>
#include <vector>
+#include "ceres/dynamic_numeric_diff_cost_function.h"
#include "ceres/gradient_checker.h"
#include "ceres/internal/eigen.h"
#include "ceres/parameter_block.h"
@@ -45,7 +46,6 @@
#include "ceres/problem_impl.h"
#include "ceres/program.h"
#include "ceres/residual_block.h"
-#include "ceres/dynamic_numeric_diff_cost_function.h"
#include "ceres/stringprintf.h"
#include "ceres/types.h"
#include "glog/logging.h"
@@ -81,7 +81,7 @@
set_num_residuals(function->num_residuals());
}
- virtual ~GradientCheckingCostFunction() { }
+ virtual ~GradientCheckingCostFunction() {}
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -92,9 +92,8 @@
}
GradientChecker::ProbeResults results;
- bool okay = gradient_checker_.Probe(parameters,
- relative_precision_,
- &results);
+ bool okay =
+ gradient_checker_.Probe(parameters, relative_precision_, &results);
// If the cost function returned false, there's nothing we can say about
// the gradients.
@@ -117,8 +116,9 @@
}
if (!okay) {
- std::string error_log = "Gradient Error detected!\nExtra info for "
- "this residual: " + extra_info_ + "\n" + results.error_log;
+ std::string error_log =
+ "Gradient Error detected!\nExtra info for this residual: " +
+ extra_info_ + "\n" + results.error_log;
callback_->SetGradientErrorDetected(error_log);
}
return true;
@@ -135,13 +135,12 @@
} // namespace
GradientCheckingIterationCallback::GradientCheckingIterationCallback()
- : gradient_error_detected_(false) {
-}
+ : gradient_error_detected_(false) {}
CallbackReturnType GradientCheckingIterationCallback::operator()(
const IterationSummary& summary) {
if (gradient_error_detected_) {
- LOG(ERROR)<< "Gradient error detected. Terminating solver.";
+ LOG(ERROR) << "Gradient error detected. Terminating solver.";
return SOLVER_ABORT;
}
return SOLVER_CONTINUE;
@@ -166,7 +165,8 @@
return new GradientCheckingCostFunction(cost_function,
local_parameterizations,
numeric_diff_options,
- relative_precision, extra_info,
+ relative_precision,
+ extra_info,
callback);
}
@@ -193,8 +193,8 @@
NumericDiffOptions numeric_diff_options;
numeric_diff_options.relative_step_size = relative_step_size;
- ProblemImpl* gradient_checking_problem_impl = new ProblemImpl(
- gradient_checking_problem_options);
+ ProblemImpl* gradient_checking_problem_impl =
+ new ProblemImpl(gradient_checking_problem_options);
Program* program = problem_impl->mutable_program();
@@ -213,7 +213,7 @@
parameter_block->mutable_user_state());
}
- for (int i = 0; i < parameter_block->Size(); ++i) {
+ for (int i = 0; i < parameter_block->Size(); ++i) {
gradient_checking_problem_impl->SetParameterUpperBound(
parameter_block->mutable_user_state(),
i,
@@ -235,8 +235,8 @@
// Build a human readable string which identifies the
// ResidualBlock. This is used by the GradientCheckingCostFunction
// when logging debugging information.
- string extra_info = StringPrintf(
- "Residual block id %d; depends on parameters [", i);
+ string extra_info =
+ StringPrintf("Residual block id %d; depends on parameters [", i);
vector<double*> parameter_blocks;
vector<const LocalParameterization*> local_parameterizations;
parameter_blocks.reserve(residual_block->NumParameterBlocks());
@@ -277,13 +277,11 @@
// depend on this being the case, so we explicitly call
// SetParameterBlockStatePtrsToUserStatePtrs to ensure that this is
// the case.
- gradient_checking_problem_impl
- ->mutable_program()
+ gradient_checking_problem_impl->mutable_program()
->SetParameterBlockStatePtrsToUserStatePtrs();
return gradient_checking_problem_impl;
}
-
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/gradient_checking_cost_function.h b/internal/ceres/gradient_checking_cost_function.h
index e9a34f7..ab6e9f8 100644
--- a/internal/ceres/gradient_checking_cost_function.h
+++ b/internal/ceres/gradient_checking_cost_function.h
@@ -60,6 +60,7 @@
// Retrieve error status (not thread safe).
bool gradient_error_detected() const { return gradient_error_detected_; }
const std::string& error_log() const { return error_log_; }
+
private:
bool gradient_error_detected_;
std::string error_log_;
diff --git a/internal/ceres/gradient_checking_cost_function_test.cc b/internal/ceres/gradient_checking_cost_function_test.cc
index ff211ed..9ca51f8 100644
--- a/internal/ceres/gradient_checking_cost_function_test.cc
+++ b/internal/ceres/gradient_checking_cost_function_test.cc
@@ -53,10 +53,10 @@
namespace internal {
using std::vector;
+using testing::_;
using testing::AllOf;
using testing::AnyNumber;
using testing::HasSubstr;
-using testing::_;
// Pick a (non-quadratic) function whose derivative are easy:
//
@@ -65,12 +65,12 @@
//
// where 'a' is a vector of the same size as 'x'. In the block
// version, they are both block vectors, of course.
-template<int bad_block = 1, int bad_variable = 2>
+template <int bad_block = 1, int bad_variable = 2>
class TestTerm : public CostFunction {
public:
// The constructor of this function needs to know the number
// of blocks desired, and the size of each block.
- TestTerm(int arity, int const *dim) : arity_(arity) {
+ TestTerm(int arity, int const* dim) : arity_(arity) {
// Make 'arity' random vectors.
a_.resize(arity_);
for (int j = 0; j < arity_; ++j) {
@@ -107,7 +107,7 @@
if (jacobians[j]) {
for (int u = 0; u < parameter_block_sizes()[j]; ++u) {
// See comments before class.
- jacobians[j][u] = - f * a_[j][u];
+ jacobians[j][u] = -f * a_[j][u];
if (bad_block == j && bad_variable == u) {
// Whoopsiedoopsie! Deliberately introduce a faulty jacobian entry
@@ -135,7 +135,7 @@
// Test with 3 blocks of size 2, 3 and 4.
int const arity = 3;
- int const dim[arity] = { 2, 3, 4 };
+ int const dim[arity] = {2, 3, 4};
// Make a random set of blocks.
vector<double*> parameters(arity);
@@ -164,17 +164,16 @@
TestTerm<-1, -1> term(arity, dim);
GradientCheckingIterationCallback callback;
std::unique_ptr<CostFunction> gradient_checking_cost_function(
- CreateGradientCheckingCostFunction(&term, NULL,
+ CreateGradientCheckingCostFunction(&term,
+ NULL,
kRelativeStepSize,
kRelativePrecision,
- "Ignored.", &callback));
- term.Evaluate(¶meters[0],
- &original_residual,
- &original_jacobians[0]);
+ "Ignored.",
+ &callback));
+ term.Evaluate(¶meters[0], &original_residual, &original_jacobians[0]);
- gradient_checking_cost_function->Evaluate(¶meters[0],
- &residual,
- &jacobians[0]);
+ gradient_checking_cost_function->Evaluate(
+ ¶meters[0], &residual, &jacobians[0]);
EXPECT_EQ(original_residual, residual);
for (int j = 0; j < arity; j++) {
@@ -193,7 +192,7 @@
// Test with 3 blocks of size 2, 3 and 4.
int const arity = 3;
- int const dim[arity] = { 2, 3, 4 };
+ int const dim[arity] = {2, 3, 4};
// Make a random set of blocks.
vector<double*> parameters(arity);
@@ -221,17 +220,18 @@
TestTerm<1, 2> term(arity, dim);
GradientCheckingIterationCallback callback;
std::unique_ptr<CostFunction> gradient_checking_cost_function(
- CreateGradientCheckingCostFunction(&term, NULL,
+ CreateGradientCheckingCostFunction(&term,
+ NULL,
kRelativeStepSize,
kRelativePrecision,
- "Fuzzy banana", &callback));
- EXPECT_TRUE(
- gradient_checking_cost_function->Evaluate(¶meters[0], &residual,
- &jacobians[0]));
+ "Fuzzy banana",
+ &callback));
+ EXPECT_TRUE(gradient_checking_cost_function->Evaluate(
+ ¶meters[0], &residual, &jacobians[0]));
EXPECT_TRUE(callback.gradient_error_detected());
EXPECT_TRUE(callback.error_log().find("Fuzzy banana") != std::string::npos);
- EXPECT_TRUE(callback.error_log().find("(1,0,2) Relative error worse than")
- != std::string::npos);
+ EXPECT_TRUE(callback.error_log().find(
+ "(1,0,2) Relative error worse than") != std::string::npos);
}
// The gradient is correct, so no errors are reported.
@@ -240,13 +240,14 @@
TestTerm<-1, -1> term(arity, dim);
GradientCheckingIterationCallback callback;
std::unique_ptr<CostFunction> gradient_checking_cost_function(
- CreateGradientCheckingCostFunction(&term, NULL,
+ CreateGradientCheckingCostFunction(&term,
+ NULL,
kRelativeStepSize,
kRelativePrecision,
- "Fuzzy banana", &callback));
- EXPECT_TRUE(
- gradient_checking_cost_function->Evaluate(¶meters[0], &residual,
- &jacobians[0]));
+ "Fuzzy banana",
+ &callback));
+ EXPECT_TRUE(gradient_checking_cost_function->Evaluate(
+ ¶meters[0], &residual, &jacobians[0]));
EXPECT_FALSE(callback.gradient_error_detected());
}
@@ -279,7 +280,7 @@
};
// Trivial cost function that accepts two arguments.
-class BinaryCostFunction: public CostFunction {
+class BinaryCostFunction : public CostFunction {
public:
BinaryCostFunction(int num_residuals,
int32_t parameter_block1_size,
@@ -300,7 +301,7 @@
};
// Trivial cost function that accepts three arguments.
-class TernaryCostFunction: public CostFunction {
+class TernaryCostFunction : public CostFunction {
public:
TernaryCostFunction(int num_residuals,
int32_t parameter_block1_size,
@@ -324,7 +325,7 @@
// Verify that the two ParameterBlocks are formed from the same user
// array and have the same LocalParameterization object.
-static void ParameterBlocksAreEquivalent(const ParameterBlock* left,
+static void ParameterBlocksAreEquivalent(const ParameterBlock* left,
const ParameterBlock* right) {
CHECK(left != nullptr);
CHECK(right != nullptr);
@@ -349,8 +350,10 @@
problem_impl.SetParameterBlockConstant(y);
problem_impl.AddParameterBlock(z, 5);
problem_impl.AddParameterBlock(w, 4, new QuaternionParameterization);
- problem_impl.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
- problem_impl.AddResidualBlock(new BinaryCostFunction(6, 5, 4) ,
+ // clang-format off
+ problem_impl.AddResidualBlock(new UnaryCostFunction(2, 3),
+ NULL, x);
+ problem_impl.AddResidualBlock(new BinaryCostFunction(6, 5, 4),
NULL, z, y);
problem_impl.AddResidualBlock(new BinaryCostFunction(3, 3, 5),
new TrivialLoss, x, z);
@@ -358,6 +361,7 @@
NULL, z, x);
problem_impl.AddResidualBlock(new TernaryCostFunction(1, 5, 3, 4),
NULL, z, x, y);
+ // clang-format on
GradientCheckingIterationCallback callback;
std::unique_ptr<ProblemImpl> gradient_checking_problem_impl(
@@ -392,8 +396,7 @@
for (int i = 0; i < program.residual_blocks().size(); ++i) {
// Compare the sizes of the two ResidualBlocks.
- const ResidualBlock* original_residual_block =
- program.residual_blocks()[i];
+ const ResidualBlock* original_residual_block = program.residual_blocks()[i];
const ResidualBlock* new_residual_block =
gradient_checking_program.residual_blocks()[i];
EXPECT_EQ(original_residual_block->NumParameterBlocks(),
@@ -412,15 +415,14 @@
}
}
-
TEST(GradientCheckingProblemImpl, ConstrainedProblemBoundsArePropagated) {
// Parameter blocks with arbitrarily chosen initial values.
double x[] = {1.0, 2.0, 3.0};
ProblemImpl problem_impl;
problem_impl.AddParameterBlock(x, 3);
problem_impl.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
- problem_impl.SetParameterLowerBound(x,0,0.9);
- problem_impl.SetParameterUpperBound(x,1,2.5);
+ problem_impl.SetParameterLowerBound(x, 0, 0.9);
+ problem_impl.SetParameterUpperBound(x, 1, 2.5);
GradientCheckingIterationCallback callback;
std::unique_ptr<ProblemImpl> gradient_checking_problem_impl(
diff --git a/internal/ceres/gradient_problem.cc b/internal/ceres/gradient_problem.cc
index 4ebd3e6..ba33fbc 100644
--- a/internal/ceres/gradient_problem.cc
+++ b/internal/ceres/gradient_problem.cc
@@ -29,6 +29,7 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/gradient_problem.h"
+
#include "ceres/local_parameterization.h"
#include "glog/logging.h"
@@ -38,14 +39,13 @@
: function_(function),
parameterization_(
new IdentityParameterization(function_->NumParameters())),
- scratch_(new double[function_->NumParameters()]) {
-}
+ scratch_(new double[function_->NumParameters()]) {}
GradientProblem::GradientProblem(FirstOrderFunction* function,
LocalParameterization* parameterization)
- : function_(function),
- parameterization_(parameterization),
- scratch_(new double[function_->NumParameters()]) {
+ : function_(function),
+ parameterization_(parameterization),
+ scratch_(new double[function_->NumParameters()]) {
CHECK_EQ(function_->NumParameters(), parameterization_->GlobalSize());
}
@@ -57,7 +57,6 @@
return parameterization_->LocalSize();
}
-
bool GradientProblem::Evaluate(const double* parameters,
double* cost,
double* gradient) const {
@@ -66,10 +65,8 @@
}
return (function_->Evaluate(parameters, cost, scratch_.get()) &&
- parameterization_->MultiplyByJacobian(parameters,
- 1,
- scratch_.get(),
- gradient));
+ parameterization_->MultiplyByJacobian(
+ parameters, 1, scratch_.get(), gradient));
}
bool GradientProblem::Plus(const double* x,
diff --git a/internal/ceres/gradient_problem_evaluator.h b/internal/ceres/gradient_problem_evaluator.h
index c5ad1d7..d224dbe 100644
--- a/internal/ceres/gradient_problem_evaluator.h
+++ b/internal/ceres/gradient_problem_evaluator.h
@@ -76,9 +76,7 @@
return problem_.Plus(state, delta, state_plus_delta);
}
- int NumParameters() const final {
- return problem_.NumParameters();
- }
+ int NumParameters() const final { return problem_.NumParameters(); }
int NumEffectiveParameters() const final {
return problem_.NumLocalParameters();
diff --git a/internal/ceres/gradient_problem_solver.cc b/internal/ceres/gradient_problem_solver.cc
index 1639e30..b72fad9 100644
--- a/internal/ceres/gradient_problem_solver.cc
+++ b/internal/ceres/gradient_problem_solver.cc
@@ -31,6 +31,7 @@
#include "ceres/gradient_problem_solver.h"
#include <memory>
+
#include "ceres/callbacks.h"
#include "ceres/gradient_problem.h"
#include "ceres/gradient_problem_evaluator.h"
@@ -45,8 +46,8 @@
#include "ceres/wall_time.h"
namespace ceres {
-using internal::StringPrintf;
using internal::StringAppendF;
+using internal::StringPrintf;
using std::string;
namespace {
@@ -83,7 +84,6 @@
#undef COPY_OPTION
}
-
} // namespace
bool GradientProblemSolver::Options::IsValid(std::string* error) const {
@@ -92,8 +92,7 @@
return solver_options.IsValid(error);
}
-GradientProblemSolver::~GradientProblemSolver() {
-}
+GradientProblemSolver::~GradientProblemSolver() {}
void GradientProblemSolver::Solve(const GradientProblemSolver::Options& options,
const GradientProblem& problem,
@@ -111,6 +110,7 @@
CHECK(summary != nullptr);
*summary = Summary();
+ // clang-format off
summary->num_parameters = problem.NumParameters();
summary->num_local_parameters = problem.NumLocalParameters();
summary->line_search_direction_type = options.line_search_direction_type; // NOLINT
@@ -118,6 +118,7 @@
summary->line_search_type = options.line_search_type;
summary->max_lbfgs_rank = options.max_lbfgs_rank;
summary->nonlinear_conjugate_gradient_type = options.nonlinear_conjugate_gradient_type; // NOLINT
+ // clang-format on
// Check validity
if (!options.IsValid(&summary->message)) {
@@ -163,11 +164,13 @@
minimizer->Minimize(minimizer_options, solution.data(), &solver_summary);
+ // clang-format off
summary->termination_type = solver_summary.termination_type;
summary->message = solver_summary.message;
summary->initial_cost = solver_summary.initial_cost;
summary->final_cost = solver_summary.final_cost;
summary->iterations = solver_summary.iterations;
+ // clang-format on
summary->line_search_polynomial_minimization_time_in_seconds =
solver_summary.line_search_polynomial_minimization_time_in_seconds;
@@ -200,15 +203,16 @@
}
string GradientProblemSolver::Summary::BriefReport() const {
- return StringPrintf("Ceres GradientProblemSolver Report: "
- "Iterations: %d, "
- "Initial cost: %e, "
- "Final cost: %e, "
- "Termination: %s",
- static_cast<int>(iterations.size()),
- initial_cost,
- final_cost,
- TerminationTypeToString(termination_type));
+ return StringPrintf(
+ "Ceres GradientProblemSolver Report: "
+ "Iterations: %d, "
+ "Initial cost: %e, "
+ "Final cost: %e, "
+ "Termination: %s",
+ static_cast<int>(iterations.size()),
+ initial_cost,
+ final_cost,
+ TerminationTypeToString(termination_type));
}
string GradientProblemSolver::Summary::FullReport() const {
@@ -218,60 +222,63 @@
StringAppendF(&report, "Parameters % 25d\n", num_parameters);
if (num_local_parameters != num_parameters) {
- StringAppendF(&report, "Local parameters % 25d\n",
- num_local_parameters);
+ StringAppendF(&report, "Local parameters % 25d\n", num_local_parameters);
}
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) {
- line_search_direction_string =
- NonlinearConjugateGradientTypeToString(
- nonlinear_conjugate_gradient_type);
+ line_search_direction_string = NonlinearConjugateGradientTypeToString(
+ nonlinear_conjugate_gradient_type);
} else {
line_search_direction_string =
LineSearchDirectionTypeToString(line_search_direction_type);
}
- StringAppendF(&report, "Line search direction %19s\n",
+ StringAppendF(&report,
+ "Line search direction %19s\n",
line_search_direction_string.c_str());
- const string line_search_type_string =
- StringPrintf("%s %s",
- LineSearchInterpolationTypeToString(
- line_search_interpolation_type),
- LineSearchTypeToString(line_search_type));
- StringAppendF(&report, "Line search type %19s\n",
+ const string line_search_type_string = StringPrintf(
+ "%s %s",
+ LineSearchInterpolationTypeToString(line_search_interpolation_type),
+ LineSearchTypeToString(line_search_type));
+ StringAppendF(&report,
+ "Line search type %19s\n",
line_search_type_string.c_str());
StringAppendF(&report, "\n");
StringAppendF(&report, "\nCost:\n");
StringAppendF(&report, "Initial % 30e\n", initial_cost);
- if (termination_type != FAILURE &&
- termination_type != USER_FAILURE) {
+ if (termination_type != FAILURE && termination_type != USER_FAILURE) {
StringAppendF(&report, "Final % 30e\n", final_cost);
- StringAppendF(&report, "Change % 30e\n",
- initial_cost - final_cost);
+ StringAppendF(&report, "Change % 30e\n", initial_cost - final_cost);
}
- StringAppendF(&report, "\nMinimizer iterations % 16d\n",
+ StringAppendF(&report,
+ "\nMinimizer iterations % 16d\n",
static_cast<int>(iterations.size()));
StringAppendF(&report, "\nTime (in seconds):\n");
- StringAppendF(&report, "\n Cost evaluation %23.6f (%d)\n",
+ StringAppendF(&report,
+ "\n Cost evaluation %23.6f (%d)\n",
cost_evaluation_time_in_seconds,
num_cost_evaluations);
- StringAppendF(&report, " Gradient & cost evaluation %16.6f (%d)\n",
+ StringAppendF(&report,
+ " Gradient & cost evaluation %16.6f (%d)\n",
gradient_evaluation_time_in_seconds,
num_gradient_evaluations);
- StringAppendF(&report, " Polynomial minimization %17.6f\n",
+ StringAppendF(&report,
+ " Polynomial minimization %17.6f\n",
line_search_polynomial_minimization_time_in_seconds);
- StringAppendF(&report, "Total %25.6f\n\n",
- total_time_in_seconds);
+ StringAppendF(
+ &report, "Total %25.6f\n\n", total_time_in_seconds);
- StringAppendF(&report, "Termination: %25s (%s)\n",
- TerminationTypeToString(termination_type), message.c_str());
+ StringAppendF(&report,
+ "Termination: %25s (%s)\n",
+ TerminationTypeToString(termination_type),
+ message.c_str());
return report;
}
diff --git a/internal/ceres/gradient_problem_solver_test.cc b/internal/ceres/gradient_problem_solver_test.cc
index 1a08c48..f01d206 100644
--- a/internal/ceres/gradient_problem_solver_test.cc
+++ b/internal/ceres/gradient_problem_solver_test.cc
@@ -28,9 +28,9 @@
//
// Author: strandmark@google.com (Petter Strandmark)
-#include "ceres/gradient_problem.h"
#include "ceres/gradient_problem_solver.h"
+#include "ceres/gradient_problem.h"
#include "gtest/gtest.h"
namespace ceres {
@@ -89,18 +89,17 @@
};
struct RememberingCallback : public IterationCallback {
- explicit RememberingCallback(double *x) : calls(0), x(x) {}
+ explicit RememberingCallback(double* x) : calls(0), x(x) {}
virtual ~RememberingCallback() {}
CallbackReturnType operator()(const IterationSummary& summary) final {
x_values.push_back(*x);
return SOLVER_CONTINUE;
}
int calls;
- double *x;
+ double* x;
std::vector<double> x_values;
};
-
TEST(Solver, UpdateStateEveryIterationOption) {
double x = 50.0;
const double original_x = x;
diff --git a/internal/ceres/gradient_problem_test.cc b/internal/ceres/gradient_problem_test.cc
index 640cf5f..8934138 100644
--- a/internal/ceres/gradient_problem_test.cc
+++ b/internal/ceres/gradient_problem_test.cc
@@ -65,9 +65,7 @@
TEST(GradientProblem, TakesOwnershipOfFirstOrderFunction) {
bool is_destructed = false;
- {
- ceres::GradientProblem problem(new QuadraticTestFunction(&is_destructed));
- }
+ { ceres::GradientProblem problem(new QuadraticTestFunction(&is_destructed)); }
EXPECT_TRUE(is_destructed);
}
diff --git a/internal/ceres/graph.h b/internal/ceres/graph.h
index 4e1fd81..9b26158 100644
--- a/internal/ceres/graph.h
+++ b/internal/ceres/graph.h
@@ -32,9 +32,10 @@
#define CERES_INTERNAL_GRAPH_H_
#include <limits>
-#include <unordered_set>
#include <unordered_map>
+#include <unordered_set>
#include <utility>
+
#include "ceres/map_util.h"
#include "ceres/pair_hash.h"
#include "ceres/types.h"
@@ -93,9 +94,7 @@
return FindOrDie(edges_, vertex);
}
- const std::unordered_set<Vertex>& vertices() const {
- return vertices_;
- }
+ const std::unordered_set<Vertex>& vertices() const { return vertices_; }
private:
std::unordered_set<Vertex> vertices_;
@@ -121,9 +120,7 @@
// Uses weight = 1.0. If vertex already exists, its weight is set to
// 1.0.
- void AddVertex(const Vertex& vertex) {
- AddVertex(vertex, 1.0);
- }
+ void AddVertex(const Vertex& vertex) { AddVertex(vertex, 1.0); }
bool RemoveVertex(const Vertex& vertex) {
if (vertices_.find(vertex) == vertices_.end()) {
@@ -184,11 +181,11 @@
// the edge weight is zero.
double EdgeWeight(const Vertex& vertex1, const Vertex& vertex2) const {
if (vertex1 < vertex2) {
- return FindWithDefault(edge_weights_,
- std::make_pair(vertex1, vertex2), 0.0);
+ return FindWithDefault(
+ edge_weights_, std::make_pair(vertex1, vertex2), 0.0);
} else {
- return FindWithDefault(edge_weights_,
- std::make_pair(vertex2, vertex1), 0.0);
+ return FindWithDefault(
+ edge_weights_, std::make_pair(vertex2, vertex1), 0.0);
}
}
@@ -198,9 +195,7 @@
return FindOrDie(edges_, vertex);
}
- const std::unordered_set<Vertex>& vertices() const {
- return vertices_;
- }
+ const std::unordered_set<Vertex>& vertices() const { return vertices_; }
static double InvalidWeight() {
return std::numeric_limits<double>::quiet_NaN();
diff --git a/internal/ceres/graph_algorithms.h b/internal/ceres/graph_algorithms.h
index b062931..7d63b33 100644
--- a/internal/ceres/graph_algorithms.h
+++ b/internal/ceres/graph_algorithms.h
@@ -36,8 +36,9 @@
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
-#include <vector>
#include <utility>
+#include <vector>
+
#include "ceres/graph.h"
#include "ceres/wall_time.h"
#include "glog/logging.h"
@@ -50,8 +51,7 @@
template <typename Vertex>
class VertexTotalOrdering {
public:
- explicit VertexTotalOrdering(const Graph<Vertex>& graph)
- : graph_(graph) {}
+ explicit VertexTotalOrdering(const Graph<Vertex>& graph) : graph_(graph) {}
bool operator()(const Vertex& lhs, const Vertex& rhs) const {
if (graph_.Neighbors(lhs).size() == graph_.Neighbors(rhs).size()) {
@@ -67,8 +67,7 @@
template <typename Vertex>
class VertexDegreeLessThan {
public:
- explicit VertexDegreeLessThan(const Graph<Vertex>& graph)
- : graph_(graph) {}
+ explicit VertexDegreeLessThan(const Graph<Vertex>& graph) : graph_(graph) {}
bool operator()(const Vertex& lhs, const Vertex& rhs) const {
return graph_.Neighbors(lhs).size() < graph_.Neighbors(rhs).size();
@@ -177,8 +176,9 @@
std::vector<Vertex> vertex_queue(*ordering);
- std::stable_sort(vertex_queue.begin(), vertex_queue.end(),
- VertexDegreeLessThan<Vertex>(graph));
+ std::stable_sort(vertex_queue.begin(),
+ vertex_queue.end(),
+ VertexDegreeLessThan<Vertex>(graph));
// Mark all vertices white.
std::unordered_map<Vertex, char> vertex_color;
@@ -257,8 +257,8 @@
// spanning forest, or a collection of linear paths that span the
// graph G.
template <typename Vertex>
-WeightedGraph<Vertex>*
-Degree2MaximumSpanningForest(const WeightedGraph<Vertex>& graph) {
+WeightedGraph<Vertex>* Degree2MaximumSpanningForest(
+ const WeightedGraph<Vertex>& graph) {
// Array of edges sorted in decreasing order of their weights.
std::vector<std::pair<double, std::pair<Vertex, Vertex>>> weighted_edges;
WeightedGraph<Vertex>* forest = new WeightedGraph<Vertex>();
@@ -294,7 +294,7 @@
// Greedily add edges to the spanning tree/forest as long as they do
// not violate the degree/cycle constraint.
- for (int i =0; i < weighted_edges.size(); ++i) {
+ for (int i = 0; i < weighted_edges.size(); ++i) {
const std::pair<Vertex, Vertex>& edge = weighted_edges[i].second;
const Vertex vertex1 = edge.first;
const Vertex vertex2 = edge.second;
diff --git a/internal/ceres/graph_algorithms_test.cc b/internal/ceres/graph_algorithms_test.cc
index 2aef327..d5dd02e 100644
--- a/internal/ceres/graph_algorithms_test.cc
+++ b/internal/ceres/graph_algorithms_test.cc
@@ -111,8 +111,8 @@
graph.AddEdge(0, 1, 0.5);
graph.AddEdge(1, 0, 0.5);
- std::unique_ptr<WeightedGraph<int> > forest(
- Degree2MaximumSpanningForest(graph));
+ std::unique_ptr<WeightedGraph<int>> forest(
+ Degree2MaximumSpanningForest(graph));
const std::unordered_set<int>& vertices = forest->vertices();
EXPECT_EQ(vertices.size(), 2);
@@ -135,7 +135,8 @@
graph.AddEdge(0, 3, 3.0);
graph.AddEdge(0, 4, 4.0);
- std::unique_ptr<WeightedGraph<int> > forest(Degree2MaximumSpanningForest(graph));
+ std::unique_ptr<WeightedGraph<int>> forest(
+ Degree2MaximumSpanningForest(graph));
const std::unordered_set<int>& vertices = forest->vertices();
EXPECT_EQ(vertices.size(), 5);
@@ -200,7 +201,6 @@
}
}
-
TEST(StableIndependentSet, BreakTies) {
Graph<int> graph;
graph.AddVertex(0);
diff --git a/internal/ceres/graph_test.cc b/internal/ceres/graph_test.cc
index 8f05475..2154a06 100644
--- a/internal/ceres/graph_test.cc
+++ b/internal/ceres/graph_test.cc
@@ -31,6 +31,7 @@
#include "ceres/graph.h"
#include <unordered_set>
+
#include "gtest/gtest.h"
namespace ceres {
diff --git a/internal/ceres/gtest/.clang-format b/internal/ceres/gtest/.clang-format
new file mode 100644
index 0000000..9d15924
--- /dev/null
+++ b/internal/ceres/gtest/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false
diff --git a/internal/ceres/householder_vector_test.cc b/internal/ceres/householder_vector_test.cc
index 10b3e88..6f3b172 100644
--- a/internal/ceres/householder_vector_test.cc
+++ b/internal/ceres/householder_vector_test.cc
@@ -29,6 +29,7 @@
// Author: vitus@google.com (Michael Vitus)
#include "ceres/internal/householder_vector.h"
+
#include "ceres/internal/eigen.h"
#include "glog/logging.h"
#include "gtest/gtest.h"
diff --git a/internal/ceres/implicit_schur_complement.cc b/internal/ceres/implicit_schur_complement.cc
index bf680d1..f2196d4 100644
--- a/internal/ceres/implicit_schur_complement.cc
+++ b/internal/ceres/implicit_schur_complement.cc
@@ -43,13 +43,9 @@
ImplicitSchurComplement::ImplicitSchurComplement(
const LinearSolver::Options& options)
- : options_(options),
- D_(NULL),
- b_(NULL) {
-}
+ : options_(options), D_(NULL), b_(NULL) {}
-ImplicitSchurComplement::~ImplicitSchurComplement() {
-}
+ImplicitSchurComplement::~ImplicitSchurComplement() {}
void ImplicitSchurComplement::Init(const BlockSparseMatrix& A,
const double* D,
@@ -88,7 +84,7 @@
// the block diagonals and invert them.
AddDiagonalAndInvert(D_, block_diagonal_EtE_inverse_.get());
if (options_.preconditioner_type == JACOBI) {
- AddDiagonalAndInvert((D_ == NULL) ? NULL : D_ + A_->num_cols_e(),
+ AddDiagonalAndInvert((D_ == NULL) ? NULL : D_ + A_->num_cols_e(),
block_diagonal_FtF_inverse_.get());
}
@@ -125,8 +121,8 @@
if (D_ != NULL) {
ConstVectorRef Dref(D_ + A_->num_cols_e(), num_cols());
VectorRef(y, num_cols()) =
- (Dref.array().square() *
- ConstVectorRef(x, num_cols()).array()).matrix();
+ (Dref.array().square() * ConstVectorRef(x, num_cols()).array())
+ .matrix();
} else {
VectorRef(y, num_cols()).setZero();
}
@@ -139,8 +135,7 @@
// entries D, add them to the diagonal of the matrix and compute the
// inverse of each diagonal block.
void ImplicitSchurComplement::AddDiagonalAndInvert(
- const double* D,
- BlockSparseMatrix* block_diagonal) {
+ const double* D, BlockSparseMatrix* block_diagonal) {
const CompressedRowBlockStructure* block_diagonal_structure =
block_diagonal->block_structure();
for (int r = 0; r < block_diagonal_structure->rows.size(); ++r) {
@@ -148,17 +143,16 @@
const int row_block_size = block_diagonal_structure->rows[r].block.size;
const Cell& cell = block_diagonal_structure->rows[r].cells[0];
MatrixRef m(block_diagonal->mutable_values() + cell.position,
- row_block_size, row_block_size);
+ row_block_size,
+ row_block_size);
if (D != NULL) {
ConstVectorRef d(D + row_block_pos, row_block_size);
m += d.array().square().matrix().asDiagonal();
}
- m = m
- .selfadjointView<Eigen::Upper>()
- .llt()
- .solve(Matrix::Identity(row_block_size, row_block_size));
+ m = m.selfadjointView<Eigen::Upper>().llt().solve(
+ Matrix::Identity(row_block_size, row_block_size));
}
}
@@ -167,7 +161,7 @@
void ImplicitSchurComplement::BackSubstitute(const double* x, double* y) {
const int num_cols_e = A_->num_cols_e();
const int num_cols_f = A_->num_cols_f();
- const int num_cols = A_->num_cols();
+ const int num_cols = A_->num_cols();
const int num_rows = A_->num_rows();
// y1 = F x
@@ -190,7 +184,7 @@
// computed via back substitution. The second block of variables
// corresponds to the Schur complement system, so we just copy those
// values from the solution to the Schur complement.
- VectorRef(y + num_cols_e, num_cols_f) = ConstVectorRef(x, num_cols_f);
+ VectorRef(y + num_cols_e, num_cols_f) = ConstVectorRef(x, num_cols_f);
}
// Compute the RHS of the Schur complement system.
diff --git a/internal/ceres/implicit_schur_complement.h b/internal/ceres/implicit_schur_complement.h
index f4ddf72..cc22f24 100644
--- a/internal/ceres/implicit_schur_complement.h
+++ b/internal/ceres/implicit_schur_complement.h
@@ -35,10 +35,11 @@
#define CERES_INTERNAL_IMPLICIT_SCHUR_COMPLEMENT_H_
#include <memory>
+
+#include "ceres/internal/eigen.h"
#include "ceres/linear_operator.h"
#include "ceres/linear_solver.h"
#include "ceres/partitioned_matrix_view.h"
-#include "ceres/internal/eigen.h"
#include "ceres/types.h"
namespace ceres {
@@ -129,7 +130,7 @@
int num_rows() const final { return A_->num_cols_f(); }
int num_cols() const final { return A_->num_cols_f(); }
- const Vector& rhs() const { return rhs_; }
+ const Vector& rhs() const { return rhs_; }
const BlockSparseMatrix* block_diagonal_EtE_inverse() const {
return block_diagonal_EtE_inverse_.get();
diff --git a/internal/ceres/implicit_schur_complement_test.cc b/internal/ceres/implicit_schur_complement_test.cc
index 4e3a598..b6d886f 100644
--- a/internal/ceres/implicit_schur_complement_test.cc
+++ b/internal/ceres/implicit_schur_complement_test.cc
@@ -32,6 +32,7 @@
#include <cstddef>
#include <memory>
+
#include "Eigen/Dense"
#include "ceres/block_random_access_dense_matrix.h"
#include "ceres/block_sparse_matrix.h"
@@ -54,7 +55,7 @@
const double kEpsilon = 1e-14;
class ImplicitSchurComplementTest : public ::testing::Test {
- protected :
+ protected:
void SetUp() final {
std::unique_ptr<LinearLeastSquaresProblem> problem(
CreateLinearLeastSquaresProblemFromId(2));
@@ -115,8 +116,11 @@
VectorRef schur_solution(solution->data() + num_cols_ - num_schur_rows,
num_schur_rows);
schur_solution = lhs->selfadjointView<Eigen::Upper>().llt().solve(*rhs);
- eliminator->BackSubstitute(BlockSparseMatrixData(*A_), b_.get(), D,
- schur_solution.data(), solution->data());
+ eliminator->BackSubstitute(BlockSparseMatrixData(*A_),
+ b_.get(),
+ D,
+ schur_solution.data(),
+ solution->data());
}
AssertionResult TestImplicitSchurComplement(double* D) {
@@ -150,18 +154,18 @@
// the explicit schur complement.
if ((y - z).norm() > kEpsilon) {
return testing::AssertionFailure()
- << "Explicit and Implicit SchurComplements differ in "
- << "column " << i << ". explicit: " << y.transpose()
- << " implicit: " << z.transpose();
+ << "Explicit and Implicit SchurComplements differ in "
+ << "column " << i << ". explicit: " << y.transpose()
+ << " implicit: " << z.transpose();
}
}
// Compare the rhs of the reduced linear system
if ((isc.rhs() - rhs).norm() > kEpsilon) {
return testing::AssertionFailure()
- << "Explicit and Implicit SchurComplements differ in "
- << "rhs. explicit: " << rhs.transpose()
- << " implicit: " << isc.rhs().transpose();
+ << "Explicit and Implicit SchurComplements differ in "
+ << "rhs. explicit: " << rhs.transpose()
+ << " implicit: " << isc.rhs().transpose();
}
// Reference solution to the f_block.
@@ -174,9 +178,9 @@
isc.BackSubstitute(reference_f_sol.data(), sol.data());
if ((sol - reference_solution).norm() > kEpsilon) {
return testing::AssertionFailure()
- << "Explicit and Implicit SchurComplements solutions differ. "
- << "explicit: " << reference_solution.transpose()
- << " implicit: " << sol.transpose();
+ << "Explicit and Implicit SchurComplements solutions differ. "
+ << "explicit: " << reference_solution.transpose()
+ << " implicit: " << sol.transpose();
}
return testing::AssertionSuccess();
diff --git a/internal/ceres/inner_product_computer.cc b/internal/ceres/inner_product_computer.cc
index 2bf8836..ef38b7b 100644
--- a/internal/ceres/inner_product_computer.cc
+++ b/internal/ceres/inner_product_computer.cc
@@ -31,12 +31,12 @@
#include "ceres/inner_product_computer.h"
#include <algorithm>
+
#include "ceres/small_blas.h"
namespace ceres {
namespace internal {
-
// Create the CompressedRowSparseMatrix matrix that will contain the
// inner product.
//
@@ -297,7 +297,7 @@
const Cell& cell1 = m_row.cells[c1];
const int c1_size = bs->cols[cell1.block_id].size;
const int row_nnz = rows[bs->cols[cell1.block_id].position + 1] -
- rows[bs->cols[cell1.block_id].position];
+ rows[bs->cols[cell1.block_id].position];
int c2_begin, c2_end;
if (storage_type == CompressedRowSparseMatrix::LOWER_TRIANGULAR) {
@@ -311,6 +311,7 @@
for (int c2 = c2_begin; c2 < c2_end; ++c2, ++cursor) {
const Cell& cell2 = m_row.cells[c2];
const int c2_size = bs->cols[cell2.block_id].size;
+ // clang-format off
MatrixTransposeMatrixMultiply<Eigen::Dynamic, Eigen::Dynamic,
Eigen::Dynamic, Eigen::Dynamic, 1>(
m_values + cell1.position,
@@ -319,6 +320,7 @@
m_row.block.size, c2_size,
values + result_offsets_[cursor],
0, 0, c1_size, row_nnz);
+ // clang-format on
}
}
}
diff --git a/internal/ceres/inner_product_computer_test.cc b/internal/ceres/inner_product_computer_test.cc
index 31cd829..ac564f4 100644
--- a/internal/ceres/inner_product_computer_test.cc
+++ b/internal/ceres/inner_product_computer_test.cc
@@ -32,6 +32,8 @@
#include <memory>
#include <numeric>
+
+#include "Eigen/SparseCore"
#include "ceres/block_sparse_matrix.h"
#include "ceres/internal/eigen.h"
#include "ceres/random.h"
@@ -39,8 +41,6 @@
#include "glog/logging.h"
#include "gtest/gtest.h"
-#include "Eigen/SparseCore"
-
namespace ceres {
namespace internal {
@@ -134,7 +134,6 @@
inner_product_computer.reset(InnerProductComputer::Create(
*random_matrix, CompressedRowSparseMatrix::UPPER_TRIANGULAR));
COMPUTE_AND_COMPARE;
-
}
}
}
@@ -215,7 +214,6 @@
end_row_block,
CompressedRowSparseMatrix::UPPER_TRIANGULAR));
COMPUTE_AND_COMPARE;
-
}
}
}
diff --git a/internal/ceres/invert_psd_matrix.h b/internal/ceres/invert_psd_matrix.h
index 21d301a..ac8808b 100644
--- a/internal/ceres/invert_psd_matrix.h
+++ b/internal/ceres/invert_psd_matrix.h
@@ -31,9 +31,9 @@
#ifndef CERES_INTERNAL_INVERT_PSD_MATRIX_H_
#define CERES_INTERNAL_INVERT_PSD_MATRIX_H_
+#include "Eigen/Dense"
#include "ceres/internal/eigen.h"
#include "glog/logging.h"
-#include "Eigen/Dense"
namespace ceres {
namespace internal {
@@ -76,4 +76,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_INTERNAL_INVERT_PSD_MATRIX_H_
+#endif // CERES_INTERNAL_INVERT_PSD_MATRIX_H_
diff --git a/internal/ceres/is_close.cc b/internal/ceres/is_close.cc
index a91a174..0becf55 100644
--- a/internal/ceres/is_close.cc
+++ b/internal/ceres/is_close.cc
@@ -35,9 +35,11 @@
namespace ceres {
namespace internal {
-bool IsClose(double x, double y, double relative_precision,
- double *relative_error,
- double *absolute_error) {
+bool IsClose(double x,
+ double y,
+ double relative_precision,
+ double* relative_error,
+ double* absolute_error) {
double local_absolute_error;
double local_relative_error;
if (!absolute_error) {
diff --git a/internal/ceres/is_close.h b/internal/ceres/is_close.h
index 7789448..d0b5e6b 100644
--- a/internal/ceres/is_close.h
+++ b/internal/ceres/is_close.h
@@ -43,8 +43,8 @@
bool IsClose(double x,
double y,
double relative_precision,
- double *relative_error,
- double *absolute_error);
+ double* relative_error,
+ double* absolute_error);
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/is_close_test.cc b/internal/ceres/is_close_test.cc
index 8f7aaba..12d6236 100644
--- a/internal/ceres/is_close_test.cc
+++ b/internal/ceres/is_close_test.cc
@@ -31,6 +31,7 @@
// This file contains tests for the IsClose function.
#include "ceres/is_close.h"
+
#include "gtest/gtest.h"
namespace ceres {
diff --git a/internal/ceres/iterative_refiner.cc b/internal/ceres/iterative_refiner.cc
index fb0e45b..5f0bfdd 100644
--- a/internal/ceres/iterative_refiner.cc
+++ b/internal/ceres/iterative_refiner.cc
@@ -28,9 +28,10 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
-#include <string>
#include "ceres/iterative_refiner.h"
+#include <string>
+
#include "Eigen/Core"
#include "ceres/sparse_cholesky.h"
#include "ceres/sparse_matrix.h"
diff --git a/internal/ceres/iterative_refiner.h b/internal/ceres/iterative_refiner.h
index f969935..b2c39b5 100644
--- a/internal/ceres/iterative_refiner.h
+++ b/internal/ceres/iterative_refiner.h
@@ -32,7 +32,10 @@
#define CERES_INTERNAL_ITERATIVE_REFINER_H_
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
+
#include "ceres/internal/eigen.h"
namespace ceres {
diff --git a/internal/ceres/iterative_refiner_test.cc b/internal/ceres/iterative_refiner_test.cc
index c474ede..49887c6 100644
--- a/internal/ceres/iterative_refiner_test.cc
+++ b/internal/ceres/iterative_refiner_test.cc
@@ -93,8 +93,8 @@
virtual ~FakeSparseCholesky() {}
LinearSolverTerminationType Solve(const double* rhs_ptr,
- double* solution_ptr,
- std::string* message) final {
+ double* solution_ptr,
+ std::string* message) final {
const int num_cols = lhs_.cols();
VectorRef solution(solution_ptr, num_cols);
ConstVectorRef rhs(rhs_ptr, num_cols);
@@ -106,14 +106,14 @@
CompressedRowSparseMatrix::StorageType StorageType() const final
DO_NOT_CALL_WITH_RETURN(CompressedRowSparseMatrix::UPPER_TRIANGULAR);
LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
- std::string* message) final
+ std::string* message) final
DO_NOT_CALL_WITH_RETURN(LINEAR_SOLVER_FAILURE);
- LinearSolverTerminationType FactorAndSolve(
- CompressedRowSparseMatrix* lhs,
- const double* rhs,
- double* solution,
- std::string* message) final DO_NOT_CALL_WITH_RETURN(LINEAR_SOLVER_FAILURE);
+ LinearSolverTerminationType FactorAndSolve(CompressedRowSparseMatrix* lhs,
+ const double* rhs,
+ double* solution,
+ std::string* message) final
+ DO_NOT_CALL_WITH_RETURN(LINEAR_SOLVER_FAILURE);
private:
Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> lhs_;
diff --git a/internal/ceres/iterative_schur_complement_solver.cc b/internal/ceres/iterative_schur_complement_solver.cc
index 6076c38..143df5e 100644
--- a/internal/ceres/iterative_schur_complement_solver.cc
+++ b/internal/ceres/iterative_schur_complement_solver.cc
@@ -55,8 +55,7 @@
IterativeSchurComplementSolver::IterativeSchurComplementSolver(
const LinearSolver::Options& options)
- : options_(options) {
-}
+ : options_(options) {}
IterativeSchurComplementSolver::~IterativeSchurComplementSolver() {}
diff --git a/internal/ceres/iterative_schur_complement_solver.h b/internal/ceres/iterative_schur_complement_solver.h
index 9aed94f..ca002d2 100644
--- a/internal/ceres/iterative_schur_complement_solver.h
+++ b/internal/ceres/iterative_schur_complement_solver.h
@@ -32,8 +32,9 @@
#define CERES_INTERNAL_ITERATIVE_SCHUR_COMPLEMENT_SOLVER_H_
#include <memory>
-#include "ceres/linear_solver.h"
+
#include "ceres/internal/eigen.h"
+#include "ceres/linear_solver.h"
#include "ceres/types.h"
namespace ceres {
@@ -70,17 +71,17 @@
class IterativeSchurComplementSolver : public BlockSparseMatrixSolver {
public:
explicit IterativeSchurComplementSolver(const LinearSolver::Options& options);
- IterativeSchurComplementSolver(const IterativeSchurComplementSolver&) = delete;
+ IterativeSchurComplementSolver(const IterativeSchurComplementSolver&) =
+ delete;
void operator=(const IterativeSchurComplementSolver&) = delete;
virtual ~IterativeSchurComplementSolver();
private:
- LinearSolver::Summary SolveImpl(
- BlockSparseMatrix* A,
- const double* b,
- const LinearSolver::PerSolveOptions& options,
- double* x) final;
+ LinearSolver::Summary SolveImpl(BlockSparseMatrix* A,
+ const double* b,
+ const LinearSolver::PerSolveOptions& options,
+ double* x) final;
void CreatePreconditioner(BlockSparseMatrix* A);
diff --git a/internal/ceres/iterative_schur_complement_solver_test.cc b/internal/ceres/iterative_schur_complement_solver_test.cc
index 3bf2d92..fdd65c7 100644
--- a/internal/ceres/iterative_schur_complement_solver_test.cc
+++ b/internal/ceres/iterative_schur_complement_solver_test.cc
@@ -36,6 +36,7 @@
#include <cstddef>
#include <memory>
+
#include "Eigen/Dense"
#include "ceres/block_random_access_dense_matrix.h"
#include "ceres/block_sparse_matrix.h"
@@ -58,7 +59,7 @@
const double kEpsilon = 1e-14;
class IterativeSchurComplementSolverTest : public ::testing::Test {
- protected :
+ protected:
void SetUpProblem(int problem_id) {
std::unique_ptr<LinearLeastSquaresProblem> problem(
CreateLinearLeastSquaresProblemFromId(problem_id));
@@ -74,9 +75,8 @@
}
AssertionResult TestSolver(double* D) {
- TripletSparseMatrix triplet_A(A_->num_rows(),
- A_->num_cols(),
- A_->num_nonzeros());
+ TripletSparseMatrix triplet_A(
+ A_->num_rows(), A_->num_cols(), A_->num_nonzeros());
A_->ToTripletSparseMatrix(&triplet_A);
DenseSparseMatrix dense_A(triplet_A);
@@ -99,15 +99,15 @@
IterativeSchurComplementSolver isc(options);
Vector isc_sol(num_cols_);
- per_solve_options.r_tolerance = 1e-12;
+ per_solve_options.r_tolerance = 1e-12;
isc.Solve(A_.get(), b_.get(), per_solve_options, isc_sol.data());
double diff = (isc_sol - reference_solution).norm();
if (diff < kEpsilon) {
return testing::AssertionSuccess();
} else {
return testing::AssertionFailure()
- << "The reference solution differs from the ITERATIVE_SCHUR"
- << " solution by " << diff << " which is more than " << kEpsilon;
+ << "The reference solution differs from the ITERATIVE_SCHUR"
+ << " solution by " << diff << " which is more than " << kEpsilon;
}
}
diff --git a/internal/ceres/jet_test.cc b/internal/ceres/jet_test.cc
index f1e9586..36f279d 100644
--- a/internal/ceres/jet_test.cc
+++ b/internal/ceres/jet_test.cc
@@ -62,30 +62,32 @@
// On a 32-bit optimized build, the mismatch is about 1.4e-14.
double const kTolerance = 1e-13;
-void ExpectJetsClose(const J &x, const J &y) {
+void ExpectJetsClose(const J& x, const J& y) {
ExpectClose(x.a, y.a, kTolerance);
ExpectClose(x.v[0], y.v[0], kTolerance);
ExpectClose(x.v[1], y.v[1], kTolerance);
}
const double kStep = 1e-8;
-const double kNumericalTolerance = 1e-6; // Numeric derivation is quite inexact
+const double kNumericalTolerance = 1e-6; // Numeric derivation is quite inexact
// Differentiate using Jet and confirm results with numerical derivation.
-template<typename Function>
+template <typename Function>
void NumericalTest(const char* name, const Function& f, const double x) {
const double exact_dx = f(MakeJet(x, 1.0, 0.0)).v[0];
const double estimated_dx =
- (f(J(x + kStep)).a - f(J(x - kStep)).a) / (2.0 * kStep);
- VL << name << "(" << x << "), exact dx: "
- << exact_dx << ", estimated dx: " << estimated_dx;
+ (f(J(x + kStep)).a - f(J(x - kStep)).a) / (2.0 * kStep);
+ VL << name << "(" << x << "), exact dx: " << exact_dx
+ << ", estimated dx: " << estimated_dx;
ExpectClose(exact_dx, estimated_dx, kNumericalTolerance);
}
// Same as NumericalTest, but given a function taking two arguments.
-template<typename Function>
-void NumericalTest2(const char* name, const Function& f,
- const double x, const double y) {
+template <typename Function>
+void NumericalTest2(const char* name,
+ const Function& f,
+ const double x,
+ const double y) {
const J exact_delta = f(MakeJet(x, 1.0, 0.0), MakeJet(y, 0.0, 1.0));
const double exact_dx = exact_delta.v[0];
const double exact_dy = exact_delta.v[1];
@@ -97,14 +99,14 @@
EXPECT_EQ(exact_dy, f(MakeJet(x, 0.0, 0.0), MakeJet(y, 0.0, 1.0)).v[1]);
const double estimated_dx =
- (f(J(x + kStep), J(y)).a - f(J(x - kStep), J(y)).a) / (2.0 * kStep);
+ (f(J(x + kStep), J(y)).a - f(J(x - kStep), J(y)).a) / (2.0 * kStep);
const double estimated_dy =
- (f(J(x), J(y + kStep)).a - f(J(x), J(y - kStep)).a) / (2.0 * kStep);
- VL << name << "(" << x << ", " << y << "), exact dx: "
- << exact_dx << ", estimated dx: " << estimated_dx;
+ (f(J(x), J(y + kStep)).a - f(J(x), J(y - kStep)).a) / (2.0 * kStep);
+ VL << name << "(" << x << ", " << y << "), exact dx: " << exact_dx
+ << ", estimated dx: " << estimated_dx;
ExpectClose(exact_dx, estimated_dx, kNumericalTolerance);
- VL << name << "(" << x << ", " << y << "), exact dy: "
- << exact_dy << ", estimated dy: " << estimated_dy;
+ VL << name << "(" << x << ", " << y << "), exact dy: " << exact_dy
+ << ", estimated dy: " << estimated_dy;
ExpectClose(exact_dy, estimated_dy, kNumericalTolerance);
}
@@ -113,12 +115,12 @@
TEST(Jet, Jet) {
// Pick arbitrary values for x and y.
J x = MakeJet(2.3, -2.7, 1e-3);
- J y = MakeJet(1.7, 0.5, 1e+2);
+ J y = MakeJet(1.7, 0.5, 1e+2);
VL << "x = " << x;
VL << "y = " << y;
- { // Check that log(exp(x)) == x.
+ { // Check that log(exp(x)) == x.
J z = exp(x);
J w = log(z);
VL << "z = " << z;
@@ -126,7 +128,7 @@
ExpectJetsClose(w, x);
}
- { // Check that (x * y) / x == y.
+ { // Check that (x * y) / x == y.
J z = x * y;
J w = z / x;
VL << "z = " << z;
@@ -134,7 +136,7 @@
ExpectJetsClose(w, y);
}
- { // Check that sqrt(x * x) == x.
+ { // Check that sqrt(x * x) == x.
J z = x * x;
J w = sqrt(z);
VL << "z = " << z;
@@ -142,7 +144,7 @@
ExpectJetsClose(w, x);
}
- { // Check that sqrt(y) * sqrt(y) == y.
+ { // Check that sqrt(y) * sqrt(y) == y.
J z = sqrt(y);
J w = z * z;
VL << "z = " << z;
@@ -153,23 +155,23 @@
NumericalTest("sqrt", sqrt<double, 2>, 0.00001);
NumericalTest("sqrt", sqrt<double, 2>, 1.0);
- { // Check that cos(2*x) = cos(x)^2 - sin(x)^2
+ { // Check that cos(2*x) = cos(x)^2 - sin(x)^2
J z = cos(J(2.0) * x);
- J w = cos(x)*cos(x) - sin(x)*sin(x);
+ J w = cos(x) * cos(x) - sin(x) * sin(x);
VL << "z = " << z;
VL << "w = " << w;
ExpectJetsClose(w, z);
}
- { // Check that sin(2*x) = 2*cos(x)*sin(x)
+ { // Check that sin(2*x) = 2*cos(x)*sin(x)
J z = sin(J(2.0) * x);
- J w = J(2.0)*cos(x)*sin(x);
+ J w = J(2.0) * cos(x) * sin(x);
VL << "z = " << z;
VL << "w = " << w;
ExpectJetsClose(w, z);
}
- { // Check that cos(x)*cos(x) + sin(x)*sin(x) = 1
+ { // Check that cos(x)*cos(x) + sin(x)*sin(x) = 1
J z = cos(x) * cos(x);
J w = sin(x) * sin(x);
VL << "z = " << z;
@@ -177,7 +179,7 @@
ExpectJetsClose(z + w, J(1.0));
}
- { // Check that atan2(r*sin(t), r*cos(t)) = t.
+ { // Check that atan2(r*sin(t), r*cos(t)) = t.
J t = MakeJet(0.7, -0.3, +1.5);
J r = MakeJet(2.3, 0.13, -2.4);
VL << "t = " << t;
@@ -189,7 +191,7 @@
ExpectJetsClose(u, t);
}
- { // Check that tan(x) = sin(x) / cos(x).
+ { // Check that tan(x) = sin(x) / cos(x).
J z = tan(x);
J w = sin(x) / cos(x);
VL << "z = " << z;
@@ -197,7 +199,7 @@
ExpectJetsClose(z, w);
}
- { // Check that tan(atan(x)) = x.
+ { // Check that tan(atan(x)) = x.
J z = tan(atan(x));
J w = x;
VL << "z = " << z;
@@ -205,7 +207,7 @@
ExpectJetsClose(z, w);
}
- { // Check that cosh(x)*cosh(x) - sinh(x)*sinh(x) = 1
+ { // Check that cosh(x)*cosh(x) - sinh(x)*sinh(x) = 1
J z = cosh(x) * cosh(x);
J w = sinh(x) * sinh(x);
VL << "z = " << z;
@@ -213,7 +215,7 @@
ExpectJetsClose(z - w, J(1.0));
}
- { // Check that tanh(x + y) = (tanh(x) + tanh(y)) / (1 + tanh(x) tanh(y))
+ { // Check that tanh(x + y) = (tanh(x) + tanh(y)) / (1 + tanh(x) tanh(y))
J z = tanh(x + y);
J w = (tanh(x) + tanh(y)) / (J(1.0) + tanh(x) * tanh(y));
VL << "z = " << z;
@@ -221,7 +223,7 @@
ExpectJetsClose(z, w);
}
- { // Check that pow(x, 1) == x.
+ { // Check that pow(x, 1) == x.
VL << "x = " << x;
J u = pow(x, 1.);
@@ -230,7 +232,7 @@
ExpectJetsClose(x, u);
}
- { // Check that pow(x, 1) == x.
+ { // Check that pow(x, 1) == x.
J y = MakeJet(1, 0.0, 0.0);
VL << "x = " << x;
VL << "y = " << y;
@@ -241,7 +243,7 @@
ExpectJetsClose(x, u);
}
- { // Check that pow(e, log(x)) == x.
+ { // Check that pow(e, log(x)) == x.
J logx = log(x);
VL << "x = " << x;
@@ -253,7 +255,7 @@
ExpectJetsClose(x, u);
}
- { // Check that pow(e, log(x)) == x.
+ { // Check that pow(e, log(x)) == x.
J logx = log(x);
J e = MakeJet(kE, 0., 0.);
VL << "x = " << x;
@@ -265,7 +267,7 @@
ExpectJetsClose(x, u);
}
- { // Check that pow(e, log(x)) == x.
+ { // Check that pow(e, log(x)) == x.
J logx = log(x);
J e = MakeJet(kE, 0., 0.);
VL << "x = " << x;
@@ -277,13 +279,13 @@
ExpectJetsClose(x, u);
}
- { // Check that pow(x,y) = exp(y*log(x)).
+ { // Check that pow(x,y) = exp(y*log(x)).
J logx = log(x);
J e = MakeJet(kE, 0., 0.);
VL << "x = " << x;
VL << "logx = " << logx;
- J u = pow(e, y*logx);
+ J u = pow(e, y * logx);
J v = pow(x, y);
VL << "u = " << u;
VL << "v = " << v;
@@ -291,7 +293,7 @@
ExpectJetsClose(v, u);
}
- { // Check that pow(0, y) == 0 for y > 1, with both arguments Jets.
+ { // Check that pow(0, y) == 0 for y > 1, with both arguments Jets.
// This tests special case handling inside pow().
J a = MakeJet(0, 1, 2);
J b = MakeJet(2, 3, 4);
@@ -303,7 +305,7 @@
ExpectJetsClose(c, MakeJet(0, 0, 0));
}
- { // Check that pow(0, y) == 0 for y == 1, with both arguments Jets.
+ { // Check that pow(0, y) == 0 for y == 1, with both arguments Jets.
// This tests special case handling inside pow().
J a = MakeJet(0, 1, 2);
J b = MakeJet(1, 3, 4);
@@ -315,10 +317,10 @@
ExpectJetsClose(c, MakeJet(0, 1, 2));
}
- { // Check that pow(0, <1) is not finite, with both arguments Jets.
+ { // Check that pow(0, <1) is not finite, with both arguments Jets.
for (int i = 1; i < 10; i++) {
J a = MakeJet(0, 1, 2);
- J b = MakeJet(i*0.1, 3, 4); // b = 0.1 ... 0.9
+ J b = MakeJet(i * 0.1, 3, 4); // b = 0.1 ... 0.9
VL << "a = " << a;
VL << "b = " << b;
@@ -330,7 +332,7 @@
}
for (int i = -10; i < 0; i++) {
J a = MakeJet(0, 1, 2);
- J b = MakeJet(i*0.1, 3, 4); // b = -1,-0.9 ... -0.1
+ J b = MakeJet(i * 0.1, 3, 4); // b = -1,-0.9 ... -0.1
VL << "a = " << a;
VL << "b = " << b;
@@ -356,7 +358,7 @@
}
}
- { // Check that pow(<0, b) is correct for integer b.
+ { // Check that pow(<0, b) is correct for integer b.
// This tests special case handling inside pow().
J a = MakeJet(-1.5, 3, 4);
@@ -375,7 +377,7 @@
}
}
- { // Check that pow(<0, b) is correct for noninteger b.
+ { // Check that pow(<0, b) is correct for noninteger b.
// This tests special case handling inside pow().
J a = MakeJet(-1.5, 3, 4);
J b = MakeJet(-2.5, 0, 5);
@@ -435,7 +437,7 @@
EXPECT_FALSE(IsFinite(c.v[1]));
}
- { // Check that 1 + x == x + 1.
+ { // Check that 1 + x == x + 1.
J a = x + 1.0;
J b = 1.0 + x;
J c = x;
@@ -445,7 +447,7 @@
ExpectJetsClose(a, c);
}
- { // Check that 1 - x == -(x - 1).
+ { // Check that 1 - x == -(x - 1).
J a = 1.0 - x;
J b = -(x - 1.0);
J c = x;
@@ -455,7 +457,7 @@
ExpectJetsClose(a, -c);
}
- { // Check that (x/s)*s == (x*s)/s.
+ { // Check that (x/s)*s == (x*s)/s.
J a = x / 5.0;
J b = x * 5.0;
J c = x;
@@ -468,7 +470,7 @@
ExpectJetsClose(b, d);
}
- { // Check that x / y == 1 / (y / x).
+ { // Check that x / y == 1 / (y / x).
J a = x / y;
J b = 1.0 / (y / x);
VL << "a = " << a;
@@ -477,26 +479,26 @@
ExpectJetsClose(a, b);
}
- { // Check that abs(-x * x) == sqrt(x * x).
+ { // Check that abs(-x * x) == sqrt(x * x).
ExpectJetsClose(abs(-x), sqrt(x * x));
}
- { // Check that cos(acos(x)) == x.
+ { // Check that cos(acos(x)) == x.
J a = MakeJet(0.1, -2.7, 1e-3);
ExpectJetsClose(cos(acos(a)), a);
ExpectJetsClose(acos(cos(a)), a);
- J b = MakeJet(0.6, 0.5, 1e+2);
+ J b = MakeJet(0.6, 0.5, 1e+2);
ExpectJetsClose(cos(acos(b)), b);
ExpectJetsClose(acos(cos(b)), b);
}
- { // Check that sin(asin(x)) == x.
+ { // Check that sin(asin(x)) == x.
J a = MakeJet(0.1, -2.7, 1e-3);
ExpectJetsClose(sin(asin(a)), a);
ExpectJetsClose(asin(sin(a)), a);
- J b = MakeJet(0.4, 0.5, 1e+2);
+ J b = MakeJet(0.4, 0.5, 1e+2);
ExpectJetsClose(sin(asin(b)), b);
ExpectJetsClose(asin(sin(b)), b);
}
@@ -529,49 +531,49 @@
ExpectJetsClose(BesselJ0(z) + BesselJn(2, z), (2.0 / z) * BesselJ1(z));
}
- { // Check that floor of a positive number works.
+ { // Check that floor of a positive number works.
J a = MakeJet(0.1, -2.7, 1e-3);
J b = floor(a);
J expected = MakeJet(floor(a.a), 0.0, 0.0);
EXPECT_EQ(expected, b);
}
- { // Check that floor of a negative number works.
+ { // Check that floor of a negative number works.
J a = MakeJet(-1.1, -2.7, 1e-3);
J b = floor(a);
J expected = MakeJet(floor(a.a), 0.0, 0.0);
EXPECT_EQ(expected, b);
}
- { // Check that floor of a positive number works.
+ { // Check that floor of a positive number works.
J a = MakeJet(10.123, -2.7, 1e-3);
J b = floor(a);
J expected = MakeJet(floor(a.a), 0.0, 0.0);
EXPECT_EQ(expected, b);
}
- { // Check that ceil of a positive number works.
+ { // Check that ceil of a positive number works.
J a = MakeJet(0.1, -2.7, 1e-3);
J b = ceil(a);
J expected = MakeJet(ceil(a.a), 0.0, 0.0);
EXPECT_EQ(expected, b);
}
- { // Check that ceil of a negative number works.
+ { // Check that ceil of a negative number works.
J a = MakeJet(-1.1, -2.7, 1e-3);
J b = ceil(a);
J expected = MakeJet(ceil(a.a), 0.0, 0.0);
EXPECT_EQ(expected, b);
}
- { // Check that ceil of a positive number works.
+ { // Check that ceil of a positive number works.
J a = MakeJet(10.123, -2.7, 1e-3);
J b = ceil(a);
J expected = MakeJet(ceil(a.a), 0.0, 0.0);
EXPECT_EQ(expected, b);
}
- { // Check that erf works.
+ { // Check that erf works.
J a = MakeJet(10.123, -2.7, 1e-3);
J b = erf(a);
J expected = MakeJet(erf(a.a), 0.0, 0.0);
@@ -582,7 +584,7 @@
NumericalTest("erf", erf<double, 2>, 0.5);
NumericalTest("erf", erf<double, 2>, 100.0);
- { // Check that erfc works.
+ { // Check that erfc works.
J a = MakeJet(10.123, -2.7, 1e-3);
J b = erfc(a);
J expected = MakeJet(erfc(a.a), 0.0, 0.0);
@@ -593,7 +595,7 @@
NumericalTest("erfc", erfc<double, 2>, 0.5);
NumericalTest("erfc", erfc<double, 2>, 100.0);
- { // Check that cbrt(x * x * x) == x.
+ { // Check that cbrt(x * x * x) == x.
J z = x * x * x;
J w = cbrt(z);
VL << "z = " << z;
@@ -601,7 +603,7 @@
ExpectJetsClose(w, x);
}
- { // Check that cbrt(y) * cbrt(y) * cbrt(y) == y.
+ { // Check that cbrt(y) * cbrt(y) * cbrt(y) == y.
J z = cbrt(y);
J w = z * z * z;
VL << "z = " << z;
@@ -609,7 +611,7 @@
ExpectJetsClose(w, y);
}
- { // Check that cbrt(x) == pow(x, 1/3).
+ { // Check that cbrt(x) == pow(x, 1/3).
J z = cbrt(x);
J w = pow(x, 1.0 / 3.0);
VL << "z = " << z;
@@ -621,7 +623,7 @@
NumericalTest("cbrt", cbrt<double, 2>, 1e-5);
NumericalTest("cbrt", cbrt<double, 2>, 1.0);
- { // Check that exp2(x) == exp(x * log(2))
+ { // Check that exp2(x) == exp(x * log(2))
J z = exp2(x);
J w = exp(x * log(2.0));
VL << "z = " << z;
@@ -636,7 +638,7 @@
NumericalTest("exp2", exp2<double, 2>, 1e-5);
NumericalTest("exp2", exp2<double, 2>, 1.0);
- { // Check that log2(x) == log(x) / log(2)
+ { // Check that log2(x) == log(x) / log(2)
J z = log2(x);
J w = log(x) / log(2.0);
VL << "z = " << z;
@@ -647,15 +649,15 @@
NumericalTest("log2", log2<double, 2>, 1.0);
NumericalTest("log2", log2<double, 2>, 100.0);
- { // Check that hypot(x, y) == sqrt(x^2 + y^2)
+ { // Check that hypot(x, y) == sqrt(x^2 + y^2)
J h = hypot(x, y);
- J s = sqrt(x*x + y*y);
+ J s = sqrt(x * x + y * y);
VL << "h = " << h;
VL << "s = " << s;
ExpectJetsClose(h, s);
}
- { // Check that hypot(x, x) == sqrt(2) * abs(x)
+ { // Check that hypot(x, x) == sqrt(2) * abs(x)
J h = hypot(x, x);
J s = sqrt(2.0) * abs(x);
VL << "h = " << h;
@@ -663,35 +665,35 @@
ExpectJetsClose(h, s);
}
- { // Check that the derivative is zero tangentially to the circle:
+ { // Check that the derivative is zero tangentially to the circle:
J h = hypot(MakeJet(2.0, 1.0, 1.0), MakeJet(2.0, 1.0, -1.0));
VL << "h = " << h;
ExpectJetsClose(h, MakeJet(sqrt(8.0), std::sqrt(2.0), 0.0));
}
- { // Check that hypot(x, 0) == x
+ { // Check that hypot(x, 0) == x
J zero = MakeJet(0.0, 2.0, 3.14);
J h = hypot(x, zero);
VL << "h = " << h;
ExpectJetsClose(x, h);
}
- { // Check that hypot(0, y) == y
+ { // Check that hypot(0, y) == y
J zero = MakeJet(0.0, 2.0, 3.14);
J h = hypot(zero, y);
VL << "h = " << h;
ExpectJetsClose(y, h);
}
- { // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x underflows:
- EXPECT_EQ(DBL_MIN * DBL_MIN, 0.0); // Make sure it underflows
+ { // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x underflows:
+ EXPECT_EQ(DBL_MIN * DBL_MIN, 0.0); // Make sure it underflows
J huge = MakeJet(DBL_MIN, 2.0, 3.14);
J h = hypot(huge, J(0.0));
VL << "h = " << h;
ExpectJetsClose(h, huge);
}
- { // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x overflows:
+ { // Check that hypot(x, 0) == sqrt(x * x) == x, even when x * x overflows:
EXPECT_EQ(DBL_MAX * DBL_MAX, std::numeric_limits<double>::infinity());
J huge = MakeJet(DBL_MAX, 2.0, 3.14);
J h = hypot(huge, J(0.0));
@@ -699,6 +701,7 @@
ExpectJetsClose(h, huge);
}
+ // clang-format off
NumericalTest2("hypot", hypot<double, 2>, 0.0, 1e-5);
NumericalTest2("hypot", hypot<double, 2>, -1e-5, 0.0);
NumericalTest2("hypot", hypot<double, 2>, 1e-5, 1e-5);
@@ -708,6 +711,7 @@
NumericalTest2("hypot", hypot<double, 2>, -1e-3, 1.0);
NumericalTest2("hypot", hypot<double, 2>, -1e-3, -1.0);
NumericalTest2("hypot", hypot<double, 2>, 1.0, 2.0);
+ // clang-format on
{
J z = fmax(x, y);
@@ -720,14 +724,13 @@
VL << "z = " << z;
ExpectJetsClose(y, z);
}
-
}
TEST(Jet, JetsInEigenMatrices) {
J x = MakeJet(2.3, -2.7, 1e-3);
- J y = MakeJet(1.7, 0.5, 1e+2);
+ J y = MakeJet(1.7, 0.5, 1e+2);
J z = MakeJet(5.3, -4.7, 1e-3);
- J w = MakeJet(9.7, 1.5, 10.1);
+ J w = MakeJet(9.7, 1.5, 10.1);
Eigen::Matrix<J, 2, 2> M;
Eigen::Matrix<J, 2, 1> v, r1, r2;
@@ -795,11 +798,11 @@
Eigen::Matrix<J, 3, 1> b, x;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
- A(i,j) = MakeJet(0.0, i, j * j);
+ A(i, j) = MakeJet(0.0, i, j * j);
}
b(i) = MakeJet(i, i, i);
x(i) = MakeJet(0.0, 0.0, 0.0);
- A(i,i) = MakeJet(1.0, i, i * i);
+ A(i, i) = MakeJet(1.0, i, i * i);
}
x = A.llt().solve(b);
for (int i = 0; i < 3; ++i) {
@@ -812,11 +815,11 @@
Eigen::Matrix<J, 3, 1> b, x;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
- A(i,j) = MakeJet(0.0, i, j * j);
+ A(i, j) = MakeJet(0.0, i, j * j);
}
b(i) = MakeJet(i, i, i);
x(i) = MakeJet(0.0, 0.0, 0.0);
- A(i,i) = MakeJet(1.0, i, i * i);
+ A(i, i) = MakeJet(1.0, i, i * i);
}
x = A.ldlt().solve(b);
for (int i = 0; i < 3; ++i) {
@@ -829,11 +832,11 @@
Eigen::Matrix<J, 3, 1> b, x;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
- A(i,j) = MakeJet(0.0, i, j * j);
+ A(i, j) = MakeJet(0.0, i, j * j);
}
b(i) = MakeJet(i, i, i);
x(i) = MakeJet(0.0, 0.0, 0.0);
- A(i,i) = MakeJet(1.0, i, i * i);
+ A(i, i) = MakeJet(1.0, i, i * i);
}
x = A.lu().solve(b);
@@ -845,7 +848,7 @@
// ScalarBinaryOpTraits is only supported on Eigen versions >= 3.3
TEST(JetTraitsTest, MatrixScalarUnaryOps) {
const J x = MakeJet(2.3, -2.7, 1e-3);
- const J y = MakeJet(1.7, 0.5, 1e+2);
+ const J y = MakeJet(1.7, 0.5, 1e+2);
Eigen::Matrix<J, 2, 1> a;
a << x, y;
@@ -856,9 +859,9 @@
TEST(JetTraitsTest, MatrixScalarBinaryOps) {
const J x = MakeJet(2.3, -2.7, 1e-3);
- const J y = MakeJet(1.7, 0.5, 1e+2);
+ const J y = MakeJet(1.7, 0.5, 1e+2);
const J z = MakeJet(5.3, -4.7, 1e-3);
- const J w = MakeJet(9.7, 1.5, 10.1);
+ const J w = MakeJet(9.7, 1.5, 10.1);
Eigen::Matrix<J, 2, 2> M;
Eigen::Vector2d v;
@@ -886,7 +889,7 @@
TEST(JetTraitsTest, ArrayScalarUnaryOps) {
const J x = MakeJet(2.3, -2.7, 1e-3);
- const J y = MakeJet(1.7, 0.5, 1e+2);
+ const J y = MakeJet(1.7, 0.5, 1e+2);
Eigen::Array<J, 2, 1> a;
a << x, y;
@@ -897,7 +900,7 @@
TEST(JetTraitsTest, ArrayScalarBinaryOps) {
const J x = MakeJet(2.3, -2.7, 1e-3);
- const J y = MakeJet(1.7, 0.5, 1e+2);
+ const J y = MakeJet(1.7, 0.5, 1e+2);
Eigen::Array<J, 2, 1> a;
Eigen::Array2d b;
@@ -922,8 +925,8 @@
}
TEST(Jet, nested3x) {
- typedef Jet<J,2> JJ;
- typedef Jet<JJ,2> JJJ;
+ typedef Jet<J, 2> JJ;
+ typedef Jet<JJ, 2> JJJ;
JJJ x;
x.a = JJ(J(1, 0), 0);
diff --git a/internal/ceres/lapack.cc b/internal/ceres/lapack.cc
index 37efbcd..a159ec7 100644
--- a/internal/ceres/lapack.cc
+++ b/internal/ceres/lapack.cc
@@ -36,11 +36,7 @@
#ifndef CERES_NO_LAPACK
// C interface to the LAPACK Cholesky factorization and triangular solve.
-extern "C" void dpotrf_(char* uplo,
- int* n,
- double* a,
- int* lda,
- int* info);
+extern "C" void dpotrf_(char* uplo, int* n, double* a, int* lda, int* info);
extern "C" void dpotrs_(char* uplo,
int* n,
@@ -92,10 +88,10 @@
}
if (info > 0) {
- *message =
- StringPrintf(
- "LAPACK::dpotrf numerical failure. "
- "The leading minor of order %d is not positive definite.", info);
+ *message = StringPrintf(
+ "LAPACK::dpotrf numerical failure. "
+ "The leading minor of order %d is not positive definite.",
+ info);
return LINEAR_SOLVER_FAILURE;
}
diff --git a/internal/ceres/lapack.h b/internal/ceres/lapack.h
index 5bb1a22..5c5bf8b 100644
--- a/internal/ceres/lapack.h
+++ b/internal/ceres/lapack.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_LAPACK_H_
#include <string>
+
#include "ceres/internal/port.h"
#include "ceres/linear_solver.h"
diff --git a/internal/ceres/levenberg_marquardt_strategy.cc b/internal/ceres/levenberg_marquardt_strategy.cc
index 9eec631..cb0e937 100644
--- a/internal/ceres/levenberg_marquardt_strategy.cc
+++ b/internal/ceres/levenberg_marquardt_strategy.cc
@@ -61,8 +61,7 @@
CHECK_GT(max_radius_, 0.0);
}
-LevenbergMarquardtStrategy::~LevenbergMarquardtStrategy() {
-}
+LevenbergMarquardtStrategy::~LevenbergMarquardtStrategy() {}
TrustRegionStrategy::Summary LevenbergMarquardtStrategy::ComputeStep(
const TrustRegionStrategy::PerSolveOptions& per_solve_options,
@@ -81,8 +80,8 @@
jacobian->SquaredColumnNorm(diagonal_.data());
for (int i = 0; i < num_parameters; ++i) {
- diagonal_[i] = std::min(std::max(diagonal_[i], min_diagonal_),
- max_diagonal_);
+ diagonal_[i] =
+ std::min(std::max(diagonal_[i], min_diagonal_), max_diagonal_);
}
}
@@ -112,7 +111,7 @@
if (linear_solver_summary.termination_type == LINEAR_SOLVER_FATAL_ERROR) {
LOG(WARNING) << "Linear solver fatal error: "
<< linear_solver_summary.message;
- } else if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE) {
+ } else if (linear_solver_summary.termination_type == LINEAR_SOLVER_FAILURE) {
LOG(WARNING) << "Linear solver failure. Failed to compute a step: "
<< linear_solver_summary.message;
} else if (!IsArrayValid(num_parameters, step)) {
@@ -138,7 +137,6 @@
}
}
-
TrustRegionStrategy::Summary summary;
summary.residual_norm = linear_solver_summary.residual_norm;
summary.num_iterations = linear_solver_summary.num_iterations;
@@ -148,8 +146,8 @@
void LevenbergMarquardtStrategy::StepAccepted(double step_quality) {
CHECK_GT(step_quality, 0.0);
- radius_ = radius_ / std::max(1.0 / 3.0,
- 1.0 - pow(2.0 * step_quality - 1.0, 3));
+ radius_ =
+ radius_ / std::max(1.0 / 3.0, 1.0 - pow(2.0 * step_quality - 1.0, 3));
radius_ = std::min(max_radius_, radius_);
decrease_factor_ = 2.0;
reuse_diagonal_ = false;
@@ -161,9 +159,7 @@
reuse_diagonal_ = true;
}
-double LevenbergMarquardtStrategy::Radius() const {
- return radius_;
-}
+double LevenbergMarquardtStrategy::Radius() const { return radius_; }
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/levenberg_marquardt_strategy.h b/internal/ceres/levenberg_marquardt_strategy.h
index 8fb37f3..4cadd6d 100644
--- a/internal/ceres/levenberg_marquardt_strategy.h
+++ b/internal/ceres/levenberg_marquardt_strategy.h
@@ -74,7 +74,7 @@
const double max_diagonal_;
double decrease_factor_;
bool reuse_diagonal_;
- Vector diagonal_; // diagonal_ = diag(J'J)
+ Vector diagonal_; // diagonal_ = diag(J'J)
// Scaled copy of diagonal_. Stored here as optimization to prevent
// allocations in every iteration and reuse when a step fails and
// ComputeStep is called again.
diff --git a/internal/ceres/levenberg_marquardt_strategy_test.cc b/internal/ceres/levenberg_marquardt_strategy_test.cc
index f8f06bf..500f269 100644
--- a/internal/ceres/levenberg_marquardt_strategy_test.cc
+++ b/internal/ceres/levenberg_marquardt_strategy_test.cc
@@ -28,9 +28,11 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
-#include <memory>
-#include "ceres/internal/eigen.h"
#include "ceres/levenberg_marquardt_strategy.h"
+
+#include <memory>
+
+#include "ceres/internal/eigen.h"
#include "ceres/linear_solver.h"
#include "ceres/trust_region_strategy.h"
#include "glog/logging.h"
@@ -38,11 +40,11 @@
#include "gmock/mock-log.h"
#include "gtest/gtest.h"
+using testing::_;
using testing::AllOf;
using testing::AnyNumber;
using testing::HasSubstr;
using testing::ScopedMockLog;
-using testing::_;
namespace ceres {
namespace internal {
@@ -54,9 +56,7 @@
class RegularizationCheckingLinearSolver : public DenseSparseMatrixSolver {
public:
RegularizationCheckingLinearSolver(const int num_cols, const double* diagonal)
- : num_cols_(num_cols),
- diagonal_(diagonal) {
- }
+ : num_cols_(num_cols), diagonal_(diagonal) {}
virtual ~RegularizationCheckingLinearSolver() {}
@@ -152,11 +152,11 @@
#if defined(_MSC_VER)
// Use GLOG_WARNING to support MSVC if GLOG_NO_ABBREVIATED_SEVERITIES
// is defined.
- EXPECT_CALL(log, Log(GLOG_WARNING, _,
- HasSubstr("Failed to compute a step")));
+ EXPECT_CALL(log,
+ Log(GLOG_WARNING, _, HasSubstr("Failed to compute a step")));
#else
- EXPECT_CALL(log, Log(google::WARNING, _,
- HasSubstr("Failed to compute a step")));
+ EXPECT_CALL(log,
+ Log(google::WARNING, _, HasSubstr("Failed to compute a step")));
#endif
TrustRegionStrategy::Summary summary =
diff --git a/internal/ceres/line_search.cc b/internal/ceres/line_search.cc
index 352c64f..3f5103f 100644
--- a/internal/ceres/line_search.cc
+++ b/internal/ceres/line_search.cc
@@ -57,10 +57,10 @@
const int kErrorMessageNumericPrecision = 8;
} // namespace
-ostream& operator<<(ostream &os, const FunctionSample& sample);
+ostream& operator<<(ostream& os, const FunctionSample& sample);
// Convenience stream operator for pushing FunctionSamples into log messages.
-ostream& operator<<(ostream &os, const FunctionSample& sample) {
+ostream& operator<<(ostream& os, const FunctionSample& sample) {
os << sample.ToDebugString();
return os;
}
@@ -73,17 +73,17 @@
string* error) {
LineSearch* line_search = NULL;
switch (line_search_type) {
- case ceres::ARMIJO:
- line_search = new ArmijoLineSearch(options);
- break;
- case ceres::WOLFE:
- line_search = new WolfeLineSearch(options);
- break;
- default:
- *error = string("Invalid line search algorithm type: ") +
- LineSearchTypeToString(line_search_type) +
- string(", unable to create line search.");
- return NULL;
+ case ceres::ARMIJO:
+ line_search = new ArmijoLineSearch(options);
+ break;
+ case ceres::WOLFE:
+ line_search = new WolfeLineSearch(options);
+ break;
+ default:
+ *error = string("Invalid line search algorithm type: ") +
+ LineSearchTypeToString(line_search_type) +
+ string(", unable to create line search.");
+ return NULL;
}
return line_search;
}
@@ -96,8 +96,7 @@
initial_evaluator_residual_time_in_seconds(0.0),
initial_evaluator_jacobian_time_in_seconds(0.0) {}
-void LineSearchFunction::Init(const Vector& position,
- const Vector& direction) {
+void LineSearchFunction::Init(const Vector& position, const Vector& direction) {
position_ = position;
direction_ = direction;
}
@@ -200,9 +199,9 @@
summary->polynomial_minimization_time_in_seconds = 0.0;
options().function->ResetTimeStatistics();
this->DoSearch(step_size_estimate, initial_cost, initial_gradient, summary);
- options().function->
- TimeStatistics(&summary->cost_evaluation_time_in_seconds,
- &summary->gradient_evaluation_time_in_seconds);
+ options().function->TimeStatistics(
+ &summary->cost_evaluation_time_in_seconds,
+ &summary->gradient_evaluation_time_in_seconds);
summary->total_time_in_seconds = WallTimeInSeconds() - start_time;
}
@@ -218,8 +217,7 @@
const double min_step_size,
const double max_step_size) const {
if (!current.value_is_valid ||
- (interpolation_type == BISECTION &&
- max_step_size <= current.x)) {
+ (interpolation_type == BISECTION && max_step_size <= current.x)) {
// Either: sample is invalid; or we are using BISECTION and contracting
// the step size.
return std::min(std::max(current.x * 0.5, min_step_size), max_step_size);
@@ -274,8 +272,8 @@
}
double step_size = 0.0, unused_min_value = 0.0;
- MinimizeInterpolatingPolynomial(samples, min_step_size, max_step_size,
- &step_size, &unused_min_value);
+ MinimizeInterpolatingPolynomial(
+ samples, min_step_size, max_step_size, &step_size, &unused_min_value);
return step_size;
}
@@ -315,40 +313,38 @@
function->Evaluate(step_size_estimate, kEvaluateGradient, ¤t);
while (!current.value_is_valid ||
- current.value > (initial_cost
- + options().sufficient_decrease
- * initial_gradient
- * current.x)) {
+ current.value > (initial_cost + options().sufficient_decrease *
+ initial_gradient * current.x)) {
// If current.value_is_valid is false, we treat it as if the cost at that
// point is not large enough to satisfy the sufficient decrease condition.
++summary->num_iterations;
if (summary->num_iterations >= options().max_num_iterations) {
- summary->error =
- StringPrintf("Line search failed: Armijo failed to find a point "
- "satisfying the sufficient decrease condition within "
- "specified max_num_iterations: %d.",
- options().max_num_iterations);
+ summary->error = StringPrintf(
+ "Line search failed: Armijo failed to find a point "
+ "satisfying the sufficient decrease condition within "
+ "specified max_num_iterations: %d.",
+ options().max_num_iterations);
LOG_IF(WARNING, !options().is_silent) << summary->error;
return;
}
const double polynomial_minimization_start_time = WallTimeInSeconds();
- const double step_size =
- this->InterpolatingPolynomialMinimizingStepSize(
- options().interpolation_type,
- initial_position,
- previous,
- current,
- (options().max_step_contraction * current.x),
- (options().min_step_contraction * current.x));
+ const double step_size = this->InterpolatingPolynomialMinimizingStepSize(
+ options().interpolation_type,
+ initial_position,
+ previous,
+ current,
+ (options().max_step_contraction * current.x),
+ (options().min_step_contraction * current.x));
summary->polynomial_minimization_time_in_seconds +=
(WallTimeInSeconds() - polynomial_minimization_start_time);
if (step_size * descent_direction_max_norm < options().min_step_size) {
- summary->error =
- StringPrintf("Line search failed: step_size too small: %.5e "
- "with descent_direction_max_norm: %.5e.", step_size,
- descent_direction_max_norm);
+ summary->error = StringPrintf(
+ "Line search failed: step_size too small: %.5e "
+ "with descent_direction_max_norm: %.5e.",
+ step_size,
+ descent_direction_max_norm);
LOG_IF(WARNING, !options().is_silent) << summary->error;
return;
}
@@ -435,8 +431,8 @@
}
VLOG(3) << std::scientific << std::setprecision(kErrorMessageNumericPrecision)
- << "Starting line search zoom phase with bracket_low: "
- << bracket_low << ", bracket_high: " << bracket_high
+ << "Starting line search zoom phase with bracket_low: " << bracket_low
+ << ", bracket_high: " << bracket_high
<< ", bracket width: " << fabs(bracket_low.x - bracket_high.x)
<< ", bracket abs delta cost: "
<< fabs(bracket_low.value - bracket_high.value);
@@ -461,11 +457,9 @@
// but still has bracket_high.value < initial_position.value.
// 3. bracket_high is chosen after bracket_low, s.t.
// bracket_low.gradient * (bracket_high.x - bracket_low.x) < 0.
- if (!this->ZoomPhase(initial_position,
- bracket_low,
- bracket_high,
- &solution,
- summary) && !solution.value_is_valid) {
+ if (!this->ZoomPhase(
+ initial_position, bracket_low, bracket_high, &solution, summary) &&
+ !solution.value_is_valid) {
// Failed to find a valid point (given the specified decrease parameters)
// within the specified bracket.
return;
@@ -501,20 +495,18 @@
//
// Returns false if no step size > minimum step size was found which
// satisfies at least the Armijo condition.
-bool WolfeLineSearch::BracketingPhase(
- const FunctionSample& initial_position,
- const double step_size_estimate,
- FunctionSample* bracket_low,
- FunctionSample* bracket_high,
- bool* do_zoom_search,
- Summary* summary) const {
+bool WolfeLineSearch::BracketingPhase(const FunctionSample& initial_position,
+ const double step_size_estimate,
+ FunctionSample* bracket_low,
+ FunctionSample* bracket_high,
+ bool* do_zoom_search,
+ Summary* summary) const {
LineSearchFunction* function = options().function;
FunctionSample previous = initial_position;
FunctionSample current;
- const double descent_direction_max_norm =
- function->DirectionInfinityNorm();
+ const double descent_direction_max_norm = function->DirectionInfinityNorm();
*do_zoom_search = false;
*bracket_low = initial_position;
@@ -536,10 +528,9 @@
++summary->num_iterations;
if (current.value_is_valid &&
- (current.value > (initial_position.value
- + options().sufficient_decrease
- * initial_position.gradient
- * current.x) ||
+ (current.value > (initial_position.value +
+ options().sufficient_decrease *
+ initial_position.gradient * current.x) ||
(previous.value_is_valid && current.value > previous.value))) {
// Bracket found: current step size violates Armijo sufficient decrease
// condition, or has stepped past an inflection point of f() relative to
@@ -556,8 +547,8 @@
}
if (current.value_is_valid &&
- fabs(current.gradient) <=
- -options().sufficient_curvature_decrease * initial_position.gradient) {
+ fabs(current.gradient) <= -options().sufficient_curvature_decrease *
+ initial_position.gradient) {
// Current step size satisfies the strong Wolfe conditions, and is thus a
// valid termination point, therefore a Zoom not required.
*bracket_low = current;
@@ -585,8 +576,8 @@
break;
} else if (current.value_is_valid &&
- fabs(current.x - previous.x) * descent_direction_max_norm
- < options().min_step_size) {
+ fabs(current.x - previous.x) * descent_direction_max_norm <
+ options().min_step_size) {
// We have shrunk the search bracket to a width less than our tolerance,
// and still not found either a point satisfying the strong Wolfe
// conditions, or a valid bracket containing such a point. Stop searching
@@ -595,9 +586,9 @@
LOG_IF(WARNING, !options().is_silent)
<< "Line search failed: Wolfe bracketing phase shrank "
<< "bracket width: " << fabs(current.x - previous.x)
- << ", to < tolerance: " << options().min_step_size
- << ", with descent_direction_max_norm: "
- << descent_direction_max_norm << ", and failed to find "
+ << ", to < tolerance: " << options().min_step_size
+ << ", with descent_direction_max_norm: " << descent_direction_max_norm
+ << ", and failed to find "
<< "a point satisfying the strong Wolfe conditions or a "
<< "bracketing containing such a point. Accepting "
<< "point found satisfying Armijo condition only, to "
@@ -609,18 +600,20 @@
// Check num iterations bound here so that we always evaluate the
// max_num_iterations-th iteration against all conditions, and
// then perform no additional (unused) evaluations.
- summary->error =
- StringPrintf("Line search failed: Wolfe bracketing phase failed to "
- "find a point satisfying strong Wolfe conditions, or a "
- "bracket containing such a point within specified "
- "max_num_iterations: %d", options().max_num_iterations);
+ summary->error = StringPrintf(
+ "Line search failed: Wolfe bracketing phase failed to "
+ "find a point satisfying strong Wolfe conditions, or a "
+ "bracket containing such a point within specified "
+ "max_num_iterations: %d",
+ options().max_num_iterations);
LOG_IF(WARNING, !options().is_silent) << summary->error;
// Ensure that bracket_low is always set to the step size amongst all
// those tested which minimizes f() and satisfies the Armijo condition
// when we terminate due to the 'artificial' max_num_iterations condition.
*bracket_low =
current.value_is_valid && current.value < bracket_low->value
- ? current : *bracket_low;
+ ? current
+ : *bracket_low;
break;
}
// Either: f(current) is invalid; or, f(current) is valid, but does not
@@ -632,17 +625,16 @@
// size.
//
// In Nocedal & Wright [1] (p60), the step-size can only increase in the
- // bracketing phase: step_size_{k+1} \in [step_size_k, step_size_k * factor].
- // However this does not account for the function returning invalid values
- // which we support, in which case we need to contract the step size whilst
- // ensuring that we do not invert the bracket, i.e, we require that:
+ // bracketing phase: step_size_{k+1} \in [step_size_k, step_size_k *
+ // factor]. However this does not account for the function returning invalid
+ // values which we support, in which case we need to contract the step size
+ // whilst ensuring that we do not invert the bracket, i.e, we require that:
// step_size_{k-1} <= step_size_{k+1} < step_size_k.
const double min_step_size =
- current.value_is_valid
- ? current.x : previous.x;
+ current.value_is_valid ? current.x : previous.x;
const double max_step_size =
- current.value_is_valid
- ? (current.x * options().max_step_expansion) : current.x;
+ current.value_is_valid ? (current.x * options().max_step_expansion)
+ : current.x;
// We are performing 2-point interpolation only here, but the API of
// InterpolatingPolynomialMinimizingStepSize() allows for up to
@@ -652,21 +644,21 @@
DCHECK(!unused_previous.value_is_valid);
// Contracts step size if f(current) is not valid.
const double polynomial_minimization_start_time = WallTimeInSeconds();
- const double step_size =
- this->InterpolatingPolynomialMinimizingStepSize(
- options().interpolation_type,
- previous,
- unused_previous,
- current,
- min_step_size,
- max_step_size);
+ const double step_size = this->InterpolatingPolynomialMinimizingStepSize(
+ options().interpolation_type,
+ previous,
+ unused_previous,
+ current,
+ min_step_size,
+ max_step_size);
summary->polynomial_minimization_time_in_seconds +=
(WallTimeInSeconds() - polynomial_minimization_start_time);
if (step_size * descent_direction_max_norm < options().min_step_size) {
- summary->error =
- StringPrintf("Line search failed: step_size too small: %.5e "
- "with descent_direction_max_norm: %.5e", step_size,
- descent_direction_max_norm);
+ summary->error = StringPrintf(
+ "Line search failed: step_size too small: %.5e "
+ "with descent_direction_max_norm: %.5e",
+ step_size,
+ descent_direction_max_norm);
LOG_IF(WARNING, !options().is_silent) << summary->error;
return false;
}
@@ -684,8 +676,8 @@
// Ensure that even if a valid bracket was found, we will only mark a zoom
// as required if the bracket's width is greater than our minimum tolerance.
if (*do_zoom_search &&
- fabs(bracket_high->x - bracket_low->x) * descent_direction_max_norm
- < options().min_step_size) {
+ fabs(bracket_high->x - bracket_low->x) * descent_direction_max_norm <
+ options().min_step_size) {
*do_zoom_search = false;
}
@@ -707,8 +699,7 @@
<< std::scientific << std::setprecision(kErrorMessageNumericPrecision)
<< "Ceres bug: f_low input to Wolfe Zoom invalid, please contact "
<< "the developers!, initial_position: " << initial_position
- << ", bracket_low: " << bracket_low
- << ", bracket_high: "<< bracket_high;
+ << ", bracket_low: " << bracket_low << ", bracket_high: " << bracket_high;
// We do not require bracket_high.gradient_is_valid as the gradient condition
// for a valid bracket is only dependent upon bracket_low.gradient, and
// in order to minimize jacobian evaluations, bracket_high.gradient may
@@ -725,8 +716,7 @@
<< std::scientific << std::setprecision(kErrorMessageNumericPrecision)
<< "Ceres bug: f_high input to Wolfe Zoom invalid, please "
<< "contact the developers!, initial_position: " << initial_position
- << ", bracket_low: " << bracket_low
- << ", bracket_high: "<< bracket_high;
+ << ", bracket_low: " << bracket_low << ", bracket_high: " << bracket_high;
if (bracket_low.gradient * (bracket_high.x - bracket_low.x) >= 0) {
// The third condition for a valid initial bracket:
@@ -738,17 +728,17 @@
// returns inconsistent gradient values relative to the function values,
// we do not CHECK_LT(), but we do stop processing and return an invalid
// value.
- summary->error =
- StringPrintf("Line search failed: Wolfe zoom phase passed a bracket "
- "which does not satisfy: bracket_low.gradient * "
- "(bracket_high.x - bracket_low.x) < 0 [%.8e !< 0] "
- "with initial_position: %s, bracket_low: %s, bracket_high:"
- " %s, the most likely cause of which is the cost function "
- "returning inconsistent gradient & function values.",
- bracket_low.gradient * (bracket_high.x - bracket_low.x),
- initial_position.ToDebugString().c_str(),
- bracket_low.ToDebugString().c_str(),
- bracket_high.ToDebugString().c_str());
+ summary->error = StringPrintf(
+ "Line search failed: Wolfe zoom phase passed a bracket "
+ "which does not satisfy: bracket_low.gradient * "
+ "(bracket_high.x - bracket_low.x) < 0 [%.8e !< 0] "
+ "with initial_position: %s, bracket_low: %s, bracket_high:"
+ " %s, the most likely cause of which is the cost function "
+ "returning inconsistent gradient & function values.",
+ bracket_low.gradient * (bracket_high.x - bracket_low.x),
+ initial_position.ToDebugString().c_str(),
+ bracket_low.ToDebugString().c_str(),
+ bracket_high.ToDebugString().c_str());
LOG_IF(WARNING, !options().is_silent) << summary->error;
solution->value_is_valid = false;
return false;
@@ -763,24 +753,25 @@
// not satisfy the Wolfe condition.
*solution = bracket_low;
if (summary->num_iterations >= options().max_num_iterations) {
- summary->error =
- StringPrintf("Line search failed: Wolfe zoom phase failed to "
- "find a point satisfying strong Wolfe conditions "
- "within specified max_num_iterations: %d, "
- "(num iterations taken for bracketing: %d).",
- options().max_num_iterations, num_bracketing_iterations);
+ summary->error = StringPrintf(
+ "Line search failed: Wolfe zoom phase failed to "
+ "find a point satisfying strong Wolfe conditions "
+ "within specified max_num_iterations: %d, "
+ "(num iterations taken for bracketing: %d).",
+ options().max_num_iterations,
+ num_bracketing_iterations);
LOG_IF(WARNING, !options().is_silent) << summary->error;
return false;
}
- if (fabs(bracket_high.x - bracket_low.x) * descent_direction_max_norm
- < options().min_step_size) {
+ if (fabs(bracket_high.x - bracket_low.x) * descent_direction_max_norm <
+ options().min_step_size) {
// Bracket width has been reduced below tolerance, and no point satisfying
// the strong Wolfe conditions has been found.
- summary->error =
- StringPrintf("Line search failed: Wolfe zoom bracket width: %.5e "
- "too small with descent_direction_max_norm: %.5e.",
- fabs(bracket_high.x - bracket_low.x),
- descent_direction_max_norm);
+ summary->error = StringPrintf(
+ "Line search failed: Wolfe zoom bracket width: %.5e "
+ "too small with descent_direction_max_norm: %.5e.",
+ fabs(bracket_high.x - bracket_low.x),
+ descent_direction_max_norm);
LOG_IF(WARNING, !options().is_silent) << summary->error;
return false;
}
@@ -799,14 +790,13 @@
const FunctionSample unused_previous;
DCHECK(!unused_previous.value_is_valid);
const double polynomial_minimization_start_time = WallTimeInSeconds();
- const double step_size =
- this->InterpolatingPolynomialMinimizingStepSize(
- options().interpolation_type,
- lower_bound_step,
- unused_previous,
- upper_bound_step,
- lower_bound_step.x,
- upper_bound_step.x);
+ const double step_size = this->InterpolatingPolynomialMinimizingStepSize(
+ options().interpolation_type,
+ lower_bound_step,
+ unused_previous,
+ upper_bound_step,
+ lower_bound_step.x,
+ upper_bound_step.x);
summary->polynomial_minimization_time_in_seconds +=
(WallTimeInSeconds() - polynomial_minimization_start_time);
// No check on magnitude of step size being too small here as it is
@@ -826,12 +816,14 @@
const bool kEvaluateGradient = true;
function->Evaluate(step_size, kEvaluateGradient, solution);
if (!solution->value_is_valid || !solution->gradient_is_valid) {
- summary->error =
- StringPrintf("Line search failed: Wolfe Zoom phase found "
- "step_size: %.5e, for which function is invalid, "
- "between low_step: %.5e and high_step: %.5e "
- "at which function is valid.",
- solution->x, bracket_low.x, bracket_high.x);
+ summary->error = StringPrintf(
+ "Line search failed: Wolfe Zoom phase found "
+ "step_size: %.5e, for which function is invalid, "
+ "between low_step: %.5e and high_step: %.5e "
+ "at which function is valid.",
+ solution->x,
+ bracket_low.x,
+ bracket_high.x);
LOG_IF(WARNING, !options().is_silent) << summary->error;
return false;
}
@@ -842,10 +834,9 @@
<< ", bracket_high: " << bracket_high
<< ", minimizing solution: " << *solution;
- if ((solution->value > (initial_position.value
- + options().sufficient_decrease
- * initial_position.gradient
- * solution->x)) ||
+ if ((solution->value > (initial_position.value +
+ options().sufficient_decrease *
+ initial_position.gradient * solution->x)) ||
(solution->value >= bracket_low.value)) {
// Armijo sufficient decrease not satisfied, or not better
// than current lowest sample, use as new upper bound.
diff --git a/internal/ceres/line_search.h b/internal/ceres/line_search.h
index d59fd77..634c971 100644
--- a/internal/ceres/line_search.h
+++ b/internal/ceres/line_search.h
@@ -35,6 +35,7 @@
#include <string>
#include <vector>
+
#include "ceres/function_sample.h"
#include "ceres/internal/eigen.h"
#include "ceres/internal/port.h"
diff --git a/internal/ceres/line_search_direction.cc b/internal/ceres/line_search_direction.cc
index 1f9d205..74e9d91 100644
--- a/internal/ceres/line_search_direction.cc
+++ b/internal/ceres/line_search_direction.cc
@@ -29,9 +29,10 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/line_search_direction.h"
+
+#include "ceres/internal/eigen.h"
#include "ceres/line_search_minimizer.h"
#include "ceres/low_rank_inverse_hessian.h"
-#include "ceres/internal/eigen.h"
#include "glog/logging.h"
namespace ceres {
@@ -52,9 +53,7 @@
public:
NonlinearConjugateGradient(const NonlinearConjugateGradientType type,
const double function_tolerance)
- : type_(type),
- function_tolerance_(function_tolerance) {
- }
+ : type_(type), function_tolerance_(function_tolerance) {}
bool NextDirection(const LineSearchMinimizer::State& previous,
const LineSearchMinimizer::State& current,
@@ -72,14 +71,14 @@
break;
case HESTENES_STIEFEL:
gradient_change = current.gradient - previous.gradient;
- beta = (current.gradient.dot(gradient_change) /
- previous.search_direction.dot(gradient_change));
+ beta = (current.gradient.dot(gradient_change) /
+ previous.search_direction.dot(gradient_change));
break;
default:
LOG(FATAL) << "Unknown nonlinear conjugate gradient type: " << type_;
}
- *search_direction = -current.gradient + beta * previous.search_direction;
+ *search_direction = -current.gradient + beta * previous.search_direction;
const double directional_derivative =
current.gradient.dot(*search_direction);
if (directional_derivative > -function_tolerance_) {
@@ -144,8 +143,7 @@
class BFGS : public LineSearchDirection {
public:
- BFGS(const int num_parameters,
- const bool use_approximate_eigenvalue_scaling)
+ BFGS(const int num_parameters, const bool use_approximate_eigenvalue_scaling)
: num_parameters_(num_parameters),
use_approximate_eigenvalue_scaling_(use_approximate_eigenvalue_scaling),
initialized_(false),
@@ -212,8 +210,8 @@
if (delta_x_dot_delta_gradient <=
kBFGSSecantConditionHessianUpdateTolerance) {
VLOG(2) << "Skipping BFGS Update, delta_x_dot_delta_gradient too "
- << "small: " << delta_x_dot_delta_gradient << ", tolerance: "
- << kBFGSSecantConditionHessianUpdateTolerance
+ << "small: " << delta_x_dot_delta_gradient
+ << ", tolerance: " << kBFGSSecantConditionHessianUpdateTolerance
<< " (Secant condition).";
} else {
// Update dense inverse Hessian approximation.
@@ -300,13 +298,13 @@
// Calculate scalar: (1 + \rho_k * y_k' * H_k * y_k)
const double delta_x_times_delta_x_transpose_scale_factor =
- (1.0 + (rho_k * delta_gradient.transpose() *
- inverse_hessian_.selfadjointView<Eigen::Lower>() *
- delta_gradient));
+ (1.0 +
+ (rho_k * delta_gradient.transpose() *
+ inverse_hessian_.selfadjointView<Eigen::Lower>() * delta_gradient));
// Calculate: B = (1 + \rho_k * y_k' * H_k * y_k) * s_k * s_k'
Matrix B = Matrix::Zero(num_parameters_, num_parameters_);
- B.selfadjointView<Eigen::Lower>().
- rankUpdate(delta_x, delta_x_times_delta_x_transpose_scale_factor);
+ B.selfadjointView<Eigen::Lower>().rankUpdate(
+ delta_x, delta_x_times_delta_x_transpose_scale_factor);
// Finally, update inverse Hessian approximation according to:
// H_k = H_{k-1} + \rho_k * (B - (A + A')). Note that (A + A') is
@@ -315,9 +313,8 @@
rho_k * (B - A - A.transpose());
}
- *search_direction =
- inverse_hessian_.selfadjointView<Eigen::Lower>() *
- (-1.0 * current.gradient);
+ *search_direction = inverse_hessian_.selfadjointView<Eigen::Lower>() *
+ (-1.0 * current.gradient);
if (search_direction->dot(current.gradient) >= 0.0) {
LOG(WARNING) << "Numerical failure in BFGS update: inverse Hessian "
@@ -339,16 +336,15 @@
bool is_positive_definite_;
};
-LineSearchDirection*
-LineSearchDirection::Create(const LineSearchDirection::Options& options) {
+LineSearchDirection* LineSearchDirection::Create(
+ const LineSearchDirection::Options& options) {
if (options.type == STEEPEST_DESCENT) {
return new SteepestDescent;
}
if (options.type == NONLINEAR_CONJUGATE_GRADIENT) {
return new NonlinearConjugateGradient(
- options.nonlinear_conjugate_gradient_type,
- options.function_tolerance);
+ options.nonlinear_conjugate_gradient_type, options.function_tolerance);
}
if (options.type == ceres::LBFGS) {
diff --git a/internal/ceres/line_search_direction.h b/internal/ceres/line_search_direction.h
index 467578d..2fcf472 100644
--- a/internal/ceres/line_search_direction.h
+++ b/internal/ceres/line_search_direction.h
@@ -47,8 +47,7 @@
nonlinear_conjugate_gradient_type(FLETCHER_REEVES),
function_tolerance(1e-12),
max_lbfgs_rank(20),
- use_approximate_eigenvalue_bfgs_scaling(true) {
- }
+ use_approximate_eigenvalue_bfgs_scaling(true) {}
int num_parameters;
LineSearchDirectionType type;
diff --git a/internal/ceres/line_search_minimizer.cc b/internal/ceres/line_search_minimizer.cc
index 931f56c..5fed73c 100644
--- a/internal/ceres/line_search_minimizer.cc
+++ b/internal/ceres/line_search_minimizer.cc
@@ -41,8 +41,8 @@
#include "ceres/line_search_minimizer.h"
#include <algorithm>
-#include <cstdlib>
#include <cmath>
+#include <cstdlib>
#include <memory>
#include <string>
#include <vector>
@@ -88,7 +88,7 @@
Solver::Summary* summary) {
const bool is_not_silent = !options.is_silent;
double start_time = WallTimeInSeconds();
- double iteration_start_time = start_time;
+ double iteration_start_time = start_time;
CHECK(options.evaluator != nullptr);
Evaluator* evaluator = options.evaluator.get();
@@ -129,8 +129,9 @@
if (!EvaluateGradientNorms(evaluator, x, ¤t_state, &summary->message)) {
summary->termination_type = FAILURE;
- summary->message = "Initial cost and jacobian evaluation failed. "
- "More details: " + summary->message;
+ summary->message =
+ "Initial cost and jacobian evaluation failed. More details: " +
+ summary->message;
LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
return;
}
@@ -141,10 +142,10 @@
iteration_summary.gradient_norm = sqrt(current_state.gradient_squared_norm);
iteration_summary.gradient_max_norm = current_state.gradient_max_norm;
if (iteration_summary.gradient_max_norm <= options.gradient_tolerance) {
- summary->message = StringPrintf("Gradient tolerance reached. "
- "Gradient max norm: %e <= %e",
- iteration_summary.gradient_max_norm,
- options.gradient_tolerance);
+ summary->message =
+ StringPrintf("Gradient tolerance reached. Gradient max norm: %e <= %e",
+ iteration_summary.gradient_max_norm,
+ options.gradient_tolerance);
summary->termination_type = CONVERGENCE;
VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message;
return;
@@ -153,8 +154,7 @@
iteration_summary.iteration_time_in_seconds =
WallTimeInSeconds() - iteration_start_time;
iteration_summary.cumulative_time_in_seconds =
- WallTimeInSeconds() - start_time
- + summary->preprocessor_time_in_seconds;
+ WallTimeInSeconds() - start_time + summary->preprocessor_time_in_seconds;
summary->iterations.push_back(iteration_summary);
LineSearchDirection::Options line_search_direction_options;
@@ -189,10 +189,8 @@
line_search_options.is_silent = options.is_silent;
line_search_options.function = &line_search_function;
- std::unique_ptr<LineSearch>
- line_search(LineSearch::Create(options.line_search_type,
- line_search_options,
- &summary->message));
+ std::unique_ptr<LineSearch> line_search(LineSearch::Create(
+ options.line_search_type, line_search_options, &summary->message));
if (line_search.get() == nullptr) {
summary->termination_type = FAILURE;
LOG_IF(ERROR, is_not_silent) << "Terminating: " << summary->message;
@@ -216,7 +214,7 @@
}
const double total_solver_time = iteration_start_time - start_time +
- summary->preprocessor_time_in_seconds;
+ summary->preprocessor_time_in_seconds;
if (total_solver_time >= options.max_solver_time_in_seconds) {
summary->message = "Maximum solver time reached.";
summary->termination_type = NO_CONVERGENCE;
@@ -234,21 +232,19 @@
current_state.search_direction = -current_state.gradient;
} else {
line_search_status = line_search_direction->NextDirection(
- previous_state,
- current_state,
- ¤t_state.search_direction);
+ previous_state, current_state, ¤t_state.search_direction);
}
if (!line_search_status &&
num_line_search_direction_restarts >=
- options.max_num_line_search_direction_restarts) {
+ options.max_num_line_search_direction_restarts) {
// Line search direction failed to generate a new direction, and we
// have already reached our specified maximum number of restarts,
// terminate optimization.
- summary->message =
- StringPrintf("Line search direction failure: specified "
- "max_num_line_search_direction_restarts: %d reached.",
- options.max_num_line_search_direction_restarts);
+ summary->message = StringPrintf(
+ "Line search direction failure: specified "
+ "max_num_line_search_direction_restarts: %d reached.",
+ options.max_num_line_search_direction_restarts);
summary->termination_type = FAILURE;
LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
break;
@@ -261,14 +257,12 @@
++num_line_search_direction_restarts;
LOG_IF(WARNING, is_not_silent)
<< "Line search direction algorithm: "
- << LineSearchDirectionTypeToString(
- options.line_search_direction_type)
+ << LineSearchDirectionTypeToString(options.line_search_direction_type)
<< ", failed to produce a valid new direction at "
<< "iteration: " << iteration_summary.iteration
<< ". Restarting, number of restarts: "
<< num_line_search_direction_restarts << " / "
- << options.max_num_line_search_direction_restarts
- << " [max].";
+ << options.max_num_line_search_direction_restarts << " [max].";
line_search_direction.reset(
LineSearchDirection::Create(line_search_direction_options));
current_state.search_direction = -current_state.gradient;
@@ -286,19 +280,21 @@
// iteration.
const double initial_step_size =
(iteration_summary.iteration == 1 || !line_search_status)
- ? std::min(1.0, 1.0 / current_state.gradient_max_norm)
- : std::min(1.0, 2.0 * (current_state.cost - previous_state.cost) /
- current_state.directional_derivative);
+ ? std::min(1.0, 1.0 / current_state.gradient_max_norm)
+ : std::min(1.0,
+ 2.0 * (current_state.cost - previous_state.cost) /
+ current_state.directional_derivative);
// By definition, we should only ever go forwards along the specified search
// direction in a line search, most likely cause for this being violated
// would be a numerical failure in the line search direction calculation.
if (initial_step_size < 0.0) {
- summary->message =
- StringPrintf("Numerical failure in line search, initial_step_size is "
- "negative: %.5e, directional_derivative: %.5e, "
- "(current_cost - previous_cost): %.5e",
- initial_step_size, current_state.directional_derivative,
- (current_state.cost - previous_state.cost));
+ summary->message = StringPrintf(
+ "Numerical failure in line search, initial_step_size is "
+ "negative: %.5e, directional_derivative: %.5e, "
+ "(current_cost - previous_cost): %.5e",
+ initial_step_size,
+ current_state.directional_derivative,
+ (current_state.cost - previous_state.cost));
summary->termination_type = FAILURE;
LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
break;
@@ -309,13 +305,14 @@
current_state.directional_derivative,
&line_search_summary);
if (!line_search_summary.success) {
- summary->message =
- StringPrintf("Numerical failure in line search, failed to find "
- "a valid step size, (did not run out of iterations) "
- "using initial_step_size: %.5e, initial_cost: %.5e, "
- "initial_gradient: %.5e.",
- initial_step_size, current_state.cost,
- current_state.directional_derivative);
+ summary->message = StringPrintf(
+ "Numerical failure in line search, failed to find "
+ "a valid step size, (did not run out of iterations) "
+ "using initial_step_size: %.5e, initial_cost: %.5e, "
+ "initial_gradient: %.5e.",
+ initial_step_size,
+ current_state.cost,
+ current_state.directional_derivative);
LOG_IF(WARNING, is_not_silent) << "Terminating: " << summary->message;
summary->termination_type = FAILURE;
break;
@@ -373,7 +370,7 @@
iteration_summary.step_is_valid = true;
iteration_summary.step_is_successful = true;
- iteration_summary.step_size = current_state.step_size;
+ iteration_summary.step_size = current_state.step_size;
iteration_summary.line_search_function_evaluations =
line_search_summary.num_function_evaluations;
iteration_summary.line_search_gradient_evaluations =
@@ -383,8 +380,8 @@
iteration_summary.iteration_time_in_seconds =
WallTimeInSeconds() - iteration_start_time;
iteration_summary.cumulative_time_in_seconds =
- WallTimeInSeconds() - start_time
- + summary->preprocessor_time_in_seconds;
+ WallTimeInSeconds() - start_time +
+ summary->preprocessor_time_in_seconds;
summary->iterations.push_back(iteration_summary);
// Iterations inside the line search algorithm are considered
@@ -393,7 +390,7 @@
// minimizer. The number of line search steps is the total number
// of inner line search iterations (or steps) across the entire
// minimization.
- summary->num_line_search_steps += line_search_summary.num_iterations;
+ summary->num_line_search_steps += line_search_summary.num_iterations;
summary->line_search_cost_evaluation_time_in_seconds +=
line_search_summary.cost_evaluation_time_in_seconds;
summary->line_search_gradient_evaluation_time_in_seconds +=
@@ -404,25 +401,26 @@
line_search_summary.total_time_in_seconds;
++summary->num_successful_steps;
- const double step_size_tolerance = options.parameter_tolerance *
- (x_norm + options.parameter_tolerance);
+ const double step_size_tolerance =
+ options.parameter_tolerance * (x_norm + options.parameter_tolerance);
if (iteration_summary.step_norm <= step_size_tolerance) {
- summary->message =
- StringPrintf("Parameter tolerance reached. "
- "Relative step_norm: %e <= %e.",
- (iteration_summary.step_norm /
- (x_norm + options.parameter_tolerance)),
- options.parameter_tolerance);
+ summary->message = StringPrintf(
+ "Parameter tolerance reached. "
+ "Relative step_norm: %e <= %e.",
+ (iteration_summary.step_norm /
+ (x_norm + options.parameter_tolerance)),
+ options.parameter_tolerance);
summary->termination_type = CONVERGENCE;
VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message;
return;
}
if (iteration_summary.gradient_max_norm <= options.gradient_tolerance) {
- summary->message = StringPrintf("Gradient tolerance reached. "
- "Gradient max norm: %e <= %e",
- iteration_summary.gradient_max_norm,
- options.gradient_tolerance);
+ summary->message = StringPrintf(
+ "Gradient tolerance reached. "
+ "Gradient max norm: %e <= %e",
+ iteration_summary.gradient_max_norm,
+ options.gradient_tolerance);
summary->termination_type = CONVERGENCE;
VLOG_IF(1, is_not_silent) << "Terminating: " << summary->message;
break;
diff --git a/internal/ceres/line_search_minimizer.h b/internal/ceres/line_search_minimizer.h
index 191128a..79e8dc9 100644
--- a/internal/ceres/line_search_minimizer.h
+++ b/internal/ceres/line_search_minimizer.h
@@ -31,10 +31,10 @@
#ifndef CERES_INTERNAL_LINE_SEARCH_MINIMIZER_H_
#define CERES_INTERNAL_LINE_SEARCH_MINIMIZER_H_
+#include "ceres/internal/eigen.h"
#include "ceres/minimizer.h"
#include "ceres/solver.h"
#include "ceres/types.h"
-#include "ceres/internal/eigen.h"
#include "glog/logging.h"
namespace ceres {
@@ -46,15 +46,13 @@
class LineSearchMinimizer : public Minimizer {
public:
struct State {
- State(int num_parameters,
- int num_effective_parameters)
+ State(int num_parameters, int num_effective_parameters)
: cost(0.0),
gradient(num_effective_parameters),
gradient_squared_norm(0.0),
search_direction(num_effective_parameters),
directional_derivative(0.0),
- step_size(0.0) {
- }
+ step_size(0.0) {}
double cost;
Vector gradient;
diff --git a/internal/ceres/line_search_minimizer_test.cc b/internal/ceres/line_search_minimizer_test.cc
index 86623b0..2ef27b9 100644
--- a/internal/ceres/line_search_minimizer_test.cc
+++ b/internal/ceres/line_search_minimizer_test.cc
@@ -43,7 +43,6 @@
bool Evaluate(const double* parameters,
double* cost,
double* gradient) const final {
-
cost[0] = parameters[0] * parameters[0];
if (gradient != NULL) {
gradient[0] = 2.0 * parameters[0];
diff --git a/internal/ceres/line_search_preprocessor.cc b/internal/ceres/line_search_preprocessor.cc
index 5a21809..6a69425 100644
--- a/internal/ceres/line_search_preprocessor.cc
+++ b/internal/ceres/line_search_preprocessor.cc
@@ -32,6 +32,7 @@
#include <numeric>
#include <string>
+
#include "ceres/casts.h"
#include "ceres/context_impl.h"
#include "ceres/evaluator.h"
@@ -62,16 +63,14 @@
pp->evaluator_options.context = pp->problem->context();
pp->evaluator_options.evaluation_callback =
pp->reduced_program->mutable_evaluation_callback();
- pp->evaluator.reset(Evaluator::Create(pp->evaluator_options,
- pp->reduced_program.get(),
- &pp->error));
+ pp->evaluator.reset(Evaluator::Create(
+ pp->evaluator_options, pp->reduced_program.get(), &pp->error));
return (pp->evaluator.get() != NULL);
}
} // namespace
-LineSearchPreprocessor::~LineSearchPreprocessor() {
-}
+LineSearchPreprocessor::~LineSearchPreprocessor() {}
bool LineSearchPreprocessor::Preprocess(const Solver::Options& options,
ProblemImpl* problem,
@@ -86,10 +85,8 @@
return false;
}
- pp->reduced_program.reset(
- program->CreateReducedProgram(&pp->removed_parameter_blocks,
- &pp->fixed_cost,
- &pp->error));
+ pp->reduced_program.reset(program->CreateReducedProgram(
+ &pp->removed_parameter_blocks, &pp->fixed_cost, &pp->error));
if (pp->reduced_program.get() == NULL) {
return false;
diff --git a/internal/ceres/line_search_preprocessor_test.cc b/internal/ceres/line_search_preprocessor_test.cc
index 301509c..68860c5 100644
--- a/internal/ceres/line_search_preprocessor_test.cc
+++ b/internal/ceres/line_search_preprocessor_test.cc
@@ -28,9 +28,10 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/line_search_preprocessor.h"
+
#include <map>
-#include "ceres/line_search_preprocessor.h"
#include "ceres/problem_impl.h"
#include "ceres/sized_cost_function.h"
#include "ceres/solver.h"
diff --git a/internal/ceres/linear_least_squares_problems.cc b/internal/ceres/linear_least_squares_problems.cc
index 7c523d3..299051c 100644
--- a/internal/ceres/linear_least_squares_problems.cc
+++ b/internal/ceres/linear_least_squares_problems.cc
@@ -101,7 +101,7 @@
int counter = 0;
for (int i = 0; i < 3; ++i) {
- for (int j = 0; j< 2; ++j) {
+ for (int j = 0; j < 2; ++j) {
Ai[counter] = i;
Aj[counter] = j;
++counter;
@@ -132,7 +132,6 @@
return problem;
}
-
/*
A = [1 0 | 2 0 0
3 0 | 0 4 0
@@ -187,9 +186,8 @@
int num_cols = 5;
LinearLeastSquaresProblem* problem = new LinearLeastSquaresProblem;
- TripletSparseMatrix* A = new TripletSparseMatrix(num_rows,
- num_cols,
- num_rows * num_cols);
+ TripletSparseMatrix* A =
+ new TripletSparseMatrix(num_rows, num_cols, num_rows * num_cols);
problem->b.reset(new double[num_rows]);
problem->D.reset(new double[num_cols]);
problem->num_eliminate_blocks = 2;
@@ -404,7 +402,6 @@
return problem;
}
-
/*
A = [1 0
3 0
@@ -620,8 +617,7 @@
LOG(INFO) << "A^T: \n" << AA.transpose();
if (D != NULL) {
- LOG(INFO) << "A's appended diagonal:\n"
- << ConstVectorRef(D, A->num_cols());
+ LOG(INFO) << "A's appended diagonal:\n" << ConstVectorRef(D, A->num_cols());
}
if (b != NULL) {
@@ -659,10 +655,8 @@
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());
+ 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";
@@ -670,8 +664,8 @@
CHECK(fptr != nullptr);
A->ToTextFile(fptr);
fclose(fptr);
- StringAppendF(&matlab_script,
- "tmp = load('%s', '-ascii');\n", filename.c_str());
+ StringAppendF(
+ &matlab_script, "tmp = load('%s', '-ascii');\n", filename.c_str());
StringAppendF(
&matlab_script,
"lsqp.A = sparse(tmp(:, 1) + 1, tmp(:, 2) + 1, tmp(:, 3), %d, %d);\n",
@@ -679,26 +673,25 @@
A->num_cols());
}
-
if (D != NULL) {
string filename = filename_base + "_D.txt";
WriteArrayToFileOrDie(filename, D, A->num_cols());
- StringAppendF(&matlab_script,
- "lsqp.D = load('%s', '-ascii');\n", filename.c_str());
+ StringAppendF(
+ &matlab_script, "lsqp.D = load('%s', '-ascii');\n", filename.c_str());
}
if (b != NULL) {
string filename = filename_base + "_b.txt";
WriteArrayToFileOrDie(filename, b, A->num_rows());
- StringAppendF(&matlab_script,
- "lsqp.b = load('%s', '-ascii');\n", filename.c_str());
+ StringAppendF(
+ &matlab_script, "lsqp.b = load('%s', '-ascii');\n", filename.c_str());
}
if (x != NULL) {
string filename = filename_base + "_x.txt";
WriteArrayToFileOrDie(filename, x, A->num_cols());
- StringAppendF(&matlab_script,
- "lsqp.x = load('%s', '-ascii');\n", filename.c_str());
+ StringAppendF(
+ &matlab_script, "lsqp.x = load('%s', '-ascii');\n", filename.c_str());
}
string matlab_filename = filename_base + ".m";
@@ -716,12 +709,11 @@
int num_eliminate_blocks) {
switch (dump_format_type) {
case CONSOLE:
- return DumpLinearLeastSquaresProblemToConsole(A, D, b, x,
- num_eliminate_blocks);
+ return DumpLinearLeastSquaresProblemToConsole(
+ A, D, b, x, num_eliminate_blocks);
case TEXTFILE:
- return DumpLinearLeastSquaresProblemToTextFile(filename_base,
- A, D, b, x,
- num_eliminate_blocks);
+ return DumpLinearLeastSquaresProblemToTextFile(
+ filename_base, A, D, b, x, num_eliminate_blocks);
default:
LOG(FATAL) << "Unknown DumpFormatType " << dump_format_type;
}
diff --git a/internal/ceres/linear_least_squares_problems.h b/internal/ceres/linear_least_squares_problems.h
index 5dfcd34..939c2b4 100644
--- a/internal/ceres/linear_least_squares_problems.h
+++ b/internal/ceres/linear_least_squares_problems.h
@@ -34,8 +34,9 @@
#include <memory>
#include <string>
#include <vector>
-#include "ceres/sparse_matrix.h"
+
#include "ceres/internal/port.h"
+#include "ceres/sparse_matrix.h"
namespace ceres {
namespace internal {
@@ -43,9 +44,7 @@
// Structure defining a linear least squares problem and if possible
// ground truth solutions. To be used by various LinearSolver tests.
struct LinearLeastSquaresProblem {
- LinearLeastSquaresProblem()
- : num_eliminate_blocks(0) {
- }
+ LinearLeastSquaresProblem() : num_eliminate_blocks(0) {}
std::unique_ptr<SparseMatrix> A;
std::unique_ptr<double[]> b;
diff --git a/internal/ceres/linear_operator.cc b/internal/ceres/linear_operator.cc
index 9d291bd..548c724 100644
--- a/internal/ceres/linear_operator.cc
+++ b/internal/ceres/linear_operator.cc
@@ -33,8 +33,7 @@
namespace ceres {
namespace internal {
-LinearOperator::~LinearOperator() {
-}
+LinearOperator::~LinearOperator() {}
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/linear_solver.cc b/internal/ceres/linear_solver.cc
index 107af6a..6cae248 100644
--- a/internal/ceres/linear_solver.cc
+++ b/internal/ceres/linear_solver.cc
@@ -33,9 +33,9 @@
#include "ceres/cgnr_solver.h"
#include "ceres/dense_normal_cholesky_solver.h"
#include "ceres/dense_qr_solver.h"
+#include "ceres/dynamic_sparse_normal_cholesky_solver.h"
#include "ceres/iterative_schur_complement_solver.h"
#include "ceres/schur_complement_solver.h"
-#include "ceres/dynamic_sparse_normal_cholesky_solver.h"
#include "ceres/sparse_normal_cholesky_solver.h"
#include "ceres/types.h"
#include "glog/logging.h"
@@ -43,8 +43,7 @@
namespace ceres {
namespace internal {
-LinearSolver::~LinearSolver() {
-}
+LinearSolver::~LinearSolver() {}
LinearSolverType LinearSolver::LinearSolverForZeroEBlocks(
LinearSolverType linear_solver_type) {
@@ -112,8 +111,7 @@
return new DenseNormalCholeskySolver(options);
default:
- LOG(FATAL) << "Unknown linear solver type :"
- << options.type;
+ LOG(FATAL) << "Unknown linear solver type :" << options.type;
return NULL; // MSVC doesn't understand that LOG(FATAL) never returns.
}
}
diff --git a/internal/ceres/linear_solver.h b/internal/ceres/linear_solver.h
index cb624b3..47684e7 100644
--- a/internal/ceres/linear_solver.h
+++ b/internal/ceres/linear_solver.h
@@ -38,6 +38,7 @@
#include <map>
#include <string>
#include <vector>
+
#include "ceres/block_sparse_matrix.h"
#include "ceres/casts.h"
#include "ceres/compressed_row_sparse_matrix.h"
@@ -74,11 +75,11 @@
// algebra library should use before computing a sparse factorization
// (usually Cholesky).
enum OrderingType {
- NATURAL, // Do not re-order the matrix. This is useful when the
- // matrix has been ordered using a fill-reducing ordering
- // already.
- AMD // Use the Approximate Minimum Degree algorithm to re-order
- // the matrix.
+ NATURAL, // Do not re-order the matrix. This is useful when the
+ // matrix has been ordered using a fill-reducing ordering
+ // already.
+ AMD // Use the Approximate Minimum Degree algorithm to re-order
+ // the matrix.
};
class LinearOperator;
@@ -215,7 +216,6 @@
// used a preconditioner.
LinearOperator* preconditioner = nullptr;
-
// The following tolerance related options only makes sense for
// iterative solvers. Direct solvers ignore them.
@@ -329,10 +329,12 @@
// Linear solvers that depend on acccess to the low level structure of
// a SparseMatrix.
+// clang-format off
typedef TypedLinearSolver<BlockSparseMatrix> BlockSparseMatrixSolver; // NOLINT
typedef TypedLinearSolver<CompressedRowSparseMatrix> CompressedRowSparseMatrixSolver; // NOLINT
typedef TypedLinearSolver<DenseSparseMatrix> DenseSparseMatrixSolver; // NOLINT
typedef TypedLinearSolver<TripletSparseMatrix> TripletSparseMatrixSolver; // NOLINT
+// clang-format on
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/loss_function.cc b/internal/ceres/loss_function.cc
index 2c21a73..353f29a 100644
--- a/internal/ceres/loss_function.cc
+++ b/internal/ceres/loss_function.cc
@@ -52,7 +52,7 @@
const double r = sqrt(s);
rho[0] = 2.0 * a_ * r - b_;
rho[1] = std::max(std::numeric_limits<double>::min(), a_ / r);
- rho[2] = - rho[1] / (2.0 * s);
+ rho[2] = -rho[1] / (2.0 * s);
} else {
// Inlier region.
rho[0] = s;
@@ -67,7 +67,7 @@
// 'sum' and 'tmp' are always positive, assuming that 's' is.
rho[0] = 2.0 * b_ * (tmp - 1.0);
rho[1] = std::max(std::numeric_limits<double>::min(), 1.0 / tmp);
- rho[2] = - (c_ * rho[1]) / (2.0 * sum);
+ rho[2] = -(c_ * rho[1]) / (2.0 * sum);
}
void CauchyLoss::Evaluate(double s, double rho[3]) const {
@@ -76,7 +76,7 @@
// 'sum' and 'inv' are always positive, assuming that 's' is.
rho[0] = b_ * log(sum);
rho[1] = std::max(std::numeric_limits<double>::min(), inv);
- rho[2] = - c_ * (inv * inv);
+ rho[2] = -c_ * (inv * inv);
}
void ArctanLoss::Evaluate(double s, double rho[3]) const {
@@ -89,9 +89,7 @@
}
TolerantLoss::TolerantLoss(double a, double b)
- : a_(a),
- b_(b),
- c_(b * log(1.0 + exp(-a / b))) {
+ : a_(a), b_(b), c_(b * log(1.0 + exp(-a / b))) {
CHECK_GE(a, 0.0);
CHECK_GT(b, 0.0);
}
@@ -133,12 +131,11 @@
}
}
-ComposedLoss::ComposedLoss(const LossFunction* f, Ownership ownership_f,
- const LossFunction* g, Ownership ownership_g)
- : f_(f),
- g_(g),
- ownership_f_(ownership_f),
- ownership_g_(ownership_g) {
+ComposedLoss::ComposedLoss(const LossFunction* f,
+ Ownership ownership_f,
+ const LossFunction* g,
+ Ownership ownership_g)
+ : f_(f), g_(g), ownership_f_(ownership_f), ownership_g_(ownership_g) {
CHECK(f_ != nullptr);
CHECK(g_ != nullptr);
}
diff --git a/internal/ceres/loss_function_test.cc b/internal/ceres/loss_function_test.cc
index 6302dbe..638c0c9 100644
--- a/internal/ceres/loss_function_test.cc
+++ b/internal/ceres/loss_function_test.cc
@@ -66,7 +66,7 @@
ASSERT_NEAR(fd_1, rho[1], 1e-6);
// Second derivative.
- const double fd_2 = (fwd[0] - 2*rho[0] + bwd[0]) / (kH * kH);
+ const double fd_2 = (fwd[0] - 2 * rho[0] + bwd[0]) / (kH * kH);
ASSERT_NEAR(fd_2, rho[2], 1e-6);
}
} // namespace
@@ -219,15 +219,16 @@
AssertLossFunctionIsValid(scaled_loss, 1.792);
}
{
- ScaledLoss scaled_loss(
- new TolerantLoss(1.3, 0.1), 10, TAKE_OWNERSHIP);
+ ScaledLoss scaled_loss(new TolerantLoss(1.3, 0.1), 10, TAKE_OWNERSHIP);
AssertLossFunctionIsValid(scaled_loss, 1.792);
}
{
- ScaledLoss scaled_loss(
- new ComposedLoss(
- new HuberLoss(0.8), TAKE_OWNERSHIP,
- new TolerantLoss(1.3, 0.5), TAKE_OWNERSHIP), 10, TAKE_OWNERSHIP);
+ ScaledLoss scaled_loss(new ComposedLoss(new HuberLoss(0.8),
+ TAKE_OWNERSHIP,
+ new TolerantLoss(1.3, 0.5),
+ TAKE_OWNERSHIP),
+ 10,
+ TAKE_OWNERSHIP);
AssertLossFunctionIsValid(scaled_loss, 1.792);
}
}
@@ -235,8 +236,7 @@
TEST(LossFunction, LossFunctionWrapper) {
// Initialization
HuberLoss loss_function1(1.0);
- LossFunctionWrapper loss_function_wrapper(new HuberLoss(1.0),
- TAKE_OWNERSHIP);
+ LossFunctionWrapper loss_function_wrapper(new HuberLoss(1.0), TAKE_OWNERSHIP);
double s = 0.862;
double rho_gold[3];
@@ -281,7 +281,6 @@
for (int i = 0; i < 3; ++i) {
EXPECT_NEAR(rho[i], rho_gold[i], 1e-12);
}
-
}
} // namespace internal
diff --git a/internal/ceres/low_rank_inverse_hessian.cc b/internal/ceres/low_rank_inverse_hessian.cc
index f3953c4..c73e5db 100644
--- a/internal/ceres/low_rank_inverse_hessian.cc
+++ b/internal/ceres/low_rank_inverse_hessian.cc
@@ -28,10 +28,11 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/low_rank_inverse_hessian.h"
+
#include <list>
#include "ceres/internal/eigen.h"
-#include "ceres/low_rank_inverse_hessian.h"
#include "glog/logging.h"
namespace ceres {
@@ -84,8 +85,7 @@
approximate_eigenvalue_scale_(1.0),
delta_x_history_(num_parameters, max_num_corrections),
delta_gradient_history_(num_parameters, max_num_corrections),
- delta_x_dot_delta_gradient_(max_num_corrections) {
-}
+ delta_x_dot_delta_gradient_(max_num_corrections) {}
bool LowRankInverseHessian::Update(const Vector& delta_x,
const Vector& delta_gradient) {
@@ -93,13 +93,12 @@
if (delta_x_dot_delta_gradient <=
kLBFGSSecantConditionHessianUpdateTolerance) {
VLOG(2) << "Skipping L-BFGS Update, delta_x_dot_delta_gradient too "
- << "small: " << delta_x_dot_delta_gradient << ", tolerance: "
- << kLBFGSSecantConditionHessianUpdateTolerance
+ << "small: " << delta_x_dot_delta_gradient
+ << ", tolerance: " << kLBFGSSecantConditionHessianUpdateTolerance
<< " (Secant condition).";
return false;
}
-
int next = indices_.size();
// Once the size of the list reaches max_num_corrections_, simulate
// a circular buffer by removing the first element of the list and
@@ -132,7 +131,7 @@
it != indices_.rend();
++it) {
const double alpha_i = delta_x_history_.col(*it).dot(search_direction) /
- delta_x_dot_delta_gradient_(*it);
+ delta_x_dot_delta_gradient_(*it);
search_direction -= alpha_i * delta_gradient_history_.col(*it);
alpha(*it) = alpha_i;
}
@@ -177,7 +176,7 @@
for (const int i : indices_) {
const double beta = delta_gradient_history_.col(i).dot(search_direction) /
- delta_x_dot_delta_gradient_(i);
+ delta_x_dot_delta_gradient_(i);
search_direction += delta_x_history_.col(i) * (alpha(i) - beta);
}
}
diff --git a/internal/ceres/map_util.h b/internal/ceres/map_util.h
index f55aee3..6e310f8 100644
--- a/internal/ceres/map_util.h
+++ b/internal/ceres/map_util.h
@@ -34,6 +34,7 @@
#define CERES_INTERNAL_MAP_UTIL_H_
#include <utility>
+
#include "ceres/internal/port.h"
#include "glog/logging.h"
@@ -55,9 +56,9 @@
// This version assumes the key is printable, and includes it in the fatal log
// message.
template <class Collection>
-const typename Collection::value_type::second_type&
-FindOrDie(const Collection& collection,
- const typename Collection::value_type::first_type& key) {
+const typename Collection::value_type::second_type& FindOrDie(
+ const Collection& collection,
+ const typename Collection::value_type::first_type& key) {
typename Collection::const_iterator it = collection.find(key);
CHECK(it != collection.end()) << "Map key not found: " << key;
return it->second;
@@ -67,10 +68,10 @@
// If the key is present in the map then the value associated with that
// key is returned, otherwise the value passed as a default is returned.
template <class Collection>
-const typename Collection::value_type::second_type
-FindWithDefault(const Collection& collection,
- const typename Collection::value_type::first_type& key,
- const typename Collection::value_type::second_type& value) {
+const typename Collection::value_type::second_type FindWithDefault(
+ const Collection& collection,
+ const typename Collection::value_type::first_type& key,
+ const typename Collection::value_type::second_type& value) {
typename Collection::const_iterator it = collection.find(key);
if (it == collection.end()) {
return value;
@@ -84,7 +85,7 @@
// took place, false indicates the key was already present.
template <class Collection>
bool InsertIfNotPresent(
- Collection * const collection,
+ Collection* const collection,
const typename Collection::value_type::first_type& key,
const typename Collection::value_type::second_type& value) {
std::pair<typename Collection::iterator, bool> ret =
@@ -96,9 +97,9 @@
// Same as above but the returned pointer is not const and can be used to change
// the stored value.
template <class Collection>
-typename Collection::value_type::second_type*
-FindOrNull(Collection& collection, // NOLINT
- const typename Collection::value_type::first_type& key) {
+typename Collection::value_type::second_type* FindOrNull(
+ Collection& collection, // NOLINT
+ const typename Collection::value_type::first_type& key) {
typename Collection::iterator it = collection.find(key);
if (it == collection.end()) {
return 0;
@@ -116,13 +117,13 @@
// Inserts a new key/value into a map or hash_map.
// Dies if the key is already present.
-template<class Collection>
+template <class Collection>
void InsertOrDie(Collection* const collection,
const typename Collection::value_type::first_type& key,
const typename Collection::value_type::second_type& data) {
typedef typename Collection::value_type value_type;
CHECK(collection->insert(value_type(key, data)).second)
- << "duplicate key: " << key;
+ << "duplicate key: " << key;
}
} // namespace ceres
diff --git a/internal/ceres/miniglog/glog/logging.cc b/internal/ceres/miniglog/glog/logging.cc
index 372ecb0..0863f61 100644
--- a/internal/ceres/miniglog/glog/logging.cc
+++ b/internal/ceres/miniglog/glog/logging.cc
@@ -34,6 +34,6 @@
// This is the set of log sinks. This must be in a separate library to ensure
// that there is only one instance of this across the entire program.
-std::set<google::LogSink *> log_sinks_global;
+std::set<google::LogSink*> log_sinks_global;
-} // namespace ceres
+} // namespace google
diff --git a/internal/ceres/miniglog/glog/logging.h b/internal/ceres/miniglog/glog/logging.h
index 0fdf382..b442d08 100644
--- a/internal/ceres/miniglog/glog/logging.h
+++ b/internal/ceres/miniglog/glog/logging.h
@@ -93,7 +93,7 @@
#define CERCES_INTERNAL_MINIGLOG_GLOG_LOGGING_H_
#ifdef ANDROID
-# include <android/log.h>
+#include <android/log.h>
#endif // ANDROID
#include <algorithm>
@@ -106,24 +106,28 @@
#include <vector>
// For appropriate definition of CERES_EXPORT macro.
-#include "ceres/internal/port.h"
#include "ceres/internal/disable_warnings.h"
+#include "ceres/internal/port.h"
// Log severity level constants.
+// clang-format off
const int FATAL = -3;
const int ERROR = -2;
const int WARNING = -1;
const int INFO = 0;
+// clang-format on
// ------------------------- Glog compatibility ------------------------------
namespace google {
typedef int LogSeverity;
+// clang-format off
const int INFO = ::INFO;
const int WARNING = ::WARNING;
const int ERROR = ::ERROR;
const int FATAL = ::FATAL;
+// clang-format on
// Sink class used for integration with mock and test functions. If sinks are
// added, all log output is also sent to each sink through the send function.
@@ -143,20 +147,18 @@
};
// Global set of log sinks. The actual object is defined in logging.cc.
-extern CERES_EXPORT std::set<LogSink *> log_sinks_global;
+extern CERES_EXPORT std::set<LogSink*> log_sinks_global;
-inline void InitGoogleLogging(char *argv) {
+inline void InitGoogleLogging(char* argv) {
// Do nothing; this is ignored.
}
// Note: the Log sink functions are not thread safe.
-inline void AddLogSink(LogSink *sink) {
+inline void AddLogSink(LogSink* sink) {
// TODO(settinger): Add locks for thread safety.
log_sinks_global.insert(sink);
}
-inline void RemoveLogSink(LogSink *sink) {
- log_sinks_global.erase(sink);
-}
+inline void RemoveLogSink(LogSink* sink) { log_sinks_global.erase(sink); }
} // namespace google
@@ -170,8 +172,8 @@
// use of the log macros LG, LOG, or VLOG.
class CERES_EXPORT MessageLogger {
public:
- MessageLogger(const char *file, int line, const char *tag, int severity)
- : file_(file), line_(line), tag_(tag), severity_(severity) {
+ MessageLogger(const char* file, int line, const char* tag, int severity)
+ : file_(file), line_(line), tag_(tag), severity_(severity) {
// Pre-pend the stream with the file and line number.
StripBasename(std::string(file), &filename_only_);
stream_ << filename_only_ << ":" << line << " ";
@@ -193,8 +195,8 @@
// Bound the logging level.
const int kMaxVerboseLevel = 2;
- int android_level_index = std::min(std::max(FATAL, severity_),
- kMaxVerboseLevel) - FATAL;
+ int android_level_index =
+ std::min(std::max(FATAL, severity_), kMaxVerboseLevel) - FATAL;
int android_log_level = android_log_levels[android_level_index];
// Output the log string the Android log at the appropriate level.
@@ -202,9 +204,7 @@
// Indicate termination if needed.
if (severity_ == FATAL) {
- __android_log_write(ANDROID_LOG_FATAL,
- tag_.c_str(),
- "terminating.\n");
+ __android_log_write(ANDROID_LOG_FATAL, tag_.c_str(), "terminating.\n");
}
#else
// If not building on Android, log all output to std::cerr.
@@ -222,12 +222,12 @@
}
// Return the stream associated with the logger object.
- std::stringstream &stream() { return stream_; }
+ std::stringstream& stream() { return stream_; }
private:
void LogToSinks(int severity) {
time_t rawtime;
- time (&rawtime);
+ time(&rawtime);
struct tm timeinfo;
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
@@ -241,24 +241,31 @@
std::set<google::LogSink*>::iterator iter;
// Send the log message to all sinks.
for (iter = google::log_sinks_global.begin();
- iter != google::log_sinks_global.end(); ++iter) {
- (*iter)->send(severity, file_.c_str(), filename_only_.c_str(), line_,
- &timeinfo, stream_.str().c_str(), stream_.str().size());
+ iter != google::log_sinks_global.end();
+ ++iter) {
+ (*iter)->send(severity,
+ file_.c_str(),
+ filename_only_.c_str(),
+ line_,
+ &timeinfo,
+ stream_.str().c_str(),
+ stream_.str().size());
}
}
void WaitForSinks() {
// TODO(settinger): Add locks for thread safety.
- std::set<google::LogSink *>::iterator iter;
+ std::set<google::LogSink*>::iterator iter;
// Call WaitTillSent() for all sinks.
for (iter = google::log_sinks_global.begin();
- iter != google::log_sinks_global.end(); ++iter) {
+ iter != google::log_sinks_global.end();
+ ++iter) {
(*iter)->WaitTillSent();
}
}
- void StripBasename(const std::string &full_path, std::string *filename) {
+ void StripBasename(const std::string& full_path, std::string* filename) {
// TODO(settinger): Add support for OSs with different path separators.
const char kSeparator = '/';
size_t pos = full_path.rfind(kSeparator);
@@ -284,16 +291,18 @@
// is not used" and "statement has no effect".
class CERES_EXPORT LoggerVoidify {
public:
- LoggerVoidify() { }
+ LoggerVoidify() {}
// This has to be an operator with a precedence lower than << but
// higher than ?:
- void operator&(const std::ostream &s) { }
+ void operator&(const std::ostream& s) {}
};
// Log only if condition is met. Otherwise evaluates to void.
+// clang-format off
#define LOG_IF(severity, condition) \
!(condition) ? (void) 0 : LoggerVoidify() & \
MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()
+// clang-format on
// Log only if condition is NOT met. Otherwise evaluates to void.
#define LOG_IF_FALSE(severity, condition) LOG_IF(severity, !(condition))
@@ -301,6 +310,7 @@
// LG is a convenient shortcut for LOG(INFO). Its use is in new
// google3 code is discouraged and the following shortcut exists for
// backward compatibility with existing code.
+// clang-format off
#ifdef MAX_LOG_LEVEL
# define LOG(n) LOG_IF(n, n <= MAX_LOG_LEVEL)
# define VLOG(n) LOG_IF(n, n <= MAX_LOG_LEVEL)
@@ -326,37 +336,39 @@
# define DLOG(severity) true ? (void) 0 : LoggerVoidify() & \
MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()
#endif
-
+// clang-format on
// Log a message and terminate.
-template<class T>
-void LogMessageFatal(const char *file, int line, const T &message) {
- MessageLogger((char *)__FILE__, __LINE__, "native", FATAL).stream()
- << message;
+template <class T>
+void LogMessageFatal(const char* file, int line, const T& message) {
+ MessageLogger((char*)__FILE__, __LINE__, "native", FATAL).stream() << message;
}
// ---------------------------- CHECK macros ---------------------------------
// Check for a given boolean condition.
-#define CHECK(condition) LOG_IF_FALSE(FATAL, condition) \
- << "Check failed: " #condition " "
+#define CHECK(condition) \
+ LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
#ifndef NDEBUG
// Debug only version of CHECK
-# define DCHECK(condition) LOG_IF_FALSE(FATAL, condition) \
- << "Check failed: " #condition " "
+#define DCHECK(condition) \
+ LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
#else
// Optimized version - generates no code.
-# define DCHECK(condition) if (false) LOG_IF_FALSE(FATAL, condition) \
- << "Check failed: " #condition " "
+#define DCHECK(condition) \
+ if (false) LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
#endif // NDEBUG
// ------------------------- CHECK_OP macros ---------------------------------
// Generic binary operator check macro. This should not be directly invoked,
// instead use the binary comparison macros defined below.
-#define CHECK_OP(val1, val2, op) LOG_IF_FALSE(FATAL, ((val1) op (val2))) \
- << "Check failed: " #val1 " " #op " " #val2 " "
+#define CHECK_OP(val1, val2, op) \
+ LOG_IF_FALSE(FATAL, ((val1)op(val2))) \
+ << "Check failed: " #val1 " " #op " " #val2 " "
+
+// clang-format off
// Check_op macro definitions
#define CHECK_EQ(val1, val2) CHECK_OP(val1, val2, ==)
@@ -384,12 +396,14 @@
# define DCHECK_GT(val1, val2) if (false) CHECK_OP(val1, val2, >)
#endif // NDEBUG
+// clang-format on
+
// ---------------------------CHECK_NOTNULL macros ---------------------------
// Helpers for CHECK_NOTNULL(). Two are necessary to support both raw pointers
// and smart pointers.
template <typename T>
-T& CheckNotNullCommon(const char *file, int line, const char *names, T& t) {
+T& CheckNotNullCommon(const char* file, int line, const char* names, T& t) {
if (t == NULL) {
LogMessageFatal(file, line, std::string(names));
}
@@ -397,12 +411,12 @@
}
template <typename T>
-T* CheckNotNull(const char *file, int line, const char *names, T* t) {
+T* CheckNotNull(const char* file, int line, const char* names, T* t) {
return CheckNotNullCommon(file, line, names, t);
}
template <typename T>
-T& CheckNotNull(const char *file, int line, const char *names, T& t) {
+T& CheckNotNull(const char* file, int line, const char* names, T& t) {
return CheckNotNullCommon(file, line, names, t);
}
@@ -416,7 +430,8 @@
CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))
#else
// Optimized version - generates no code.
-#define DCHECK_NOTNULL(val) if (false)\
+#define DCHECK_NOTNULL(val) \
+ if (false) \
CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))
#endif // NDEBUG
diff --git a/internal/ceres/minimizer.cc b/internal/ceres/minimizer.cc
index f596033..4943a75 100644
--- a/internal/ceres/minimizer.cc
+++ b/internal/ceres/minimizer.cc
@@ -28,8 +28,9 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
-#include "ceres/line_search_minimizer.h"
#include "ceres/minimizer.h"
+
+#include "ceres/line_search_minimizer.h"
#include "ceres/trust_region_minimizer.h"
#include "ceres/types.h"
#include "glog/logging.h"
@@ -50,7 +51,6 @@
return NULL;
}
-
Minimizer::~Minimizer() {}
bool Minimizer::RunCallbacks(const Minimizer::Options& options,
diff --git a/internal/ceres/minimizer.h b/internal/ceres/minimizer.h
index afdd60d..69416b3 100644
--- a/internal/ceres/minimizer.h
+++ b/internal/ceres/minimizer.h
@@ -34,6 +34,7 @@
#include <memory>
#include <string>
#include <vector>
+
#include "ceres/internal/port.h"
#include "ceres/iteration_callback.h"
#include "ceres/solver.h"
@@ -54,13 +55,9 @@
// see solver.h for detailed information about the meaning and
// default values of each of these parameters.
struct Options {
- Options() {
- Init(Solver::Options());
- }
+ Options() { Init(Solver::Options()); }
- explicit Options(const Solver::Options& options) {
- Init(options);
- }
+ explicit Options(const Solver::Options& options) { Init(options); }
void Init(const Solver::Options& options) {
num_threads = options.num_threads;
@@ -92,8 +89,7 @@
max_lbfgs_rank = options.max_lbfgs_rank;
use_approximate_eigenvalue_bfgs_scaling =
options.use_approximate_eigenvalue_bfgs_scaling;
- line_search_interpolation_type =
- options.line_search_interpolation_type;
+ line_search_interpolation_type = options.line_search_interpolation_type;
min_line_search_step_size = options.min_line_search_step_size;
line_search_sufficient_function_decrease =
options.line_search_sufficient_function_decrease;
@@ -107,8 +103,7 @@
options.max_num_line_search_direction_restarts;
line_search_sufficient_curvature_decrease =
options.line_search_sufficient_curvature_decrease;
- max_line_search_step_expansion =
- options.max_line_search_step_expansion;
+ max_line_search_step_expansion = options.max_line_search_step_expansion;
inner_iteration_tolerance = options.inner_iteration_tolerance;
is_silent = (options.logging_type == SILENT);
is_constrained = false;
diff --git a/internal/ceres/minimizer_test.cc b/internal/ceres/minimizer_test.cc
index b0a2d96..3de4abe 100644
--- a/internal/ceres/minimizer_test.cc
+++ b/internal/ceres/minimizer_test.cc
@@ -28,10 +28,11 @@
//
// Author: keir@google.com (Keir Mierle)
-#include "gtest/gtest.h"
-#include "ceres/iteration_callback.h"
#include "ceres/minimizer.h"
+
+#include "ceres/iteration_callback.h"
#include "ceres/solver.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
diff --git a/internal/ceres/normal_prior.cc b/internal/ceres/normal_prior.cc
index a3d5d8e..4a62132 100644
--- a/internal/ceres/normal_prior.cc
+++ b/internal/ceres/normal_prior.cc
@@ -32,14 +32,14 @@
#include <cstddef>
#include <vector>
+
#include "ceres/internal/eigen.h"
#include "ceres/types.h"
#include "glog/logging.h"
namespace ceres {
-NormalPrior::NormalPrior(const Matrix& A, const Vector& b)
- : A_(A), b_(b) {
+NormalPrior::NormalPrior(const Matrix& A, const Vector& b) : A_(A), b_(b) {
CHECK_GT(b_.rows(), 0);
CHECK_GT(A_.rows(), 0);
CHECK_EQ(b_.rows(), A.cols());
diff --git a/internal/ceres/normal_prior_test.cc b/internal/ceres/normal_prior_test.cc
index 9abbf7f..518c18e 100644
--- a/internal/ceres/normal_prior_test.cc
+++ b/internal/ceres/normal_prior_test.cc
@@ -32,9 +32,9 @@
#include <cstddef>
-#include "gtest/gtest.h"
#include "ceres/internal/eigen.h"
#include "ceres/random.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -42,8 +42,7 @@
namespace {
void RandomVector(Vector* v) {
- for (int r = 0; r < v->rows(); ++r)
- (*v)[r] = 2 * RandDouble() - 1;
+ for (int r = 0; r < v->rows(); ++r) (*v)[r] = 2 * RandDouble() - 1;
}
void RandomMatrix(Matrix* m) {
@@ -67,11 +66,10 @@
Matrix A(num_rows, num_cols);
RandomMatrix(&A);
- double * x = new double[num_cols];
- for (int i = 0; i < num_cols; ++i)
- x[i] = 2 * RandDouble() - 1;
+ double* x = new double[num_cols];
+ for (int i = 0; i < num_cols; ++i) x[i] = 2 * RandDouble() - 1;
- double * jacobian = new double[num_rows * num_cols];
+ double* jacobian = new double[num_rows * num_cols];
Vector residuals(num_rows);
NormalPrior prior(A, b);
@@ -87,8 +85,8 @@
double jacobian_diff_norm = (J - A).norm();
EXPECT_NEAR(jacobian_diff_norm, 0.0, 1e-10);
- delete []x;
- delete []jacobian;
+ delete[] x;
+ delete[] jacobian;
}
}
}
@@ -104,9 +102,8 @@
Matrix A(num_rows, num_cols);
RandomMatrix(&A);
- double * x = new double[num_cols];
- for (int i = 0; i < num_cols; ++i)
- x[i] = 2 * RandDouble() - 1;
+ double* x = new double[num_cols];
+ for (int i = 0; i < num_cols; ++i) x[i] = 2 * RandDouble() - 1;
double* jacobians[1];
jacobians[0] = NULL;
@@ -127,8 +124,7 @@
(residuals - A * (VectorRef(x, num_cols) - b)).squaredNorm();
EXPECT_NEAR(residual_diff_norm, 0, 1e-10);
-
- delete []x;
+ delete[] x;
}
}
}
diff --git a/internal/ceres/numeric_diff_cost_function_test.cc b/internal/ceres/numeric_diff_cost_function_test.cc
index 20cf1b2..a5f7a15 100644
--- a/internal/ceres/numeric_diff_cost_function_test.cc
+++ b/internal/ceres/numeric_diff_cost_function_test.cc
@@ -50,39 +50,36 @@
TEST(NumericDiffCostFunction, EasyCaseFunctorCentralDifferences) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<EasyFunctor,
- CENTRAL,
- 3, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new EasyFunctor));
+ cost_function.reset(new NumericDiffCostFunction<EasyFunctor,
+ CENTRAL,
+ 3, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new EasyFunctor));
EasyFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
}
TEST(NumericDiffCostFunction, EasyCaseFunctorForwardDifferences) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<EasyFunctor,
- FORWARD,
- 3, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new EasyFunctor));
+ cost_function.reset(new NumericDiffCostFunction<EasyFunctor,
+ FORWARD,
+ 3, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new EasyFunctor));
EasyFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
}
TEST(NumericDiffCostFunction, EasyCaseFunctorRidders) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<EasyFunctor,
- RIDDERS,
- 3, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new EasyFunctor));
+ cost_function.reset(new NumericDiffCostFunction<EasyFunctor,
+ RIDDERS,
+ 3, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new EasyFunctor));
EasyFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
}
@@ -92,10 +89,10 @@
cost_function.reset(
new NumericDiffCostFunction<EasyCostFunction,
CENTRAL,
- 3, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new EasyCostFunction, TAKE_OWNERSHIP));
+ 3, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new EasyCostFunction, TAKE_OWNERSHIP));
EasyFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
}
@@ -105,10 +102,10 @@
cost_function.reset(
new NumericDiffCostFunction<EasyCostFunction,
FORWARD,
- 3, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new EasyCostFunction, TAKE_OWNERSHIP));
+ 3, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new EasyCostFunction, TAKE_OWNERSHIP));
EasyFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
}
@@ -118,44 +115,39 @@
cost_function.reset(
new NumericDiffCostFunction<EasyCostFunction,
RIDDERS,
- 3, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new EasyCostFunction, TAKE_OWNERSHIP));
+ 3, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new EasyCostFunction, TAKE_OWNERSHIP));
EasyFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
}
-TEST(NumericDiffCostFunction,
- TranscendentalCaseFunctorCentralDifferences) {
+TEST(NumericDiffCostFunction, TranscendentalCaseFunctorCentralDifferences) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<TranscendentalFunctor,
- CENTRAL,
- 2, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new TranscendentalFunctor));
+ cost_function.reset(new NumericDiffCostFunction<TranscendentalFunctor,
+ CENTRAL,
+ 2, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new TranscendentalFunctor));
TranscendentalFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
}
-TEST(NumericDiffCostFunction,
- TranscendentalCaseFunctorForwardDifferences) {
+TEST(NumericDiffCostFunction, TranscendentalCaseFunctorForwardDifferences) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<TranscendentalFunctor,
- FORWARD,
- 2, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new TranscendentalFunctor));
+ cost_function.reset(new NumericDiffCostFunction<TranscendentalFunctor,
+ FORWARD,
+ 2, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(new TranscendentalFunctor));
TranscendentalFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
}
-TEST(NumericDiffCostFunction,
- TranscendentalCaseFunctorRidders) {
+TEST(NumericDiffCostFunction, TranscendentalCaseFunctorRidders) {
NumericDiffOptions options;
// Using a smaller initial step size to overcome oscillatory function
@@ -163,13 +155,13 @@
options.ridders_relative_initial_step_size = 1e-3;
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<TranscendentalFunctor,
- RIDDERS,
- 2, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new TranscendentalFunctor, TAKE_OWNERSHIP, 2, options));
+ cost_function.reset(new NumericDiffCostFunction<TranscendentalFunctor,
+ RIDDERS,
+ 2, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(
+ new TranscendentalFunctor, TAKE_OWNERSHIP, 2, options));
TranscendentalFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
}
@@ -177,13 +169,13 @@
TEST(NumericDiffCostFunction,
TranscendentalCaseCostFunctionCentralDifferences) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<TranscendentalCostFunction,
- CENTRAL,
- 2, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new TranscendentalCostFunction, TAKE_OWNERSHIP));
+ cost_function.reset(new NumericDiffCostFunction<TranscendentalCostFunction,
+ CENTRAL,
+ 2, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(
+ new TranscendentalCostFunction, TAKE_OWNERSHIP));
TranscendentalFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
}
@@ -191,19 +183,18 @@
TEST(NumericDiffCostFunction,
TranscendentalCaseCostFunctionForwardDifferences) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<TranscendentalCostFunction,
- FORWARD,
- 2, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new TranscendentalCostFunction, TAKE_OWNERSHIP));
+ cost_function.reset(new NumericDiffCostFunction<TranscendentalCostFunction,
+ FORWARD,
+ 2, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(
+ new TranscendentalCostFunction, TAKE_OWNERSHIP));
TranscendentalFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, FORWARD);
}
-TEST(NumericDiffCostFunction,
- TranscendentalCaseCostFunctionRidders) {
+TEST(NumericDiffCostFunction, TranscendentalCaseCostFunctionRidders) {
NumericDiffOptions options;
// Using a smaller initial step size to overcome oscillatory function
@@ -211,18 +202,18 @@
options.ridders_relative_initial_step_size = 1e-3;
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<TranscendentalCostFunction,
- RIDDERS,
- 2, /* number of residuals */
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new TranscendentalCostFunction, TAKE_OWNERSHIP, 2, options));
+ cost_function.reset(new NumericDiffCostFunction<TranscendentalCostFunction,
+ RIDDERS,
+ 2, // number of residuals
+ 5, // size of x1
+ 5 // size of x2
+ >(
+ new TranscendentalCostFunction, TAKE_OWNERSHIP, 2, options));
TranscendentalFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, RIDDERS);
}
-template<int num_rows, int num_cols>
+template <int num_rows, int num_cols>
class SizeTestingCostFunction : public SizedCostFunction<num_rows, num_cols> {
public:
bool Evaluate(double const* const* parameters,
@@ -241,20 +232,20 @@
TEST(NumericDiffCostFunction, EigenRowMajorColMajorTest) {
std::unique_ptr<CostFunction> cost_function;
cost_function.reset(
- new NumericDiffCostFunction<SizeTestingCostFunction<1,1>, CENTRAL, 1, 1>(
- new SizeTestingCostFunction<1,1>, ceres::TAKE_OWNERSHIP));
+ new NumericDiffCostFunction<SizeTestingCostFunction<1, 1>, CENTRAL, 1, 1>(
+ new SizeTestingCostFunction<1, 1>, ceres::TAKE_OWNERSHIP));
cost_function.reset(
- new NumericDiffCostFunction<SizeTestingCostFunction<2,1>, CENTRAL, 2, 1>(
- new SizeTestingCostFunction<2,1>, ceres::TAKE_OWNERSHIP));
+ new NumericDiffCostFunction<SizeTestingCostFunction<2, 1>, CENTRAL, 2, 1>(
+ new SizeTestingCostFunction<2, 1>, ceres::TAKE_OWNERSHIP));
cost_function.reset(
- new NumericDiffCostFunction<SizeTestingCostFunction<1,2>, CENTRAL, 1, 2>(
- new SizeTestingCostFunction<1,2>, ceres::TAKE_OWNERSHIP));
+ new NumericDiffCostFunction<SizeTestingCostFunction<1, 2>, CENTRAL, 1, 2>(
+ new SizeTestingCostFunction<1, 2>, ceres::TAKE_OWNERSHIP));
cost_function.reset(
- new NumericDiffCostFunction<SizeTestingCostFunction<2,2>, CENTRAL, 2, 2>(
- new SizeTestingCostFunction<2,2>, ceres::TAKE_OWNERSHIP));
+ new NumericDiffCostFunction<SizeTestingCostFunction<2, 2>, CENTRAL, 2, 2>(
+ new SizeTestingCostFunction<2, 2>, ceres::TAKE_OWNERSHIP));
cost_function.reset(
new NumericDiffCostFunction<EasyFunctor, CENTRAL, ceres::DYNAMIC, 1, 1>(
@@ -288,21 +279,20 @@
new NumericDiffCostFunction<EasyFunctor,
CENTRAL,
ceres::DYNAMIC,
- 5, /* size of x1 */
- 5 /* size of x2 */>(
- new EasyFunctor, TAKE_OWNERSHIP, 3));
+ 5, // size of x1
+ 5 // size of x2
+ >(new EasyFunctor, TAKE_OWNERSHIP, 3));
EasyFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function, CENTRAL);
}
TEST(NumericDiffCostFunction, ExponentialFunctorRidders) {
std::unique_ptr<CostFunction> cost_function;
- cost_function.reset(
- new NumericDiffCostFunction<ExponentialFunctor,
- RIDDERS,
- 1, /* number of residuals */
- 1 /* size of x1 */>(
- new ExponentialFunctor));
+ cost_function.reset(new NumericDiffCostFunction<ExponentialFunctor,
+ RIDDERS,
+ 1, // number of residuals
+ 1 // size of x1
+ >(new ExponentialFunctor));
ExponentialFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
}
@@ -312,9 +302,9 @@
cost_function.reset(
new NumericDiffCostFunction<ExponentialCostFunction,
RIDDERS,
- 1, /* number of residuals */
- 1 /* size of x1 */>(
- new ExponentialCostFunction));
+ 1, // number of residuals
+ 1 // size of x1
+ >(new ExponentialCostFunction));
ExponentialFunctor functor;
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
}
@@ -326,14 +316,16 @@
// presence of random noise.
options.ridders_relative_initial_step_size = 10.0;
- cost_function.reset(
- new NumericDiffCostFunction<RandomizedFunctor,
- RIDDERS,
- 1, /* number of residuals */
- 1 /* size of x1 */>(
- new RandomizedFunctor(kNoiseFactor, kRandomSeed), TAKE_OWNERSHIP,
- 1, options));
- RandomizedFunctor functor (kNoiseFactor, kRandomSeed);
+ cost_function.reset(new NumericDiffCostFunction<RandomizedFunctor,
+ RIDDERS,
+ 1, // number of residuals
+ 1 // size of x1
+ >(
+ new RandomizedFunctor(kNoiseFactor, kRandomSeed),
+ TAKE_OWNERSHIP,
+ 1,
+ options));
+ RandomizedFunctor functor(kNoiseFactor, kRandomSeed);
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
}
@@ -344,14 +336,16 @@
// presence of random noise.
options.ridders_relative_initial_step_size = 10.0;
- cost_function.reset(
- new NumericDiffCostFunction<RandomizedCostFunction,
- RIDDERS,
- 1, /* number of residuals */
- 1 /* size of x1 */>(
- new RandomizedCostFunction(kNoiseFactor, kRandomSeed),
- TAKE_OWNERSHIP, 1, options));
- RandomizedFunctor functor (kNoiseFactor, kRandomSeed);
+ cost_function.reset(new NumericDiffCostFunction<RandomizedCostFunction,
+ RIDDERS,
+ 1, // number of residuals
+ 1 // size of x1
+ >(
+ new RandomizedCostFunction(kNoiseFactor, kRandomSeed),
+ TAKE_OWNERSHIP,
+ 1,
+ options));
+ RandomizedFunctor functor(kNoiseFactor, kRandomSeed);
functor.ExpectCostFunctionEvaluationIsNearlyCorrect(*cost_function);
}
diff --git a/internal/ceres/numeric_diff_test_utils.cc b/internal/ceres/numeric_diff_test_utils.cc
index ab1b5f8..d833bbb 100644
--- a/internal/ceres/numeric_diff_test_utils.cc
+++ b/internal/ceres/numeric_diff_test_utils.cc
@@ -33,12 +33,12 @@
#include <algorithm>
#include <cmath>
+
#include "ceres/cost_function.h"
#include "ceres/test_util.h"
#include "ceres/types.h"
#include "gtest/gtest.h"
-
namespace ceres {
namespace internal {
@@ -55,23 +55,22 @@
}
void EasyFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
- const CostFunction& cost_function,
- NumericDiffMethodType method) const {
- // The x1[0] is made deliberately small to test the performance near
- // zero.
+ const CostFunction& cost_function, NumericDiffMethodType method) const {
+ // The x1[0] is made deliberately small to test the performance near zero.
+ // clang-format off
double x1[] = { 1e-64, 2.0, 3.0, 4.0, 5.0 };
double x2[] = { 9.0, 9.0, 5.0, 5.0, 1.0 };
double *parameters[] = { &x1[0], &x2[0] };
+ // clang-format on
double dydx1[15]; // 3 x 5, row major.
double dydx2[15]; // 3 x 5, row major.
- double *jacobians[2] = { &dydx1[0], &dydx2[0] };
+ double* jacobians[2] = {&dydx1[0], &dydx2[0]};
- double residuals[3] = {-1e-100, -2e-100, -3e-100 };
+ double residuals[3] = {-1e-100, -2e-100, -3e-100};
- ASSERT_TRUE(cost_function.Evaluate(¶meters[0],
- &residuals[0],
- &jacobians[0]));
+ ASSERT_TRUE(
+ cost_function.Evaluate(¶meters[0], &residuals[0], &jacobians[0]));
double expected_residuals[3];
EasyFunctor functor;
@@ -97,12 +96,14 @@
}
for (int i = 0; i < 5; ++i) {
+ // clang-format off
ExpectClose(x2[i], dydx1[5 * 0 + i], tolerance); // y1
ExpectClose(x1[i], dydx2[5 * 0 + i], tolerance);
ExpectClose(2 * x2[i] * residuals[0], dydx1[5 * 1 + i], tolerance); // y2
ExpectClose(2 * x1[i] * residuals[0], dydx2[5 * 1 + i], tolerance);
ExpectClose(0.0, dydx1[5 * 2 + i], tolerance); // y3
ExpectClose(2 * x2[i], dydx2[5 * 2 + i], tolerance);
+ // clang-format on
}
}
@@ -119,14 +120,13 @@
}
void TranscendentalFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
- const CostFunction& cost_function,
- NumericDiffMethodType method) const {
-
+ const CostFunction& cost_function, NumericDiffMethodType method) const {
struct TestParameterBlocks {
double x1[5];
double x2[5];
};
+ // clang-format off
std::vector<TestParameterBlocks> kTests = {
{ { 1.0, 2.0, 3.0, 4.0, 5.0 }, // No zeros.
{ 9.0, 9.0, 5.0, 5.0, 1.0 },
@@ -147,21 +147,21 @@
{ 0.0, 0.0, 0.0, 0.0, 0.0 },
},
};
+ // clang-format on
for (int k = 0; k < kTests.size(); ++k) {
- double *x1 = &(kTests[k].x1[0]);
- double *x2 = &(kTests[k].x2[0]);
- double *parameters[] = { x1, x2 };
+ double* x1 = &(kTests[k].x1[0]);
+ double* x2 = &(kTests[k].x2[0]);
+ double* parameters[] = {x1, x2};
double dydx1[10];
double dydx2[10];
- double *jacobians[2] = { &dydx1[0], &dydx2[0] };
+ double* jacobians[2] = {&dydx1[0], &dydx2[0]};
double residuals[2];
- ASSERT_TRUE(cost_function.Evaluate(¶meters[0],
- &residuals[0],
- &jacobians[0]));
+ ASSERT_TRUE(
+ cost_function.Evaluate(¶meters[0], &residuals[0], &jacobians[0]));
double x1x2 = 0;
for (int i = 0; i < 5; ++i) {
x1x2 += x1[i] * x2[i];
@@ -184,39 +184,37 @@
}
for (int i = 0; i < 5; ++i) {
+ // clang-format off
ExpectClose( x2[i] * cos(x1x2), dydx1[5 * 0 + i], tolerance);
ExpectClose( x1[i] * cos(x1x2), dydx2[5 * 0 + i], tolerance);
ExpectClose(-x2[i] * exp(-x1x2 / 10.) / 10., dydx1[5 * 1 + i], tolerance);
ExpectClose(-x1[i] * exp(-x1x2 / 10.) / 10., dydx2[5 * 1 + i], tolerance);
+ // clang-format on
}
}
}
-bool ExponentialFunctor::operator()(const double* x1,
- double* residuals) const {
+bool ExponentialFunctor::operator()(const double* x1, double* residuals) const {
residuals[0] = exp(x1[0]);
return true;
}
-
void ExponentialFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
const CostFunction& cost_function) const {
// Evaluating the functor at specific points for testing.
- std::vector<double> kTests = { 1.0, 2.0, 3.0, 4.0, 5.0 };
+ std::vector<double> kTests = {1.0, 2.0, 3.0, 4.0, 5.0};
// Minimal tolerance w.r.t. the cost function and the tests.
const double kTolerance = 2e-14;
for (int k = 0; k < kTests.size(); ++k) {
- double *parameters[] = { &kTests[k] };
+ double* parameters[] = {&kTests[k]};
double dydx;
- double *jacobians[1] = { &dydx };
+ double* jacobians[1] = {&dydx};
double residual;
- ASSERT_TRUE(cost_function.Evaluate(¶meters[0],
- &residual,
- &jacobians[0]));
-
+ ASSERT_TRUE(
+ cost_function.Evaluate(¶meters[0], &residual, &jacobians[0]));
double expected_result = exp(kTests[k]);
@@ -228,10 +226,9 @@
}
}
-bool RandomizedFunctor::operator()(const double* x1,
- double* residuals) const {
- double random_value = static_cast<double>(rand()) /
- static_cast<double>(RAND_MAX);
+bool RandomizedFunctor::operator()(const double* x1, double* residuals) const {
+ double random_value =
+ static_cast<double>(rand()) / static_cast<double>(RAND_MAX);
// Normalize noise to [-factor, factor].
random_value *= 2.0;
@@ -244,7 +241,7 @@
void RandomizedFunctor::ExpectCostFunctionEvaluationIsNearlyCorrect(
const CostFunction& cost_function) const {
- std::vector<double> kTests = { 0.0, 1.0, 3.0, 4.0, 50.0 };
+ std::vector<double> kTests = {0.0, 1.0, 3.0, 4.0, 50.0};
const double kTolerance = 2e-4;
@@ -252,14 +249,13 @@
srand(random_seed_);
for (int k = 0; k < kTests.size(); ++k) {
- double *parameters[] = { &kTests[k] };
+ double* parameters[] = {&kTests[k]};
double dydx;
- double *jacobians[1] = { &dydx };
+ double* jacobians[1] = {&dydx};
double residual;
- ASSERT_TRUE(cost_function.Evaluate(¶meters[0],
- &residual,
- &jacobians[0]));
+ ASSERT_TRUE(
+ cost_function.Evaluate(¶meters[0], &residual, &jacobians[0]));
// Expect residual to be close to x^2 w.r.t. noise factor.
ExpectClose(residual, kTests[k] * kTests[k], noise_factor_);
diff --git a/internal/ceres/numeric_diff_test_utils.h b/internal/ceres/numeric_diff_test_utils.h
index 33497d9..462553c 100644
--- a/internal/ceres/numeric_diff_test_utils.h
+++ b/internal/ceres/numeric_diff_test_utils.h
@@ -51,8 +51,7 @@
public:
bool operator()(const double* x1, const double* x2, double* residuals) const;
void ExpectCostFunctionEvaluationIsNearlyCorrect(
- const CostFunction& cost_function,
- NumericDiffMethodType method) const;
+ const CostFunction& cost_function, NumericDiffMethodType method) const;
};
class EasyCostFunction : public SizedCostFunction<3, 5, 5> {
@@ -76,8 +75,7 @@
public:
bool operator()(const double* x1, const double* x2, double* residuals) const;
void ExpectCostFunctionEvaluationIsNearlyCorrect(
- const CostFunction& cost_function,
- NumericDiffMethodType method) const;
+ const CostFunction& cost_function, NumericDiffMethodType method) const;
};
class TranscendentalCostFunction : public SizedCostFunction<2, 5, 5> {
@@ -87,6 +85,7 @@
double** /* not used */) const final {
return functor_(parameters[0], parameters[1], residuals);
}
+
private:
TranscendentalFunctor functor_;
};
@@ -117,8 +116,7 @@
class RandomizedFunctor {
public:
RandomizedFunctor(double noise_factor, unsigned int random_seed)
- : noise_factor_(noise_factor), random_seed_(random_seed) {
- }
+ : noise_factor_(noise_factor), random_seed_(random_seed) {}
bool operator()(const double* x1, double* residuals) const;
void ExpectCostFunctionEvaluationIsNearlyCorrect(
@@ -132,8 +130,7 @@
class RandomizedCostFunction : public SizedCostFunction<1, 1> {
public:
RandomizedCostFunction(double noise_factor, unsigned int random_seed)
- : functor_(noise_factor, random_seed) {
- }
+ : functor_(noise_factor, random_seed) {}
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -145,7 +142,6 @@
RandomizedFunctor functor_;
};
-
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/ordered_groups_test.cc b/internal/ceres/ordered_groups_test.cc
index 8cf4324..d613a41 100644
--- a/internal/ceres/ordered_groups_test.cc
+++ b/internal/ceres/ordered_groups_test.cc
@@ -32,6 +32,7 @@
#include <cstddef>
#include <vector>
+
#include "gtest/gtest.h"
namespace ceres {
diff --git a/internal/ceres/pair_hash.h b/internal/ceres/pair_hash.h
index 80453ba..abbedcc 100644
--- a/internal/ceres/pair_hash.h
+++ b/internal/ceres/pair_hash.h
@@ -33,10 +33,11 @@
#ifndef CERES_INTERNAL_PAIR_HASH_H_
#define CERES_INTERNAL_PAIR_HASH_H_
-#include "ceres/internal/port.h"
#include <cstdint>
#include <utility>
+#include "ceres/internal/port.h"
+
namespace ceres {
namespace internal {
@@ -53,6 +54,8 @@
// in 18 cycles if you're lucky. On x86 architectures, this requires 45
// instructions in 27 cycles, if you're lucky.
//
+// clang-format off
+//
// 32bit version
inline void hash_mix(uint32_t& a, uint32_t& b, uint32_t& c) {
a -= b; a -= c; a ^= (c>>13);
@@ -78,6 +81,7 @@
b -= c; b -= a; b ^= (a<<49);
c -= a; c -= b; c ^= (b>>11);
}
+// clang-format on
inline uint32_t Hash32NumWithSeed(uint32_t num, uint32_t c) {
// The golden ratio; an arbitrary value.
diff --git a/internal/ceres/parallel_for_cxx.cc b/internal/ceres/parallel_for_cxx.cc
index 8e358f5..4da40c0 100644
--- a/internal/ceres/parallel_for_cxx.cc
+++ b/internal/ceres/parallel_for_cxx.cc
@@ -33,14 +33,13 @@
#ifdef CERES_USE_CXX_THREADS
-#include "ceres/parallel_for.h"
-
#include <cmath>
#include <condition_variable>
#include <memory>
#include <mutex>
#include "ceres/concurrent_queue.h"
+#include "ceres/parallel_for.h"
#include "ceres/scoped_thread_token.h"
#include "ceres/thread_token_provider.h"
#include "glog/logging.h"
@@ -117,9 +116,7 @@
} // namespace
-int MaxNumThreadsAvailable() {
- return ThreadPool::MaxNumThreadsAvailable();
-}
+int MaxNumThreadsAvailable() { return ThreadPool::MaxNumThreadsAvailable(); }
// See ParallelFor (below) for more details.
void ParallelFor(ContextImpl* context,
@@ -141,8 +138,10 @@
return;
}
- ParallelFor(context, start, end, num_threads,
- [&function](int /*thread_id*/, int i) { function(i); });
+ ParallelFor(
+ context, start, end, num_threads, [&function](int /*thread_id*/, int i) {
+ function(i);
+ });
}
// This implementation uses a fixed size max worker pool with a shared task
@@ -213,8 +212,7 @@
const int thread_id = scoped_thread_token.token();
// Perform each task.
- for (int j = shared_state->start + i;
- j < shared_state->end;
+ for (int j = shared_state->start + i; j < shared_state->end;
j += shared_state->num_work_items) {
function(thread_id, j);
}
@@ -244,4 +242,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/parallel_for_nothreads.cc b/internal/ceres/parallel_for_nothreads.cc
index e8f450a..d036569 100644
--- a/internal/ceres/parallel_for_nothreads.cc
+++ b/internal/ceres/parallel_for_nothreads.cc
@@ -72,7 +72,7 @@
}
}
-}
-}
+} // namespace internal
+} // namespace ceres
#endif // CERES_NO_THREADS
diff --git a/internal/ceres/parallel_for_openmp.cc b/internal/ceres/parallel_for_openmp.cc
index 8afe3b1..eb9d905 100644
--- a/internal/ceres/parallel_for_openmp.cc
+++ b/internal/ceres/parallel_for_openmp.cc
@@ -34,7 +34,6 @@
#if defined(CERES_USE_OPENMP)
#include "ceres/parallel_for.h"
-
#include "ceres/scoped_thread_token.h"
#include "ceres/thread_token_provider.h"
#include "glog/logging.h"
@@ -43,9 +42,7 @@
namespace ceres {
namespace internal {
-int MaxNumThreadsAvailable() {
- return omp_get_max_threads();
-}
+int MaxNumThreadsAvailable() { return omp_get_max_threads(); }
void ParallelFor(ContextImpl* context,
int start,
diff --git a/internal/ceres/parallel_for_test.cc b/internal/ceres/parallel_for_test.cc
index 04e5783..434f993 100644
--- a/internal/ceres/parallel_for_test.cc
+++ b/internal/ceres/parallel_for_test.cc
@@ -29,7 +29,9 @@
// Author: vitus@google.com (Michael Vitus)
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
#include "ceres/parallel_for.h"
@@ -64,8 +66,9 @@
for (int num_threads = 1; num_threads <= 8; ++num_threads) {
std::vector<int> values(size, 0);
- ParallelFor(&context, 0, size, num_threads,
- [&values](int i) { values[i] = std::sqrt(i); });
+ ParallelFor(&context, 0, size, num_threads, [&values](int i) {
+ values[i] = std::sqrt(i);
+ });
EXPECT_THAT(values, ElementsAreArray(expected_results));
}
}
@@ -84,8 +87,10 @@
for (int num_threads = 1; num_threads <= 8; ++num_threads) {
std::vector<int> values(size, 0);
- ParallelFor(&context, 0, size, num_threads,
- [&values](int thread_id, int i) { values[i] = std::sqrt(i); });
+ ParallelFor(
+ &context, 0, size, num_threads, [&values](int thread_id, int i) {
+ values[i] = std::sqrt(i);
+ });
EXPECT_THAT(values, ElementsAreArray(expected_results));
}
}
@@ -146,7 +151,10 @@
std::mutex mutex;
std::condition_variable condition;
int count = 0;
- ParallelFor(&context, 0, 2, 2,
+ ParallelFor(&context,
+ 0,
+ 2,
+ 2,
[&x, &mutex, &condition, &count](int thread_id, int i) {
std::unique_lock<std::mutex> lock(mutex);
x[i] = thread_id;
@@ -155,7 +163,7 @@
condition.wait(lock, [&]() { return count == 2; });
});
- EXPECT_THAT(x, UnorderedElementsAreArray({0,1}));
+ EXPECT_THAT(x, UnorderedElementsAreArray({0, 1}));
}
#endif // CERES_NO_THREADS
diff --git a/internal/ceres/parallel_utils_test.cc b/internal/ceres/parallel_utils_test.cc
index f997d25..53870bb 100644
--- a/internal/ceres/parallel_utils_test.cc
+++ b/internal/ceres/parallel_utils_test.cc
@@ -29,7 +29,10 @@
// Author: wjr@google.com (William Rucklidge)
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
+
#include "ceres/parallel_utils.h"
#include "glog/logging.h"
diff --git a/internal/ceres/parameter_block_ordering.cc b/internal/ceres/parameter_block_ordering.cc
index ef521c0..9899c24 100644
--- a/internal/ceres/parameter_block_ordering.cc
+++ b/internal/ceres/parameter_block_ordering.cc
@@ -50,11 +50,11 @@
using std::vector;
int ComputeStableSchurOrdering(const Program& program,
- vector<ParameterBlock*>* ordering) {
+ vector<ParameterBlock*>* ordering) {
CHECK(ordering != nullptr);
ordering->clear();
EventLogger event_logger("ComputeStableSchurOrdering");
- std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+ std::unique_ptr<Graph<ParameterBlock*>> graph(CreateHessianGraph(program));
event_logger.AddEvent("CreateHessianGraph");
const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
@@ -86,7 +86,7 @@
CHECK(ordering != nullptr);
ordering->clear();
- std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+ std::unique_ptr<Graph<ParameterBlock*>> graph(CreateHessianGraph(program));
int independent_set_size = IndependentSetOrdering(*graph, ordering);
const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
@@ -106,7 +106,7 @@
CHECK(ordering != nullptr);
ordering->Clear();
const vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
- std::unique_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
+ std::unique_ptr<Graph<ParameterBlock*>> graph(CreateHessianGraph(program));
int num_covered = 0;
int round = 0;
diff --git a/internal/ceres/parameter_block_ordering.h b/internal/ceres/parameter_block_ordering.h
index f996929..7b58afd 100644
--- a/internal/ceres/parameter_block_ordering.h
+++ b/internal/ceres/parameter_block_ordering.h
@@ -32,8 +32,9 @@
#define CERES_INTERNAL_PARAMETER_BLOCK_ORDERING_H_
#include <vector>
-#include "ceres/ordered_groups.h"
+
#include "ceres/graph.h"
+#include "ceres/ordered_groups.h"
#include "ceres/types.h"
namespace ceres {
@@ -56,13 +57,13 @@
// complement of the independent set,
// fixed blocks]
int ComputeSchurOrdering(const Program& program,
- std::vector<ParameterBlock* >* ordering);
+ std::vector<ParameterBlock*>* ordering);
// Same as above, except that ties while computing the independent set
// ordering are resolved in favour of the order in which the parameter
// blocks occur in the program.
int ComputeStableSchurOrdering(const Program& program,
- std::vector<ParameterBlock* >* ordering);
+ std::vector<ParameterBlock*>* ordering);
// Use an approximate independent set ordering to decompose the
// parameter blocks of a problem in a sequence of independent
diff --git a/internal/ceres/parameter_block_ordering_test.cc b/internal/ceres/parameter_block_ordering_test.cc
index 24dfdc9..1078893 100644
--- a/internal/ceres/parameter_block_ordering_test.cc
+++ b/internal/ceres/parameter_block_ordering_test.cc
@@ -61,7 +61,7 @@
};
class SchurOrderingTest : public ::testing::Test {
- protected :
+ protected:
void SetUp() final {
// The explicit calls to AddParameterBlock are necessary because
// the below tests depend on the specific numbering of the
@@ -75,8 +75,8 @@
problem_.AddResidualBlock(new DummyCostFunction<6, 5, 4>, NULL, z_, y_);
problem_.AddResidualBlock(new DummyCostFunction<3, 3, 5>, NULL, x_, z_);
problem_.AddResidualBlock(new DummyCostFunction<7, 5, 3>, NULL, z_, x_);
- problem_.AddResidualBlock(new DummyCostFunction<1, 5, 3, 6>, NULL,
- z_, x_, w_);
+ problem_.AddResidualBlock(
+ new DummyCostFunction<1, 5, 3, 6>, NULL, z_, x_, w_);
}
ProblemImpl problem_;
diff --git a/internal/ceres/parameter_dims_test.cc b/internal/ceres/parameter_dims_test.cc
index c832260..ee3be8f 100644
--- a/internal/ceres/parameter_dims_test.cc
+++ b/internal/ceres/parameter_dims_test.cc
@@ -25,6 +25,7 @@
#include "ceres/internal/parameter_dims.h"
#include <gtest/gtest.h>
+
#include <type_traits>
#include <utility>
@@ -35,15 +36,15 @@
static_assert(IsValidParameterDimensionSequence(std::integer_sequence<int>()) ==
true,
"Unit test of is valid parameter dimension sequence failed.");
-static_assert(
- IsValidParameterDimensionSequence(std::integer_sequence<int, 2, 1>()) == true,
- "Unit test of is valid parameter dimension sequence failed.");
-static_assert(
- IsValidParameterDimensionSequence(std::integer_sequence<int, 0, 1>()) == false,
- "Unit test of is valid parameter dimension sequence failed.");
-static_assert(
- IsValidParameterDimensionSequence(std::integer_sequence<int, 3, 0>()) == false,
- "Unit test of is valid parameter dimension sequence failed.");
+static_assert(IsValidParameterDimensionSequence(
+ std::integer_sequence<int, 2, 1>()) == true,
+ "Unit test of is valid parameter dimension sequence failed.");
+static_assert(IsValidParameterDimensionSequence(
+ std::integer_sequence<int, 0, 1>()) == false,
+ "Unit test of is valid parameter dimension sequence failed.");
+static_assert(IsValidParameterDimensionSequence(
+ std::integer_sequence<int, 3, 0>()) == false,
+ "Unit test of is valid parameter dimension sequence failed.");
// Static parameter dims unit test
static_assert(
diff --git a/internal/ceres/partitioned_matrix_view.h b/internal/ceres/partitioned_matrix_view.h
index 3853ea1..b8ac3b2 100644
--- a/internal/ceres/partitioned_matrix_view.h
+++ b/internal/ceres/partitioned_matrix_view.h
@@ -98,12 +98,14 @@
virtual void UpdateBlockDiagonalFtF(
BlockSparseMatrix* block_diagonal) const = 0;
+ // clang-format off
virtual int num_col_blocks_e() const = 0;
virtual int num_col_blocks_f() const = 0;
virtual int num_cols_e() const = 0;
virtual int num_cols_f() const = 0;
virtual int num_rows() const = 0;
virtual int num_cols() const = 0;
+ // clang-format on
static PartitionedMatrixViewBase* Create(const LinearSolver::Options& options,
const BlockSparseMatrix& matrix);
@@ -111,7 +113,7 @@
template <int kRowBlockSize = Eigen::Dynamic,
int kEBlockSize = Eigen::Dynamic,
- int kFBlockSize = Eigen::Dynamic >
+ int kFBlockSize = Eigen::Dynamic>
class PartitionedMatrixView : public PartitionedMatrixViewBase {
public:
// matrix = [E F], where the matrix E contains the first
@@ -127,12 +129,14 @@
BlockSparseMatrix* CreateBlockDiagonalFtF() const final;
void UpdateBlockDiagonalEtE(BlockSparseMatrix* block_diagonal) const final;
void UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const final;
+ // clang-format off
int num_col_blocks_e() const final { return num_col_blocks_e_; }
int num_col_blocks_f() const final { return num_col_blocks_f_; }
int num_cols_e() const final { return num_cols_e_; }
int num_cols_f() const final { return num_cols_f_; }
int num_rows() const final { return matrix_.num_rows(); }
int num_cols() const final { return matrix_.num_cols(); }
+ // clang-format on
private:
BlockSparseMatrix* CreateBlockDiagonalMatrixLayout(int start_col_block,
diff --git a/internal/ceres/partitioned_matrix_view_impl.h b/internal/ceres/partitioned_matrix_view_impl.h
index f3f548c..0b6a57f 100644
--- a/internal/ceres/partitioned_matrix_view_impl.h
+++ b/internal/ceres/partitioned_matrix_view_impl.h
@@ -28,14 +28,14 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
-#include "ceres/partitioned_matrix_view.h"
-
#include <algorithm>
#include <cstring>
#include <vector>
+
#include "ceres/block_sparse_matrix.h"
#include "ceres/block_structure.h"
#include "ceres/internal/eigen.h"
+#include "ceres/partitioned_matrix_view.h"
#include "ceres/small_blas.h"
#include "glog/logging.h"
@@ -44,11 +44,8 @@
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-PartitionedMatrixView(
- const BlockSparseMatrix& matrix,
- int num_col_blocks_e)
- : matrix_(matrix),
- num_col_blocks_e_(num_col_blocks_e) {
+ PartitionedMatrixView(const BlockSparseMatrix& matrix, int num_col_blocks_e)
+ : matrix_(matrix), num_col_blocks_e_(num_col_blocks_e) {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
CHECK(bs != nullptr);
@@ -85,8 +82,7 @@
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-~PartitionedMatrixView() {
-}
+ ~PartitionedMatrixView() {}
// The next four methods don't seem to be particularly cache
// friendly. This is an artifact of how the BlockStructure of the
@@ -94,9 +90,8 @@
// multithreading as well as improved data layout.
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-RightMultiplyE(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ RightMultiplyE(const double* x, double* y) const {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
// Iterate over the first num_row_blocks_e_ row blocks, and multiply
@@ -109,17 +104,18 @@
const int col_block_id = cell.block_id;
const int col_block_pos = bs->cols[col_block_id].position;
const int col_block_size = bs->cols[col_block_id].size;
+ // clang-format off
MatrixVectorMultiply<kRowBlockSize, kEBlockSize, 1>(
values + cell.position, row_block_size, col_block_size,
x + col_block_pos,
y + row_block_pos);
+ // clang-format on
}
}
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-RightMultiplyF(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ RightMultiplyF(const double* x, double* y) const {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
// Iterate over row blocks, and if the row block is in E, then
@@ -136,10 +132,12 @@
const int col_block_id = cells[c].block_id;
const int col_block_pos = bs->cols[col_block_id].position;
const int col_block_size = bs->cols[col_block_id].size;
+ // clang-format off
MatrixVectorMultiply<kRowBlockSize, kFBlockSize, 1>(
values + cells[c].position, row_block_size, col_block_size,
x + col_block_pos - num_cols_e_,
y + row_block_pos);
+ // clang-format on
}
}
@@ -151,18 +149,19 @@
const int col_block_id = cells[c].block_id;
const int col_block_pos = bs->cols[col_block_id].position;
const int col_block_size = bs->cols[col_block_id].size;
+ // clang-format off
MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
values + cells[c].position, row_block_size, col_block_size,
x + col_block_pos - num_cols_e_,
y + row_block_pos);
+ // clang-format on
}
}
}
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-LeftMultiplyE(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ LeftMultiplyE(const double* x, double* y) const {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
// Iterate over the first num_row_blocks_e_ row blocks, and multiply
@@ -175,17 +174,18 @@
const int col_block_id = cell.block_id;
const int col_block_pos = bs->cols[col_block_id].position;
const int col_block_size = bs->cols[col_block_id].size;
+ // clang-format off
MatrixTransposeVectorMultiply<kRowBlockSize, kEBlockSize, 1>(
values + cell.position, row_block_size, col_block_size,
x + row_block_pos,
y + col_block_pos);
+ // clang-format on
}
}
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-LeftMultiplyF(const double* x, double* y) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ LeftMultiplyF(const double* x, double* y) const {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
// Iterate over row blocks, and if the row block is in E, then
@@ -202,10 +202,12 @@
const int col_block_id = cells[c].block_id;
const int col_block_pos = bs->cols[col_block_id].position;
const int col_block_size = bs->cols[col_block_id].size;
+ // clang-format off
MatrixTransposeVectorMultiply<kRowBlockSize, kFBlockSize, 1>(
values + cells[c].position, row_block_size, col_block_size,
x + row_block_pos,
y + col_block_pos - num_cols_e_);
+ // clang-format on
}
}
@@ -217,10 +219,12 @@
const int col_block_id = cells[c].block_id;
const int col_block_pos = bs->cols[col_block_id].position;
const int col_block_size = bs->cols[col_block_id].size;
+ // clang-format off
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
values + cells[c].position, row_block_size, col_block_size,
x + row_block_pos,
y + col_block_pos - num_cols_e_);
+ // clang-format on
}
}
}
@@ -233,7 +237,8 @@
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
BlockSparseMatrix*
PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-CreateBlockDiagonalMatrixLayout(int start_col_block, int end_col_block) const {
+ CreateBlockDiagonalMatrixLayout(int start_col_block,
+ int end_col_block) const {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
CompressedRowBlockStructure* block_diagonal_structure =
new CompressedRowBlockStructure;
@@ -269,9 +274,10 @@
}
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-BlockSparseMatrix*
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-CreateBlockDiagonalEtE() const {
+BlockSparseMatrix* PartitionedMatrixView<kRowBlockSize,
+ kEBlockSize,
+ kFBlockSize>::CreateBlockDiagonalEtE()
+ const {
BlockSparseMatrix* block_diagonal =
CreateBlockDiagonalMatrixLayout(0, num_col_blocks_e_);
UpdateBlockDiagonalEtE(block_diagonal);
@@ -279,12 +285,12 @@
}
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-BlockSparseMatrix*
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-CreateBlockDiagonalFtF() const {
- BlockSparseMatrix* block_diagonal =
- CreateBlockDiagonalMatrixLayout(
- num_col_blocks_e_, num_col_blocks_e_ + num_col_blocks_f_);
+BlockSparseMatrix* PartitionedMatrixView<kRowBlockSize,
+ kEBlockSize,
+ kFBlockSize>::CreateBlockDiagonalFtF()
+ const {
+ BlockSparseMatrix* block_diagonal = CreateBlockDiagonalMatrixLayout(
+ num_col_blocks_e_, num_col_blocks_e_ + num_col_blocks_f_);
UpdateBlockDiagonalFtF(block_diagonal);
return block_diagonal;
}
@@ -295,17 +301,15 @@
// block_diagonal = block_diagonal(E'E)
//
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-UpdateBlockDiagonalEtE(
- BlockSparseMatrix* block_diagonal) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ UpdateBlockDiagonalEtE(BlockSparseMatrix* block_diagonal) const {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
const CompressedRowBlockStructure* block_diagonal_structure =
block_diagonal->block_structure();
block_diagonal->SetZero();
const double* values = matrix_.values();
- for (int r = 0; r < num_row_blocks_e_ ; ++r) {
+ for (int r = 0; r < num_row_blocks_e_; ++r) {
const Cell& cell = bs->rows[r].cells[0];
const int row_block_size = bs->rows[r].block.size;
const int block_id = cell.block_id;
@@ -313,12 +317,14 @@
const int cell_position =
block_diagonal_structure->rows[block_id].cells[0].position;
+ // clang-format off
MatrixTransposeMatrixMultiply
<kRowBlockSize, kEBlockSize, kRowBlockSize, kEBlockSize, 1>(
values + cell.position, row_block_size, col_block_size,
values + cell.position, row_block_size, col_block_size,
block_diagonal->mutable_values() + cell_position,
0, 0, col_block_size, col_block_size);
+ // clang-format on
}
}
@@ -328,9 +334,8 @@
// block_diagonal = block_diagonal(F'F)
//
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
-UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const {
+void PartitionedMatrixView<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ UpdateBlockDiagonalFtF(BlockSparseMatrix* block_diagonal) const {
const CompressedRowBlockStructure* bs = matrix_.block_structure();
const CompressedRowBlockStructure* block_diagonal_structure =
block_diagonal->block_structure();
@@ -347,12 +352,14 @@
const int cell_position =
block_diagonal_structure->rows[diagonal_block_id].cells[0].position;
+ // clang-format off
MatrixTransposeMatrixMultiply
<kRowBlockSize, kFBlockSize, kRowBlockSize, kFBlockSize, 1>(
values + cells[c].position, row_block_size, col_block_size,
values + cells[c].position, row_block_size, col_block_size,
block_diagonal->mutable_values() + cell_position,
0, 0, col_block_size, col_block_size);
+ // clang-format on
}
}
@@ -366,12 +373,14 @@
const int cell_position =
block_diagonal_structure->rows[diagonal_block_id].cells[0].position;
+ // clang-format off
MatrixTransposeMatrixMultiply
<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, 1>(
values + cells[c].position, row_block_size, col_block_size,
values + cells[c].position, row_block_size, col_block_size,
block_diagonal->mutable_values() + cell_position,
0, 0, col_block_size, col_block_size);
+ // clang-format on
}
}
}
diff --git a/internal/ceres/partitioned_matrix_view_test.cc b/internal/ceres/partitioned_matrix_view_test.cc
index 827cfb7..b66d0b8 100644
--- a/internal/ceres/partitioned_matrix_view_test.cc
+++ b/internal/ceres/partitioned_matrix_view_test.cc
@@ -32,6 +32,7 @@
#include <memory>
#include <vector>
+
#include "ceres/block_structure.h"
#include "ceres/casts.h"
#include "ceres/internal/eigen.h"
@@ -47,7 +48,7 @@
const double kEpsilon = 1e-14;
class PartitionedMatrixViewTest : public ::testing::Test {
- protected :
+ protected:
void SetUp() final {
srand(5);
std::unique_ptr<LinearLeastSquaresProblem> problem(
@@ -61,8 +62,7 @@
LinearSolver::Options options;
options.elimination_groups.push_back(num_eliminate_blocks_);
pmv_.reset(PartitionedMatrixViewBase::Create(
- options,
- *down_cast<BlockSparseMatrix*>(A_.get())));
+ options, *down_cast<BlockSparseMatrix*>(A_.get())));
}
int num_rows_;
@@ -143,9 +143,9 @@
}
TEST_F(PartitionedMatrixViewTest, BlockDiagonalEtE) {
- std::unique_ptr<BlockSparseMatrix>
- block_diagonal_ee(pmv_->CreateBlockDiagonalEtE());
- const CompressedRowBlockStructure* bs = block_diagonal_ee->block_structure();
+ std::unique_ptr<BlockSparseMatrix> block_diagonal_ee(
+ pmv_->CreateBlockDiagonalEtE());
+ const CompressedRowBlockStructure* bs = block_diagonal_ee->block_structure();
EXPECT_EQ(block_diagonal_ee->num_rows(), 2);
EXPECT_EQ(block_diagonal_ee->num_cols(), 2);
@@ -157,9 +157,9 @@
}
TEST_F(PartitionedMatrixViewTest, BlockDiagonalFtF) {
- std::unique_ptr<BlockSparseMatrix>
- block_diagonal_ff(pmv_->CreateBlockDiagonalFtF());
- const CompressedRowBlockStructure* bs = block_diagonal_ff->block_structure();
+ std::unique_ptr<BlockSparseMatrix> block_diagonal_ff(
+ pmv_->CreateBlockDiagonalFtF());
+ const CompressedRowBlockStructure* bs = block_diagonal_ff->block_structure();
EXPECT_EQ(block_diagonal_ff->num_rows(), 3);
EXPECT_EQ(block_diagonal_ff->num_cols(), 3);
diff --git a/internal/ceres/polynomial.h b/internal/ceres/polynomial.h
index 3e09bae..40e4150 100644
--- a/internal/ceres/polynomial.h
+++ b/internal/ceres/polynomial.h
@@ -33,6 +33,7 @@
#define CERES_INTERNAL_POLYNOMIAL_SOLVER_H_
#include <vector>
+
#include "ceres/internal/eigen.h"
#include "ceres/internal/port.h"
diff --git a/internal/ceres/polynomial_test.cc b/internal/ceres/polynomial_test.cc
index 00c8534..0ff73ea 100644
--- a/internal/ceres/polynomial_test.cc
+++ b/internal/ceres/polynomial_test.cc
@@ -31,13 +31,14 @@
#include "ceres/polynomial.h"
-#include <limits>
+#include <algorithm>
#include <cmath>
#include <cstddef>
-#include <algorithm>
-#include "gtest/gtest.h"
+#include <limits>
+
#include "ceres/function_sample.h"
#include "ceres/test_util.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -74,7 +75,7 @@
// Multiply poly by x^2 - 2real + abs(real,imag)^2
poly2.head(poly.size()) += poly;
poly2.segment(1, poly.size()) -= 2 * real * poly;
- poly2.tail(poly.size()) += (real*real + imag*imag) * poly;
+ poly2.tail(poly.size()) += (real * real + imag * imag) * poly;
return poly2;
}
@@ -90,7 +91,7 @@
// If use_real is false, NULL is passed as the real argument to
// FindPolynomialRoots. If use_imaginary is false, NULL is passed as the
// imaginary argument to FindPolynomialRoots.
-template<int N>
+template <int N>
void RunPolynomialTestRealRoots(const double (&real_roots)[N],
bool use_real,
bool use_imaginary,
@@ -142,32 +143,32 @@
}
TEST(Polynomial, LinearPolynomialWithPositiveRootWorks) {
- const double roots[1] = { 42.42 };
+ const double roots[1] = {42.42};
RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
}
TEST(Polynomial, LinearPolynomialWithNegativeRootWorks) {
- const double roots[1] = { -42.42 };
+ const double roots[1] = {-42.42};
RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
}
TEST(Polynomial, QuadraticPolynomialWithPositiveRootsWorks) {
- const double roots[2] = { 1.0, 42.42 };
+ const double roots[2] = {1.0, 42.42};
RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
}
TEST(Polynomial, QuadraticPolynomialWithOneNegativeRootWorks) {
- const double roots[2] = { -42.42, 1.0 };
+ const double roots[2] = {-42.42, 1.0};
RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
}
TEST(Polynomial, QuadraticPolynomialWithTwoNegativeRootsWorks) {
- const double roots[2] = { -42.42, -1.0 };
+ const double roots[2] = {-42.42, -1.0};
RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
}
TEST(Polynomial, QuadraticPolynomialWithCloseRootsWorks) {
- const double roots[2] = { 42.42, 42.43 };
+ const double roots[2] = {42.42, 42.43};
RunPolynomialTestRealRoots(roots, true, false, kEpsilonLoose);
}
@@ -190,37 +191,37 @@
}
TEST(Polynomial, QuarticPolynomialWorks) {
- const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+ const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
}
TEST(Polynomial, QuarticPolynomialWithTwoClustersOfCloseRootsWorks) {
- const double roots[4] = { 1.23e-1, 2.46e-1, 1.23e+5, 2.46e+5 };
+ const double roots[4] = {1.23e-1, 2.46e-1, 1.23e+5, 2.46e+5};
RunPolynomialTestRealRoots(roots, true, true, kEpsilonLoose);
}
TEST(Polynomial, QuarticPolynomialWithTwoZeroRootsWorks) {
- const double roots[4] = { -42.42, 0.0, 0.0, 42.42 };
+ const double roots[4] = {-42.42, 0.0, 0.0, 42.42};
RunPolynomialTestRealRoots(roots, true, true, 2 * kEpsilonLoose);
}
TEST(Polynomial, QuarticMonomialWorks) {
- const double roots[4] = { 0.0, 0.0, 0.0, 0.0 };
+ const double roots[4] = {0.0, 0.0, 0.0, 0.0};
RunPolynomialTestRealRoots(roots, true, true, kEpsilon);
}
TEST(Polynomial, NullPointerAsImaginaryPartWorks) {
- const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+ const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
RunPolynomialTestRealRoots(roots, true, false, kEpsilon);
}
TEST(Polynomial, NullPointerAsRealPartWorks) {
- const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+ const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
RunPolynomialTestRealRoots(roots, false, true, kEpsilon);
}
TEST(Polynomial, BothOutputArgumentsNullWorks) {
- const double roots[4] = { 1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5 };
+ const double roots[4] = {1.23e-4, 1.23e-1, 1.23e+2, 1.23e+5};
RunPolynomialTestRealRoots(roots, false, false, kEpsilon);
}
@@ -279,7 +280,6 @@
EXPECT_EQ(optimal_value, 2.0);
}
-
TEST(Polynomial, MinimizeQuadraticPolynomial) {
// p(x) = x^2 - 3 x + 2
// min_x = 3/2
@@ -294,8 +294,8 @@
double min_x = -2.0;
double max_x = 2.0;
MinimizePolynomial(polynomial, min_x, max_x, &optimal_x, &optimal_value);
- EXPECT_EQ(optimal_x, 3.0/2.0);
- EXPECT_EQ(optimal_value, -1.0/4.0);
+ EXPECT_EQ(optimal_x, 3.0 / 2.0);
+ EXPECT_EQ(optimal_value, -1.0 / 4.0);
min_x = -2.0;
max_x = 1.0;
@@ -402,7 +402,6 @@
EXPECT_NEAR((true_polynomial - polynomial).norm(), 0.0, 1e-14);
}
-
TEST(Polynomial, CubicInterpolatingPolynomialFromValues) {
// p(x) = x^3 + 2x^2 + 3x + 2
Vector true_polynomial(4);
diff --git a/internal/ceres/preconditioner.cc b/internal/ceres/preconditioner.cc
index f98374e..69ba04d 100644
--- a/internal/ceres/preconditioner.cc
+++ b/internal/ceres/preconditioner.cc
@@ -29,13 +29,13 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include "ceres/preconditioner.h"
+
#include "glog/logging.h"
namespace ceres {
namespace internal {
-Preconditioner::~Preconditioner() {
-}
+Preconditioner::~Preconditioner() {}
PreconditionerType Preconditioner::PreconditionerForZeroEBlocks(
PreconditionerType preconditioner_type) {
@@ -53,8 +53,7 @@
CHECK(matrix != nullptr);
}
-SparseMatrixPreconditionerWrapper::~SparseMatrixPreconditionerWrapper() {
-}
+SparseMatrixPreconditionerWrapper::~SparseMatrixPreconditionerWrapper() {}
bool SparseMatrixPreconditionerWrapper::UpdateImpl(const SparseMatrix& A,
const double* D) {
@@ -66,7 +65,7 @@
matrix_->RightMultiply(x, y);
}
-int SparseMatrixPreconditionerWrapper::num_rows() const {
+int SparseMatrixPreconditionerWrapper::num_rows() const {
return matrix_->num_rows();
}
diff --git a/internal/ceres/preconditioner.h b/internal/ceres/preconditioner.h
index 3e46ed8..b10364b 100644
--- a/internal/ceres/preconditioner.h
+++ b/internal/ceres/preconditioner.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_PRECONDITIONER_H_
#include <vector>
+
#include "ceres/casts.h"
#include "ceres/compressed_row_sparse_matrix.h"
#include "ceres/context_impl.h"
@@ -50,7 +51,8 @@
struct Options {
PreconditionerType type = JACOBI;
VisibilityClusteringType visibility_clustering_type = CANONICAL_VIEWS;
- SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type = SUITE_SPARSE;
+ SparseLinearAlgebraLibraryType sparse_linear_algebra_library_type =
+ SUITE_SPARSE;
// When using the subset preconditioner, all row blocks starting
// from this row block are used to construct the preconditioner.
@@ -137,9 +139,7 @@
}
int num_rows() const override = 0;
- int num_cols() const override {
- return num_rows();
- }
+ int num_cols() const override { return num_rows(); }
};
// This templated subclass of Preconditioner serves as a base class for
@@ -159,9 +159,11 @@
// Preconditioners that depend on access to the low level structure
// of a SparseMatrix.
-typedef TypedPreconditioner<SparseMatrix> SparseMatrixPreconditioner; // NOLINT
-typedef TypedPreconditioner<BlockSparseMatrix> BlockSparseMatrixPreconditioner; // NOLINT
-typedef TypedPreconditioner<CompressedRowSparseMatrix> CompressedRowSparseMatrixPreconditioner; // NOLINT
+// clang-format off
+typedef TypedPreconditioner<SparseMatrix> SparseMatrixPreconditioner;
+typedef TypedPreconditioner<BlockSparseMatrix> BlockSparseMatrixPreconditioner;
+typedef TypedPreconditioner<CompressedRowSparseMatrix> CompressedRowSparseMatrixPreconditioner;
+// clang-format on
// Wrap a SparseMatrix object as a preconditioner.
class SparseMatrixPreconditionerWrapper : public SparseMatrixPreconditioner {
diff --git a/internal/ceres/preprocessor.cc b/internal/ceres/preprocessor.cc
index 0221914..6a67d38 100644
--- a/internal/ceres/preprocessor.cc
+++ b/internal/ceres/preprocessor.cc
@@ -28,11 +28,12 @@
//
// Author: sameragarwal@google.com (Sameer Agarwal)
+#include "ceres/preprocessor.h"
+
#include "ceres/callbacks.h"
#include "ceres/gradient_checking_cost_function.h"
#include "ceres/line_search_preprocessor.h"
#include "ceres/parallel_for.h"
-#include "ceres/preprocessor.h"
#include "ceres/problem_impl.h"
#include "ceres/solver.h"
#include "ceres/trust_region_preprocessor.h"
@@ -53,17 +54,15 @@
return NULL;
}
-Preprocessor::~Preprocessor() {
-}
+Preprocessor::~Preprocessor() {}
void ChangeNumThreadsIfNeeded(Solver::Options* options) {
const int num_threads_available = MaxNumThreadsAvailable();
if (options->num_threads > num_threads_available) {
- LOG(WARNING)
- << "Specified options.num_threads: " << options->num_threads
- << " exceeds maximum available from the threading model Ceres "
- << "was compiled with: " << num_threads_available
- << ". Bounding to maximum number available.";
+ LOG(WARNING) << "Specified options.num_threads: " << options->num_threads
+ << " exceeds maximum available from the threading model Ceres "
+ << "was compiled with: " << num_threads_available
+ << ". Bounding to maximum number available.";
options->num_threads = num_threads_available;
}
}
@@ -83,16 +82,15 @@
minimizer_options.evaluator = pp->evaluator;
if (options.logging_type != SILENT) {
- pp->logging_callback.reset(
- new LoggingCallback(options.minimizer_type,
- options.minimizer_progress_to_stdout));
+ pp->logging_callback.reset(new LoggingCallback(
+ options.minimizer_type, options.minimizer_progress_to_stdout));
minimizer_options.callbacks.insert(minimizer_options.callbacks.begin(),
pp->logging_callback.get());
}
if (options.update_state_every_iteration) {
pp->state_updating_callback.reset(
- new StateUpdatingCallback(program, reduced_parameters));
+ new StateUpdatingCallback(program, reduced_parameters));
// This must get pushed to the front of the callbacks so that it
// is run before any of the user callbacks.
minimizer_options.callbacks.insert(minimizer_options.callbacks.begin(),
diff --git a/internal/ceres/preprocessor.h b/internal/ceres/preprocessor.h
index 99bd6c0..e69c790 100644
--- a/internal/ceres/preprocessor.h
+++ b/internal/ceres/preprocessor.h
@@ -80,9 +80,7 @@
// A PreprocessedProblem is the result of running the Preprocessor on
// a Problem and Solver::Options object.
struct PreprocessedProblem {
- PreprocessedProblem()
- : fixed_cost(0.0) {
- }
+ PreprocessedProblem() : fixed_cost(0.0) {}
std::string error;
Solver::Options options;
diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index 9805891..5129b9a 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc
@@ -48,8 +48,8 @@
#include "ceres/sized_cost_function.h"
#include "ceres/sparse_matrix.h"
#include "ceres/types.h"
-#include "gtest/gtest.h"
#include "gmock/gmock.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -80,7 +80,7 @@
};
// Trivial cost function that accepts two arguments.
-class BinaryCostFunction: public CostFunction {
+class BinaryCostFunction : public CostFunction {
public:
BinaryCostFunction(int num_residuals,
int32_t parameter_block1_size,
@@ -101,7 +101,7 @@
};
// Trivial cost function that accepts three arguments.
-class TernaryCostFunction: public CostFunction {
+class TernaryCostFunction : public CostFunction {
public:
TernaryCostFunction(int num_residuals,
int32_t parameter_block1_size,
@@ -123,7 +123,6 @@
}
};
-
TEST(Problem, MoveConstructor) {
Problem src;
double x;
@@ -172,23 +171,23 @@
Problem problem;
problem.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
- EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
- new UnaryCostFunction(
- 2, 4 /* 4 != 3 */), NULL, x),
- "different block sizes");
+ EXPECT_DEATH_IF_SUPPORTED(
+ problem.AddResidualBlock(
+ new UnaryCostFunction(2, 4 /* 4 != 3 */), NULL, x),
+ "different block sizes");
}
TEST(Problem, AddResidualWithDuplicateParametersDies) {
double x[3], z[5];
Problem problem;
- EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
- new BinaryCostFunction(2, 3, 3), NULL, x, x),
- "Duplicate parameter blocks");
- EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
- new TernaryCostFunction(1, 5, 3, 5),
- NULL, z, x, z),
- "Duplicate parameter blocks");
+ EXPECT_DEATH_IF_SUPPORTED(
+ problem.AddResidualBlock(new BinaryCostFunction(2, 3, 3), NULL, x, x),
+ "Duplicate parameter blocks");
+ EXPECT_DEATH_IF_SUPPORTED(
+ problem.AddResidualBlock(
+ new TernaryCostFunction(1, 5, 3, 5), NULL, z, x, z),
+ "Duplicate parameter blocks");
}
TEST(Problem, AddResidualWithIncorrectSizesOfParameterBlockDies) {
@@ -201,9 +200,9 @@
// The cost function expects the size of the second parameter, z, to be 4
// instead of 5 as declared above. This is fatal.
- EXPECT_DEATH_IF_SUPPORTED(problem.AddResidualBlock(
- new BinaryCostFunction(2, 3, 4), NULL, x, z),
- "different block sizes");
+ EXPECT_DEATH_IF_SUPPORTED(
+ problem.AddResidualBlock(new BinaryCostFunction(2, 3, 4), NULL, x, z),
+ "different block sizes");
}
TEST(Problem, AddResidualAddsDuplicatedParametersOnlyOnce) {
@@ -230,7 +229,7 @@
"different block sizes");
}
-static double *IntToPtr(int i) {
+static double* IntToPtr(int i) {
return reinterpret_cast<double*>(sizeof(double) * i); // NOLINT
}
@@ -246,16 +245,16 @@
// ones marked with o==o and aliasing ones marked with o--o.
Problem problem;
- problem.AddParameterBlock(IntToPtr(5), 5); // x
+ problem.AddParameterBlock(IntToPtr(5), 5); // x
problem.AddParameterBlock(IntToPtr(13), 3); // y
- EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 4), 2),
+ EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(4), 2),
"Aliasing detected");
- EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 4), 3),
+ EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(4), 3),
"Aliasing detected");
- EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 4), 9),
+ EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(4), 9),
"Aliasing detected");
- EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr( 8), 3),
+ EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(8), 3),
"Aliasing detected");
EXPECT_DEATH_IF_SUPPORTED(problem.AddParameterBlock(IntToPtr(12), 2),
"Aliasing detected");
@@ -263,7 +262,7 @@
"Aliasing detected");
// These ones should work.
- problem.AddParameterBlock(IntToPtr( 2), 3);
+ problem.AddParameterBlock(IntToPtr(2), 3);
problem.AddParameterBlock(IntToPtr(10), 3);
problem.AddParameterBlock(IntToPtr(16), 2);
@@ -306,17 +305,20 @@
EXPECT_EQ(7, problem.NumParameters());
problem.AddParameterBlock(z, 5);
- EXPECT_EQ(3, problem.NumParameterBlocks());
+ EXPECT_EQ(3, problem.NumParameterBlocks());
EXPECT_EQ(12, problem.NumParameters());
// Add a parameter that has a local parameterization.
- w[0] = 1.0; w[1] = 0.0; w[2] = 0.0; w[3] = 0.0;
+ w[0] = 1.0;
+ w[1] = 0.0;
+ w[2] = 0.0;
+ w[3] = 0.0;
problem.AddParameterBlock(w, 4, new QuaternionParameterization);
- EXPECT_EQ(4, problem.NumParameterBlocks());
+ EXPECT_EQ(4, problem.NumParameterBlocks());
EXPECT_EQ(16, problem.NumParameters());
problem.AddResidualBlock(new UnaryCostFunction(2, 3), NULL, x);
- problem.AddResidualBlock(new BinaryCostFunction(6, 5, 4) , NULL, z, y);
+ problem.AddResidualBlock(new BinaryCostFunction(6, 5, 4), NULL, z, y);
problem.AddResidualBlock(new BinaryCostFunction(3, 3, 5), NULL, x, z);
problem.AddResidualBlock(new BinaryCostFunction(7, 5, 3), NULL, z, x);
problem.AddResidualBlock(new TernaryCostFunction(1, 5, 3, 4), NULL, z, x, y);
@@ -328,12 +330,10 @@
class DestructorCountingCostFunction : public SizedCostFunction<3, 4, 5> {
public:
- explicit DestructorCountingCostFunction(int *num_destructions)
+ explicit DestructorCountingCostFunction(int* num_destructions)
: num_destructions_(num_destructions) {}
- virtual ~DestructorCountingCostFunction() {
- *num_destructions_ += 1;
- }
+ virtual ~DestructorCountingCostFunction() { *num_destructions_ += 1; }
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -463,8 +463,7 @@
// The next block of functions until the end are only for testing the
// residual block removals.
void ExpectParameterBlockContainsResidualBlock(
- double* values,
- ResidualBlock* residual_block) {
+ double* values, ResidualBlock* residual_block) {
ParameterBlock* parameter_block =
FindOrDie(problem->parameter_map(), values);
EXPECT_TRUE(ContainsKey(*(parameter_block->mutable_residual_blocks()),
@@ -478,12 +477,9 @@
}
// Degenerate case.
- void ExpectParameterBlockContains(double* values) {
- ExpectSize(values, 0);
- }
+ void ExpectParameterBlockContains(double* values) { ExpectSize(values, 0); }
- void ExpectParameterBlockContains(double* values,
- ResidualBlock* r1) {
+ void ExpectParameterBlockContains(double* values, ResidualBlock* r1) {
ExpectSize(values, 1);
ExpectParameterBlockContainsResidualBlock(values, r1);
}
@@ -598,8 +594,8 @@
Problem problem;
problem.AddParameterBlock(x, 3);
- EXPECT_DEATH_IF_SUPPORTED(
- problem.RemoveParameterBlock(y), "Parameter block not found:");
+ EXPECT_DEATH_IF_SUPPORTED(problem.RemoveParameterBlock(y),
+ "Parameter block not found:");
}
TEST(Problem, GetParameterization) {
@@ -610,7 +606,7 @@
problem.AddParameterBlock(x, 3);
problem.AddParameterBlock(y, 2);
- LocalParameterization* parameterization = new IdentityParameterization(3);
+ LocalParameterization* parameterization = new IdentityParameterization(3);
problem.SetParameterization(x, parameterization);
EXPECT_EQ(problem.GetParameterization(x), parameterization);
EXPECT_TRUE(problem.GetParameterization(y) == NULL);
@@ -626,8 +622,7 @@
vector<int> constant_parameters;
constant_parameters.push_back(0);
problem.SetParameterization(
- x,
- new SubsetParameterization(3, constant_parameters));
+ x, new SubsetParameterization(3, constant_parameters));
EXPECT_EQ(problem.ParameterBlockSize(x), 3);
EXPECT_EQ(problem.ParameterBlockLocalSize(x), 2);
EXPECT_EQ(problem.ParameterBlockLocalSize(y), 4);
@@ -714,6 +709,8 @@
EXPECT_EQ(z, GetParameterBlock(1)->user_state());
EXPECT_EQ(w, GetParameterBlock(2)->user_state());
+ // clang-format off
+
// Add all combinations of cost functions.
CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
CostFunction* cost_yz = new BinaryCostFunction (1, 4, 5);
@@ -764,6 +761,8 @@
problem->RemoveParameterBlock(y);
EXPECT_EQ(0, problem->NumParameterBlocks());
EXPECT_EQ(0, NumResidualBlocks());
+
+ // clang-format on
}
TEST_P(DynamicProblem, RemoveResidualBlock) {
@@ -771,6 +770,8 @@
problem->AddParameterBlock(z, 5);
problem->AddParameterBlock(w, 3);
+ // clang-format off
+
// Add all combinations of cost functions.
CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
CostFunction* cost_yz = new BinaryCostFunction (1, 4, 5);
@@ -885,6 +886,8 @@
ExpectParameterBlockContains(z);
ExpectParameterBlockContains(w);
}
+
+ // clang-format on
}
TEST_P(DynamicProblem, RemoveInvalidResidualBlockDies) {
@@ -892,6 +895,8 @@
problem->AddParameterBlock(z, 5);
problem->AddParameterBlock(w, 3);
+ // clang-format off
+
// Add all combinations of cost functions.
CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
CostFunction* cost_yz = new BinaryCostFunction (1, 4, 5);
@@ -909,6 +914,8 @@
ResidualBlock* r_z = problem->AddResidualBlock(cost_z, NULL, z);
ResidualBlock* r_w = problem->AddResidualBlock(cost_w, NULL, w);
+ // clang-format on
+
// Remove r_yzw.
problem->RemoveResidualBlock(r_yzw);
ASSERT_EQ(3, problem->NumParameterBlocks());
@@ -938,7 +945,7 @@
}
// Check that a null-terminated array, a, has the same elements as b.
-template<typename T>
+template <typename T>
void ExpectVectorContainsUnordered(const T* a, const vector<T>& b) {
// Compute the size of a.
int size = 0;
@@ -963,8 +970,8 @@
}
static void ExpectProblemHasResidualBlocks(
- const ProblemImpl &problem,
- const ResidualBlockId *expected_residual_blocks) {
+ const ProblemImpl& problem,
+ const ResidualBlockId* expected_residual_blocks) {
vector<ResidualBlockId> residual_blocks;
problem.GetResidualBlocks(&residual_blocks);
ExpectVectorContainsUnordered(expected_residual_blocks, residual_blocks);
@@ -975,6 +982,8 @@
problem->AddParameterBlock(z, 5);
problem->AddParameterBlock(w, 3);
+ // clang-format off
+
// Add all combinations of cost functions.
CostFunction* cost_yzw = new TernaryCostFunction(1, 4, 5, 3);
CostFunction* cost_yz = new BinaryCostFunction (1, 4, 5);
@@ -1070,6 +1079,8 @@
get_parameter_blocks_cases[i].expected_parameter_blocks,
parameter_blocks);
}
+
+ // clang-format on
}
INSTANTIATE_TEST_SUITE_P(OptionsInstantiation,
@@ -1108,8 +1119,8 @@
for (int j = 0; j < kNumParameterBlocks; ++j) {
if (jacobians[j] != NULL) {
MatrixRef(jacobians[j], kNumResiduals, kNumResiduals) =
- (-2.0 * (j + 1.0) *
- ConstVectorRef(parameters[j], kNumResiduals)).asDiagonal();
+ (-2.0 * (j + 1.0) * ConstVectorRef(parameters[j], kNumResiduals))
+ .asDiagonal();
}
}
@@ -1142,31 +1153,20 @@
parameter_blocks_.push_back(parameters_ + 2);
parameter_blocks_.push_back(parameters_ + 4);
-
CostFunction* cost_function = new QuadraticCostFunction<2, 2>;
// f(x, y)
- residual_blocks_.push_back(
- problem_.AddResidualBlock(cost_function,
- NULL,
- parameters_,
- parameters_ + 2));
+ residual_blocks_.push_back(problem_.AddResidualBlock(
+ cost_function, NULL, parameters_, parameters_ + 2));
// g(y, z)
- residual_blocks_.push_back(
- problem_.AddResidualBlock(cost_function,
- NULL, parameters_ + 2,
- parameters_ + 4));
+ residual_blocks_.push_back(problem_.AddResidualBlock(
+ cost_function, NULL, parameters_ + 2, parameters_ + 4));
// h(z, x)
- residual_blocks_.push_back(
- problem_.AddResidualBlock(cost_function,
- NULL,
- parameters_ + 4,
- parameters_));
+ residual_blocks_.push_back(problem_.AddResidualBlock(
+ cost_function, NULL, parameters_ + 4, parameters_));
}
- void TearDown() {
- EXPECT_TRUE(problem_.program().IsValid());
- }
+ void TearDown() { EXPECT_TRUE(problem_.program().IsValid()); }
void EvaluateAndCompare(const Problem::EvaluateOptions& options,
const int expected_num_rows,
@@ -1225,8 +1225,8 @@
expected.num_cols,
expected.cost,
(i & 1) ? expected.residuals : NULL,
- (i & 2) ? expected.gradient : NULL,
- (i & 4) ? expected.jacobian : NULL);
+ (i & 2) ? expected.gradient : NULL,
+ (i & 4) ? expected.jacobian : NULL);
}
}
@@ -1236,8 +1236,8 @@
vector<ResidualBlockId> residual_blocks_;
};
-
TEST_F(ProblemEvaluateTest, MultipleParameterAndResidualBlocks) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
6, 6,
@@ -1263,11 +1263,13 @@
0.0, -8.0, 0.0, 0.0, 0.0, -12.0
}
};
+ // clang-format on
CheckAllEvaluationCombinations(Problem::EvaluateOptions(), expected);
}
TEST_F(ProblemEvaluateTest, ParameterAndResidualBlocksPassedInOptions) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
6, 6,
@@ -1293,6 +1295,7 @@
0.0, -8.0, 0.0, 0.0, 0.0, -12.0
}
};
+ // clang-format on
Problem::EvaluateOptions evaluate_options;
evaluate_options.parameter_blocks = parameter_blocks_;
@@ -1301,6 +1304,7 @@
}
TEST_F(ProblemEvaluateTest, ReorderedResidualBlocks) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
6, 6,
@@ -1326,6 +1330,7 @@
0.0, 0.0, 0.0, -8.0, 0.0, -24.0
}
};
+ // clang-format on
Problem::EvaluateOptions evaluate_options;
evaluate_options.parameter_blocks = parameter_blocks_;
@@ -1338,7 +1343,9 @@
CheckAllEvaluationCombinations(evaluate_options, expected);
}
-TEST_F(ProblemEvaluateTest, ReorderedResidualBlocksAndReorderedParameterBlocks) {
+TEST_F(ProblemEvaluateTest,
+ ReorderedResidualBlocksAndReorderedParameterBlocks) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
6, 6,
@@ -1364,6 +1371,7 @@
0.0, -24.0, 0.0, -8.0, 0.0, 0.0
}
};
+ // clang-format on
Problem::EvaluateOptions evaluate_options;
// z, y, x
@@ -1380,6 +1388,7 @@
}
TEST_F(ProblemEvaluateTest, ConstantParameterBlock) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
6, 6,
@@ -1407,12 +1416,14 @@
0.0, -8.0, 0.0, 0.0, 0.0, -12.0
}
};
+ // clang-format on
problem_.SetParameterBlockConstant(parameters_ + 2);
CheckAllEvaluationCombinations(Problem::EvaluateOptions(), expected);
}
TEST_F(ProblemEvaluateTest, ExcludedAResidualBlock) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
4, 6,
@@ -1435,6 +1446,7 @@
0.0, -8.0, 0.0, 0.0, 0.0, -12.0
}
};
+ // clang-format on
Problem::EvaluateOptions evaluate_options;
evaluate_options.residual_blocks.push_back(residual_blocks_[0]);
@@ -1444,6 +1456,7 @@
}
TEST_F(ProblemEvaluateTest, ExcludedParameterBlock) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
6, 4,
@@ -1470,6 +1483,7 @@
0.0, -8.0, 0.0, -12.0
}
};
+ // clang-format on
Problem::EvaluateOptions evaluate_options;
// x, z
@@ -1480,6 +1494,7 @@
}
TEST_F(ProblemEvaluateTest, ExcludedParameterBlockAndExcludedResidualBlock) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
4, 4,
@@ -1503,6 +1518,7 @@
0.0, 0.0, 0.0, -24.0,
}
};
+ // clang-format on
Problem::EvaluateOptions evaluate_options;
// x, z
@@ -1515,6 +1531,7 @@
}
TEST_F(ProblemEvaluateTest, LocalParameterization) {
+ // clang-format off
ExpectedEvaluation expected = {
// Rows/columns
6, 5,
@@ -1540,12 +1557,12 @@
0.0, -8.0, 0.0, 0.0, -12.0
}
};
+ // clang-format on
vector<int> constant_parameters;
constant_parameters.push_back(0);
- problem_.SetParameterization(parameters_ + 2,
- new SubsetParameterization(2,
- constant_parameters));
+ problem_.SetParameterization(
+ parameters_ + 2, new SubsetParameterization(2, constant_parameters));
CheckAllEvaluationCombinations(Problem::EvaluateOptions(), expected);
}
diff --git a/internal/ceres/program.h b/internal/ceres/program.h
index 7971299..c4935e3 100644
--- a/internal/ceres/program.h
+++ b/internal/ceres/program.h
@@ -36,8 +36,8 @@
#include <string>
#include <vector>
-#include "ceres/internal/port.h"
#include "ceres/evaluation_callback.h"
+#include "ceres/internal/port.h"
namespace ceres {
namespace internal {
diff --git a/internal/ceres/program_evaluator.h b/internal/ceres/program_evaluator.h
index 97ee590..36c9c64 100644
--- a/internal/ceres/program_evaluator.h
+++ b/internal/ceres/program_evaluator.h
@@ -80,7 +80,9 @@
#define CERES_INTERNAL_PROGRAM_EVALUATOR_H_
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
#include <atomic>
#include <map>
diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index be6ad87..1d9f49c 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -99,7 +99,8 @@
vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
string message;
- std::unique_ptr<Program> reduced_program(problem.program().CreateReducedProgram(
+ std::unique_ptr<Program> reduced_program(
+ problem.program().CreateReducedProgram(
&removed_parameter_blocks, &fixed_cost, &message));
EXPECT_EQ(reduced_program->NumParameterBlocks(), 3);
@@ -130,7 +131,6 @@
EXPECT_EQ(fixed_cost, 9.0);
}
-
TEST(Program, RemoveFixedBlocksNoResidualBlocks) {
ProblemImpl problem;
double x;
@@ -215,17 +215,13 @@
problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
problem.SetParameterBlockConstant(&x);
- ResidualBlock *expected_removed_block =
+ ResidualBlock* expected_removed_block =
problem.program().residual_blocks()[0];
std::unique_ptr<double[]> scratch(
new double[expected_removed_block->NumScratchDoublesForEvaluate()]);
double expected_fixed_cost;
- expected_removed_block->Evaluate(true,
- &expected_fixed_cost,
- nullptr,
- nullptr,
- scratch.get());
-
+ expected_removed_block->Evaluate(
+ true, &expected_fixed_cost, nullptr, nullptr, scratch.get());
vector<double*> removed_parameter_blocks;
double fixed_cost = 0.0;
@@ -323,9 +319,7 @@
EXPECT_EQ((expected_dense_jacobian - actual_dense_jacobian).norm(), 0.0);
}
-INSTANTIATE_TEST_SUITE_P(AllColumns,
- BlockJacobianTest,
- ::testing::Range(0, 7));
+INSTANTIATE_TEST_SUITE_P(AllColumns, BlockJacobianTest, ::testing::Range(0, 7));
template <int kNumResiduals, int kNumParameterBlocks>
class NumParameterBlocksCostFunction : public CostFunction {
@@ -337,8 +331,7 @@
}
}
- virtual ~NumParameterBlocksCostFunction() {
- }
+ virtual ~NumParameterBlocksCostFunction() {}
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -403,8 +396,8 @@
problem.AddResidualBlock(new MockCostFunctionBase<1, 2>(), nullptr, x);
string error;
EXPECT_FALSE(problem.program().ParameterBlocksAreFinite(&error));
- EXPECT_NE(error.find("has at least one invalid value"),
- string::npos) << error;
+ EXPECT_NE(error.find("has at least one invalid value"), string::npos)
+ << error;
}
TEST(Program, InfeasibleParameterBlock) {
diff --git a/internal/ceres/random.h b/internal/ceres/random.h
index 87d9d77..6b280f9 100644
--- a/internal/ceres/random.h
+++ b/internal/ceres/random.h
@@ -34,13 +34,12 @@
#include <cmath>
#include <cstdlib>
+
#include "ceres/internal/port.h"
namespace ceres {
-inline void SetRandomState(int state) {
- srand(state);
-}
+inline void SetRandomState(int state) { srand(state); }
inline int Uniform(int n) {
if (n) {
@@ -63,7 +62,7 @@
x1 = 2.0 * RandDouble() - 1.0;
x2 = 2.0 * RandDouble() - 1.0;
w = x1 * x1 + x2 * x2;
- } while ( w >= 1.0 || w == 0.0 );
+ } while (w >= 1.0 || w == 0.0);
w = sqrt((-2.0 * log(w)) / w);
return x1 * w;
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index aa6032a..5d80236 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -35,6 +35,7 @@
#include <numeric>
#include <vector>
+#include "Eigen/SparseCore"
#include "ceres/cxsparse.h"
#include "ceres/internal/port.h"
#include "ceres/ordered_groups.h"
@@ -47,7 +48,6 @@
#include "ceres/suitesparse.h"
#include "ceres/triplet_sparse_matrix.h"
#include "ceres/types.h"
-#include "Eigen/SparseCore"
#ifdef CERES_USE_EIGEN_SPARSE
#include "Eigen/OrderingMethods"
@@ -78,8 +78,8 @@
CHECK_NE(parameter_block->index(), -1)
<< "Did you forget to call Program::SetParameterOffsetsAndIndex()? "
<< "This is a Ceres bug; please contact the developers!";
- min_parameter_block_position = std::min(parameter_block->index(),
- min_parameter_block_position);
+ min_parameter_block_position =
+ std::min(parameter_block->index(), min_parameter_block_position);
}
}
return min_parameter_block_position;
@@ -117,9 +117,8 @@
<< "Please report this error to the developers.";
#else
SuiteSparse ss;
- cholmod_sparse* block_jacobian_transpose =
- ss.CreateSparseMatrix(
- const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
+ cholmod_sparse* block_jacobian_transpose = ss.CreateSparseMatrix(
+ const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
// No CAMD or the user did not supply a useful ordering, then just
// use regular AMD.
@@ -129,18 +128,16 @@
} else {
vector<int> constraints;
for (int i = 0; i < parameter_blocks.size(); ++i) {
- constraints.push_back(
- parameter_block_ordering.GroupId(
- parameter_blocks[i]->mutable_user_state()));
+ constraints.push_back(parameter_block_ordering.GroupId(
+ parameter_blocks[i]->mutable_user_state()));
}
// Renumber the entries of constraints to be contiguous integers
// as CAMD requires that the group ids be in the range [0,
// parameter_blocks.size() - 1].
MapValuesToContiguousRange(constraints.size(), &constraints[0]);
- ss.ConstrainedApproximateMinimumDegreeOrdering(block_jacobian_transpose,
- &constraints[0],
- ordering);
+ ss.ConstrainedApproximateMinimumDegreeOrdering(
+ block_jacobian_transpose, &constraints[0], ordering);
}
VLOG(2) << "Block ordering stats: "
@@ -153,20 +150,18 @@
}
void OrderingForSparseNormalCholeskyUsingCXSparse(
- const TripletSparseMatrix& tsm_block_jacobian_transpose,
- int* ordering) {
+ const TripletSparseMatrix& tsm_block_jacobian_transpose, int* ordering) {
#ifdef CERES_NO_CXSPARSE
LOG(FATAL) << "Congratulations, you found a Ceres bug! "
<< "Please report this error to the developers.";
-#else // CERES_NO_CXSPARSE
+#else
// CXSparse works with J'J instead of J'. So compute the block
// sparsity for J'J and compute an approximate minimum degree
// ordering.
CXSparse cxsparse;
cs_di* block_jacobian_transpose;
- block_jacobian_transpose =
- cxsparse.CreateSparseMatrix(
- const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
+ block_jacobian_transpose = cxsparse.CreateSparseMatrix(
+ const_cast<TripletSparseMatrix*>(&tsm_block_jacobian_transpose));
cs_di* block_jacobian = cxsparse.TransposeMatrix(block_jacobian_transpose);
cs_di* block_hessian =
cxsparse.MatrixMatrixMultiply(block_jacobian_transpose, block_jacobian);
@@ -178,16 +173,13 @@
#endif // CERES_NO_CXSPARSE
}
-
void OrderingForSparseNormalCholeskyUsingEigenSparse(
- const TripletSparseMatrix& tsm_block_jacobian_transpose,
- int* ordering) {
+ const TripletSparseMatrix& tsm_block_jacobian_transpose, int* ordering) {
#ifndef CERES_USE_EIGEN_SPARSE
- LOG(FATAL) <<
- "SPARSE_NORMAL_CHOLESKY cannot be used with EIGEN_SPARSE "
- "because Ceres was not built with support for "
- "Eigen's SimplicialLDLT decomposition. "
- "This requires enabling building with -DEIGENSPARSE=ON.";
+ LOG(FATAL) << "SPARSE_NORMAL_CHOLESKY cannot be used with EIGEN_SPARSE "
+ "because Ceres was not built with support for "
+ "Eigen's SimplicialLDLT decomposition. "
+ "This requires enabling building with -DEIGENSPARSE=ON.";
#else
// This conversion from a TripletSparseMatrix to a Eigen::Triplet
@@ -218,13 +210,14 @@
const ParameterBlockOrdering& ordering,
Program* program,
string* error) {
- const int num_parameter_blocks = program->NumParameterBlocks();
+ const int num_parameter_blocks = program->NumParameterBlocks();
if (ordering.NumElements() != num_parameter_blocks) {
- *error = StringPrintf("User specified ordering does not have the same "
- "number of parameters as the problem. The problem"
- "has %d blocks while the ordering has %d blocks.",
- num_parameter_blocks,
- ordering.NumElements());
+ *error = StringPrintf(
+ "User specified ordering does not have the same "
+ "number of parameters as the problem. The problem"
+ "has %d blocks while the ordering has %d blocks.",
+ num_parameter_blocks,
+ ordering.NumElements());
return false;
}
@@ -238,10 +231,11 @@
for (double* parameter_block_ptr : group) {
auto it = parameter_map.find(parameter_block_ptr);
if (it == parameter_map.end()) {
- *error = StringPrintf("User specified ordering contains a pointer "
- "to a double that is not a parameter block in "
- "the problem. The invalid double is in group: %d",
- p.first);
+ *error = StringPrintf(
+ "User specified ordering contains a pointer "
+ "to a double that is not a parameter block in "
+ "the problem. The invalid double is in group: %d",
+ p.first);
return false;
}
parameter_blocks->push_back(it->second);
@@ -265,8 +259,8 @@
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 = MinParameterBlock(residual_block,
- size_of_first_elimination_group);
+ int position =
+ MinParameterBlock(residual_block, size_of_first_elimination_group);
min_position_per_residual[i] = position;
DCHECK_LE(position, size_of_first_elimination_group);
residual_blocks_per_e_block[position]++;
@@ -284,8 +278,8 @@
<< "to the developers.";
CHECK(find(residual_blocks_per_e_block.begin(),
- residual_blocks_per_e_block.end() - 1, 0) !=
- residual_blocks_per_e_block.end())
+ residual_blocks_per_e_block.end() - 1,
+ 0) != residual_blocks_per_e_block.end())
<< "Congratulations, you found a Ceres bug! Please report this error "
<< "to the developers.";
@@ -334,8 +328,7 @@
// Pre-order the columns corresponding to the schur complement if
// possible.
static void MaybeReorderSchurComplementColumnsUsingSuiteSparse(
- const ParameterBlockOrdering& parameter_block_ordering,
- Program* program) {
+ const ParameterBlockOrdering& parameter_block_ordering, Program* program) {
#ifndef CERES_NO_SUITESPARSE
SuiteSparse ss;
if (!SuiteSparse::IsConstrainedApproximateMinimumDegreeOrderingAvailable()) {
@@ -347,9 +340,8 @@
*(program->mutable_parameter_blocks());
for (int i = 0; i < parameter_blocks.size(); ++i) {
- constraints.push_back(
- parameter_block_ordering.GroupId(
- parameter_blocks[i]->mutable_user_state()));
+ constraints.push_back(parameter_block_ordering.GroupId(
+ parameter_blocks[i]->mutable_user_state()));
}
// Renumber the entries of constraints to be contiguous integers as
@@ -365,9 +357,8 @@
ss.CreateSparseMatrix(tsm_block_jacobian_transpose.get());
vector<int> ordering(parameter_blocks.size(), 0);
- ss.ConstrainedApproximateMinimumDegreeOrdering(block_jacobian_transpose,
- &constraints[0],
- &ordering[0]);
+ ss.ConstrainedApproximateMinimumDegreeOrdering(
+ block_jacobian_transpose, &constraints[0], &ordering[0]);
ss.Free(block_jacobian_transpose);
const vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
@@ -396,10 +387,7 @@
// Vertically partition the jacobian in parameter blocks of type E
// and F.
const SparseMatrix E =
- block_jacobian.block(0,
- 0,
- num_rows,
- size_of_first_elimination_group);
+ block_jacobian.block(0, 0, num_rows, size_of_first_elimination_group);
const SparseMatrix F =
block_jacobian.block(0,
size_of_first_elimination_group,
@@ -482,22 +470,17 @@
// Verify that the first elimination group is an independent set.
const set<double*>& first_elimination_group =
- parameter_block_ordering
- ->group_to_elements()
- .begin()
- ->second;
+ parameter_block_ordering->group_to_elements().begin()->second;
if (!program->IsParameterBlockSetIndependent(first_elimination_group)) {
- *error =
- StringPrintf("The first elimination group in the parameter block "
- "ordering of size %zd is not an independent set",
- first_elimination_group.size());
+ *error = StringPrintf(
+ "The first elimination group in the parameter block "
+ "ordering of size %zd is not an independent set",
+ first_elimination_group.size());
return false;
}
- if (!ApplyOrdering(parameter_map,
- *parameter_block_ordering,
- program,
- error)) {
+ if (!ApplyOrdering(
+ parameter_map, *parameter_block_ordering, program, error)) {
return false;
}
}
@@ -510,13 +493,10 @@
if (linear_solver_type == SPARSE_SCHUR) {
if (sparse_linear_algebra_library_type == SUITE_SPARSE) {
MaybeReorderSchurComplementColumnsUsingSuiteSparse(
- *parameter_block_ordering,
- program);
+ *parameter_block_ordering, program);
} else if (sparse_linear_algebra_library_type == EIGEN_SPARSE) {
MaybeReorderSchurComplementColumnsUsingEigen(
- size_of_first_elimination_group,
- parameter_map,
- program);
+ size_of_first_elimination_group, parameter_map, program);
}
}
@@ -556,9 +536,8 @@
parameter_block_ordering,
&ordering[0]);
} else if (sparse_linear_algebra_library_type == CX_SPARSE) {
- OrderingForSparseNormalCholeskyUsingCXSparse(
- *tsm_block_jacobian_transpose,
- &ordering[0]);
+ OrderingForSparseNormalCholeskyUsingCXSparse(*tsm_block_jacobian_transpose,
+ &ordering[0]);
} else if (sparse_linear_algebra_library_type == ACCELERATE_SPARSE) {
// Accelerate does not provide a function to perform reordering without
// performing a full symbolic factorisation. As such, we have nothing
@@ -570,8 +549,7 @@
} else if (sparse_linear_algebra_library_type == EIGEN_SPARSE) {
OrderingForSparseNormalCholeskyUsingEigenSparse(
- *tsm_block_jacobian_transpose,
- &ordering[0]);
+ *tsm_block_jacobian_transpose, &ordering[0]);
}
// Apply ordering.
@@ -588,11 +566,11 @@
const std::unordered_set<ResidualBlockId>& bottom_residual_blocks,
Program* program) {
auto residual_blocks = program->mutable_residual_blocks();
- auto it = std::partition(
- residual_blocks->begin(), residual_blocks->end(),
- [&bottom_residual_blocks](ResidualBlock* r) {
- return bottom_residual_blocks.count(r) == 0;
- });
+ auto it = std::partition(residual_blocks->begin(),
+ residual_blocks->end(),
+ [&bottom_residual_blocks](ResidualBlock* r) {
+ return bottom_residual_blocks.count(r) == 0;
+ });
return it - residual_blocks->begin();
}
diff --git a/internal/ceres/reorder_program.h b/internal/ceres/reorder_program.h
index 88cbee3..e32079c 100644
--- a/internal/ceres/reorder_program.h
+++ b/internal/ceres/reorder_program.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_REORDER_PROGRAM_H_
#include <string>
+
#include "ceres/internal/port.h"
#include "ceres/parameter_block_ordering.h"
#include "ceres/problem_impl.h"
diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index 2cfc123..83c867a 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -31,6 +31,7 @@
#include "ceres/reorder_program.h"
#include <random>
+
#include "ceres/parameter_block.h"
#include "ceres/problem_impl.h"
#include "ceres/program.h"
@@ -107,9 +108,7 @@
std::string message;
EXPECT_TRUE(LexicographicallyOrderResidualBlocks(
- 2,
- problem.mutable_program(),
- &message));
+ 2, problem.mutable_program(), &message));
EXPECT_EQ(residual_blocks.size(), expected_residual_blocks.size());
for (int i = 0; i < expected_residual_blocks.size(); ++i) {
EXPECT_EQ(residual_blocks[i], expected_residual_blocks[i]);
@@ -132,10 +131,8 @@
Program program(problem.program());
std::string message;
- EXPECT_FALSE(ApplyOrdering(problem.parameter_map(),
- linear_solver_ordering,
- &program,
- &message));
+ EXPECT_FALSE(ApplyOrdering(
+ problem.parameter_map(), linear_solver_ordering, &program, &message));
}
TEST(_, ApplyOrderingNormal) {
@@ -156,10 +153,8 @@
Program* program = problem.mutable_program();
std::string message;
- EXPECT_TRUE(ApplyOrdering(problem.parameter_map(),
- linear_solver_ordering,
- program,
- &message));
+ EXPECT_TRUE(ApplyOrdering(
+ problem.parameter_map(), linear_solver_ordering, program, &message));
const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
EXPECT_EQ(parameter_blocks.size(), 3);
@@ -169,8 +164,8 @@
}
#ifndef CERES_NO_SUITESPARSE
-class ReorderProgramFoSparseCholeskyUsingSuiteSparseTest :
- public ::testing::Test {
+class ReorderProgramFoSparseCholeskyUsingSuiteSparseTest
+ : public ::testing::Test {
protected:
void SetUp() {
problem_.AddResidualBlock(new UnaryCostFunction(), nullptr, &x_);
@@ -188,12 +183,11 @@
program->parameter_blocks();
std::string error;
- EXPECT_TRUE(ReorderProgramForSparseCholesky(
- ceres::SUITE_SPARSE,
- linear_solver_ordering,
- 0, /* use all rows */
- program,
- &error));
+ EXPECT_TRUE(ReorderProgramForSparseCholesky(ceres::SUITE_SPARSE,
+ linear_solver_ordering,
+ 0, /* use all rows */
+ program,
+ &error));
const vector<ParameterBlock*>& ordered_parameter_blocks =
program->parameter_blocks();
EXPECT_EQ(ordered_parameter_blocks.size(),
@@ -219,8 +213,7 @@
ComputeAndValidateOrdering(linear_solver_ordering);
}
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest,
- ContiguousGroups) {
+TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest, ContiguousGroups) {
ParameterBlockOrdering linear_solver_ordering;
linear_solver_ordering.AddElementToGroup(&x_, 0);
linear_solver_ordering.AddElementToGroup(&y_, 1);
@@ -229,8 +222,7 @@
ComputeAndValidateOrdering(linear_solver_ordering);
}
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest,
- GroupsWithGaps) {
+TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest, GroupsWithGaps) {
ParameterBlockOrdering linear_solver_ordering;
linear_solver_ordering.AddElementToGroup(&x_, 0);
linear_solver_ordering.AddElementToGroup(&y_, 2);
diff --git a/internal/ceres/residual_block.cc b/internal/ceres/residual_block.cc
index 0bf30bc..067c9ef 100644
--- a/internal/ceres/residual_block.cc
+++ b/internal/ceres/residual_block.cc
@@ -34,6 +34,7 @@
#include <algorithm>
#include <cstddef>
#include <vector>
+
#include "ceres/corrector.h"
#include "ceres/cost_function.h"
#include "ceres/internal/eigen.h"
@@ -50,8 +51,10 @@
namespace internal {
ResidualBlock::ResidualBlock(
- const CostFunction* cost_function, const LossFunction* loss_function,
- const std::vector<ParameterBlock*>& parameter_blocks, int index)
+ const CostFunction* cost_function,
+ const LossFunction* loss_function,
+ const std::vector<ParameterBlock*>& parameter_blocks,
+ int index)
: cost_function_(cost_function),
loss_function_(loss_function),
parameter_blocks_(
@@ -111,22 +114,18 @@
return false;
}
- if (!IsEvaluationValid(*this,
- parameters.data(),
- cost,
- residuals,
- eval_jacobians)) {
+ if (!IsEvaluationValid(
+ *this, parameters.data(), cost, residuals, eval_jacobians)) {
+ // clang-format off
std::string message =
"\n\n"
"Error in evaluating the ResidualBlock.\n\n"
"There are two possible reasons. Either the CostFunction did not evaluate and fill all \n" // NOLINT
"residual and jacobians that were requested or there was a non-finite value (nan/infinite)\n" // NOLINT
"generated during the or jacobian computation. \n\n" +
- EvaluationToString(*this,
- parameters.data(),
- cost,
- residuals,
- eval_jacobians);
+ EvaluationToString(
+ *this, parameters.data(), cost, residuals, eval_jacobians);
+ // clang-format on
LOG(WARNING) << message;
return false;
}
@@ -149,7 +148,11 @@
parameter_block->LocalParameterizationJacobian(),
parameter_block->Size(),
parameter_block->LocalSize(),
- jacobians[i], 0, 0, num_residuals, parameter_block->LocalSize());
+ jacobians[i],
+ 0,
+ 0,
+ num_residuals,
+ parameter_block->LocalSize());
}
}
}
diff --git a/internal/ceres/residual_block.h b/internal/ceres/residual_block.h
index a2e4425..3d75339 100644
--- a/internal/ceres/residual_block.h
+++ b/internal/ceres/residual_block.h
@@ -105,7 +105,6 @@
double** jacobians,
double* scratch) const;
-
const CostFunction* cost_function() const { return cost_function_; }
const LossFunction* loss_function() const { return loss_function_; }
diff --git a/internal/ceres/residual_block_test.cc b/internal/ceres/residual_block_test.cc
index 482e7ce..3c05f48 100644
--- a/internal/ceres/residual_block_test.cc
+++ b/internal/ceres/residual_block_test.cc
@@ -31,11 +31,12 @@
#include "ceres/residual_block.h"
#include <cstdint>
-#include "gtest/gtest.h"
-#include "ceres/parameter_block.h"
-#include "ceres/sized_cost_function.h"
+
#include "ceres/internal/eigen.h"
#include "ceres/local_parameterization.h"
+#include "ceres/parameter_block.h"
+#include "ceres/sized_cost_function.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -43,7 +44,7 @@
using std::vector;
// Trivial cost function that accepts three arguments.
-class TernaryCostFunction: public CostFunction {
+class TernaryCostFunction : public CostFunction {
public:
TernaryCostFunction(int num_residuals,
int32_t parameter_block1_size,
@@ -64,9 +65,8 @@
if (jacobians) {
for (int k = 0; k < 3; ++k) {
if (jacobians[k] != NULL) {
- MatrixRef jacobian(jacobians[k],
- num_residuals(),
- parameter_block_sizes()[k]);
+ MatrixRef jacobian(
+ jacobians[k], num_residuals(), parameter_block_sizes()[k]);
jacobian.setConstant(k);
}
}
@@ -109,12 +109,12 @@
// Verify cost-only evaluation.
double cost;
residual_block.Evaluate(true, &cost, NULL, NULL, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
// Verify cost and residual evaluation.
double residuals[3];
residual_block.Evaluate(true, &cost, residuals, NULL, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
EXPECT_EQ(0.0, residuals[0]);
EXPECT_EQ(1.0, residuals[1]);
EXPECT_EQ(2.0, residuals[2]);
@@ -131,14 +131,11 @@
jacobian_ry.setConstant(-1.0);
jacobian_rz.setConstant(-1.0);
- double *jacobian_ptrs[3] = {
- jacobian_rx.data(),
- jacobian_ry.data(),
- jacobian_rz.data()
- };
+ double* jacobian_ptrs[3] = {
+ jacobian_rx.data(), jacobian_ry.data(), jacobian_rz.data()};
residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
EXPECT_EQ(0.0, residuals[0]);
EXPECT_EQ(1.0, residuals[1]);
EXPECT_EQ(2.0, residuals[2]);
@@ -157,18 +154,20 @@
jacobian_ptrs[1] = NULL; // Don't compute the jacobian for y.
residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
EXPECT_EQ(0.0, residuals[0]);
EXPECT_EQ(1.0, residuals[1]);
EXPECT_EQ(2.0, residuals[2]);
+ // clang-format off
EXPECT_TRUE((jacobian_rx.array() == 0.0).all()) << "\n" << jacobian_rx;
EXPECT_TRUE((jacobian_ry.array() == -1.0).all()) << "\n" << jacobian_ry;
EXPECT_TRUE((jacobian_rz.array() == 2.0).all()) << "\n" << jacobian_rz;
+ // clang-format on
}
// Trivial cost function that accepts three arguments.
-class LocallyParameterizedCostFunction: public SizedCostFunction<3, 2, 3, 4> {
+class LocallyParameterizedCostFunction : public SizedCostFunction<3, 2, 3, 4> {
public:
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -189,9 +188,8 @@
// 0 1 2 3 4 ...
//
if (jacobians[k] != NULL) {
- MatrixRef jacobian(jacobians[k],
- num_residuals(),
- parameter_block_sizes()[k]);
+ MatrixRef jacobian(
+ jacobians[k], num_residuals(), parameter_block_sizes()[k]);
for (int j = 0; j < k + 2; ++j) {
jacobian.col(j).setConstant(j);
}
@@ -243,17 +241,17 @@
EXPECT_EQ(parameters[0], residual_block.parameter_blocks()[0]);
EXPECT_EQ(parameters[1], residual_block.parameter_blocks()[1]);
EXPECT_EQ(parameters[2], residual_block.parameter_blocks()[2]);
- EXPECT_EQ(3*(2 + 4) + 3, residual_block.NumScratchDoublesForEvaluate());
+ EXPECT_EQ(3 * (2 + 4) + 3, residual_block.NumScratchDoublesForEvaluate());
// Verify cost-only evaluation.
double cost;
residual_block.Evaluate(true, &cost, NULL, NULL, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
// Verify cost and residual evaluation.
double residuals[3];
residual_block.Evaluate(true, &cost, residuals, NULL, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
EXPECT_EQ(0.0, residuals[0]);
EXPECT_EQ(1.0, residuals[1]);
EXPECT_EQ(2.0, residuals[2]);
@@ -270,18 +268,17 @@
jacobian_ry.setConstant(-1.0);
jacobian_rz.setConstant(-1.0);
- double *jacobian_ptrs[3] = {
- jacobian_rx.data(),
- jacobian_ry.data(),
- jacobian_rz.data()
- };
+ double* jacobian_ptrs[3] = {
+ jacobian_rx.data(), jacobian_ry.data(), jacobian_rz.data()};
residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
EXPECT_EQ(0.0, residuals[0]);
EXPECT_EQ(1.0, residuals[1]);
EXPECT_EQ(2.0, residuals[2]);
+ // clang-format off
+
Matrix expected_jacobian_rx(3, 1);
expected_jacobian_rx << 1.0, 1.0, 1.0;
@@ -305,6 +302,8 @@
<< "\nExpected:\n " << expected_jacobian_rz
<< "\nActual:\n" << jacobian_rz;
+ // clang-format on
+
// Verify cost, residual, and partial jacobian evaluation.
cost = 0.0;
VectorRef(residuals, 3).setConstant(0.0);
@@ -315,7 +314,7 @@
jacobian_ptrs[1] = NULL; // Don't compute the jacobian for y.
residual_block.Evaluate(true, &cost, residuals, jacobian_ptrs, scratch);
- EXPECT_EQ(0.5 * (0*0 + 1*1 + 2*2), cost);
+ EXPECT_EQ(0.5 * (0 * 0 + 1 * 1 + 2 * 2), cost);
EXPECT_EQ(0.0, residuals[0]);
EXPECT_EQ(1.0, residuals[1]);
EXPECT_EQ(2.0, residuals[2]);
diff --git a/internal/ceres/residual_block_utils.cc b/internal/ceres/residual_block_utils.cc
index 35e928b..d5b3fa1 100644
--- a/internal/ceres/residual_block_utils.cc
+++ b/internal/ceres/residual_block_utils.cc
@@ -33,6 +33,7 @@
#include <cmath>
#include <cstddef>
#include <limits>
+
#include "ceres/array_utils.h"
#include "ceres/internal/eigen.h"
#include "ceres/internal/port.h"
@@ -75,6 +76,7 @@
const int num_residuals = block.NumResiduals();
string result = "";
+ // clang-format off
StringAppendF(&result,
"Residual Block size: %d parameter blocks x %d residuals\n\n",
num_parameter_blocks, num_residuals);
@@ -85,6 +87,7 @@
"of the Jacobian/residual array was requested but was not written to by user code, it is \n" // NOLINT
"indicated by 'Uninitialized'. This is an error. Residuals or Jacobian values evaluating \n" // NOLINT
"to Inf or NaN is also an error. \n\n"; // NOLINT
+ // clang-format on
string space = "Residuals: ";
result += space;
@@ -102,8 +105,8 @@
for (int k = 0; k < num_residuals; ++k) {
AppendArrayToString(1,
(jacobians != NULL && jacobians[i] != NULL)
- ? jacobians[i] + k * parameter_block_size + j
- : NULL,
+ ? jacobians[i] + k * parameter_block_size + j
+ : NULL,
&result);
}
StringAppendF(&result, "\n");
diff --git a/internal/ceres/residual_block_utils.h b/internal/ceres/residual_block_utils.h
index 627337f..41ae81a 100644
--- a/internal/ceres/residual_block_utils.h
+++ b/internal/ceres/residual_block_utils.h
@@ -44,6 +44,7 @@
#define CERES_INTERNAL_RESIDUAL_BLOCK_UTILS_H_
#include <string>
+
#include "ceres/internal/port.h"
namespace ceres {
diff --git a/internal/ceres/residual_block_utils_test.cc b/internal/ceres/residual_block_utils_test.cc
index 6ad3729..331f5ab 100644
--- a/internal/ceres/residual_block_utils_test.cc
+++ b/internal/ceres/residual_block_utils_test.cc
@@ -28,15 +28,17 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/residual_block_utils.h"
+
#include <cmath>
#include <limits>
#include <memory>
-#include "gtest/gtest.h"
+
+#include "ceres/cost_function.h"
#include "ceres/parameter_block.h"
#include "ceres/residual_block.h"
-#include "ceres/residual_block_utils.h"
-#include "ceres/cost_function.h"
#include "ceres/sized_cost_function.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -49,10 +51,7 @@
std::vector<ParameterBlock*> parameter_blocks;
parameter_blocks.push_back(¶meter_block);
- ResidualBlock residual_block(&cost_function,
- NULL,
- parameter_blocks,
- -1);
+ ResidualBlock residual_block(&cost_function, NULL, parameter_blocks, -1);
std::unique_ptr<double[]> scratch(
new double[residual_block.NumScratchDoublesForEvaluate()]);
@@ -60,18 +59,16 @@
double cost;
double residuals;
double jacobian;
- double* jacobians[] = { &jacobian };
+ double* jacobians[] = {&jacobian};
- EXPECT_EQ(residual_block.Evaluate(true,
- &cost,
- &residuals,
- jacobians,
- scratch.get()), is_good);
+ EXPECT_EQ(residual_block.Evaluate(
+ true, &cost, &residuals, jacobians, scratch.get()),
+ is_good);
}
// A CostFunction that behaves normaly, i.e., it computes numerically
// valid residuals and jacobians.
-class GoodCostFunction: public SizedCostFunction<1, 1> {
+class GoodCostFunction : public SizedCostFunction<1, 1> {
public:
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -86,7 +83,7 @@
// The following four CostFunctions simulate the different ways in
// which user code can cause ResidualBlock::Evaluate to fail.
-class NoResidualUpdateCostFunction: public SizedCostFunction<1, 1> {
+class NoResidualUpdateCostFunction : public SizedCostFunction<1, 1> {
public:
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -100,7 +97,7 @@
}
};
-class NoJacobianUpdateCostFunction: public SizedCostFunction<1, 1> {
+class NoJacobianUpdateCostFunction : public SizedCostFunction<1, 1> {
public:
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -114,7 +111,7 @@
}
};
-class BadResidualCostFunction: public SizedCostFunction<1, 1> {
+class BadResidualCostFunction : public SizedCostFunction<1, 1> {
public:
bool Evaluate(double const* const* parameters,
double* residuals,
@@ -127,7 +124,7 @@
}
};
-class BadJacobianCostFunction: public SizedCostFunction<1, 1> {
+class BadJacobianCostFunction : public SizedCostFunction<1, 1> {
public:
bool Evaluate(double const* const* parameters,
double* residuals,
diff --git a/internal/ceres/rotation_test.cc b/internal/ceres/rotation_test.cc
index 6a06632..fc39b31 100644
--- a/internal/ceres/rotation_test.cc
+++ b/internal/ceres/rotation_test.cc
@@ -28,14 +28,16 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/rotation.h"
+
#include <cmath>
#include <limits>
#include <string>
+
#include "ceres/internal/eigen.h"
-#include "ceres/is_close.h"
#include "ceres/internal/port.h"
+#include "ceres/is_close.h"
#include "ceres/jet.h"
-#include "ceres/rotation.h"
#include "ceres/stringprintf.h"
#include "ceres/test_util.h"
#include "glog/logging.h"
@@ -45,8 +47,8 @@
namespace ceres {
namespace internal {
-using std::min;
using std::max;
+using std::min;
using std::numeric_limits;
using std::string;
using std::swap;
@@ -74,8 +76,8 @@
return false;
}
- double norm2 = arg[0] * arg[0] + arg[1] * arg[1] +
- arg[2] * arg[2] + arg[3] * arg[3];
+ double norm2 =
+ arg[0] * arg[0] + arg[1] * arg[1] + arg[2] * arg[2] + arg[3] * arg[3];
if (fabs(norm2 - 1.0) > kTolerance) {
*result_listener << "squared norm is " << norm2;
return false;
@@ -120,6 +122,7 @@
return true;
}
+ // clang-format off
*result_listener << "expected : "
<< expected[0] << " "
<< expected[1] << " "
@@ -130,6 +133,7 @@
<< arg[1] << " "
<< arg[2] << " "
<< arg[3];
+ // clang-format on
return false;
}
@@ -164,6 +168,7 @@
return true;
}
+ // clang-format off
*result_listener << " arg:"
<< " " << arg[0]
<< " " << arg[1]
@@ -172,6 +177,7 @@
<< " " << expected[0]
<< " " << expected[1]
<< " " << expected[2];
+ // clang-format on
return false;
}
@@ -225,9 +231,9 @@
// Transforms a zero axis/angle to a quaternion.
TEST(Rotation, ZeroAngleAxisToQuaternion) {
- double axis_angle[3] = { 0, 0, 0 };
+ double axis_angle[3] = {0, 0, 0};
double quaternion[4];
- double expected[4] = { 1, 0, 0, 0 };
+ double expected[4] = {1, 0, 0, 0};
AngleAxisToQuaternion(axis_angle, quaternion);
EXPECT_THAT(quaternion, IsNormalizedQuaternion());
EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -237,9 +243,9 @@
TEST(Rotation, SmallAngleAxisToQuaternion) {
// Small, finite value to test.
double theta = 1.0e-2;
- double axis_angle[3] = { theta, 0, 0 };
+ double axis_angle[3] = {theta, 0, 0};
double quaternion[4];
- double expected[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+ double expected[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
AngleAxisToQuaternion(axis_angle, quaternion);
EXPECT_THAT(quaternion, IsNormalizedQuaternion());
EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -249,9 +255,9 @@
TEST(Rotation, TinyAngleAxisToQuaternion) {
// Very small value that could potentially cause underflow.
double theta = pow(numeric_limits<double>::min(), 0.75);
- double axis_angle[3] = { theta, 0, 0 };
+ double axis_angle[3] = {theta, 0, 0};
double quaternion[4];
- double expected[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+ double expected[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
AngleAxisToQuaternion(axis_angle, quaternion);
EXPECT_THAT(quaternion, IsNormalizedQuaternion());
EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -259,9 +265,9 @@
// Transforms a rotation by pi/2 around X to a quaternion.
TEST(Rotation, XRotationToQuaternion) {
- double axis_angle[3] = { kPi / 2, 0, 0 };
+ double axis_angle[3] = {kPi / 2, 0, 0};
double quaternion[4];
- double expected[4] = { kHalfSqrt2, kHalfSqrt2, 0, 0 };
+ double expected[4] = {kHalfSqrt2, kHalfSqrt2, 0, 0};
AngleAxisToQuaternion(axis_angle, quaternion);
EXPECT_THAT(quaternion, IsNormalizedQuaternion());
EXPECT_THAT(quaternion, IsNearQuaternion(expected));
@@ -269,18 +275,18 @@
// Transforms a unit quaternion to an axis angle.
TEST(Rotation, UnitQuaternionToAngleAxis) {
- double quaternion[4] = { 1, 0, 0, 0 };
+ double quaternion[4] = {1, 0, 0, 0};
double axis_angle[3];
- double expected[3] = { 0, 0, 0 };
+ double expected[3] = {0, 0, 0};
QuaternionToAngleAxis(quaternion, axis_angle);
EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
}
// Transforms a quaternion that rotates by pi about the Y axis to an axis angle.
TEST(Rotation, YRotationQuaternionToAngleAxis) {
- double quaternion[4] = { 0, 0, 1, 0 };
+ double quaternion[4] = {0, 0, 1, 0};
double axis_angle[3];
- double expected[3] = { 0, kPi, 0 };
+ double expected[3] = {0, kPi, 0};
QuaternionToAngleAxis(quaternion, axis_angle);
EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
}
@@ -288,9 +294,9 @@
// Transforms a quaternion that rotates by pi/3 about the Z axis to an axis
// angle.
TEST(Rotation, ZRotationQuaternionToAngleAxis) {
- double quaternion[4] = { sqrt(3) / 2, 0, 0, 0.5 };
+ double quaternion[4] = {sqrt(3) / 2, 0, 0, 0.5};
double axis_angle[3];
- double expected[3] = { 0, 0, kPi / 3 };
+ double expected[3] = {0, 0, kPi / 3};
QuaternionToAngleAxis(quaternion, axis_angle);
EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
}
@@ -299,9 +305,9 @@
TEST(Rotation, SmallQuaternionToAngleAxis) {
// Small, finite value to test.
double theta = 1.0e-2;
- double quaternion[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+ double quaternion[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
double axis_angle[3];
- double expected[3] = { theta, 0, 0 };
+ double expected[3] = {theta, 0, 0};
QuaternionToAngleAxis(quaternion, axis_angle);
EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
}
@@ -310,9 +316,9 @@
TEST(Rotation, TinyQuaternionToAngleAxis) {
// Very small value that could potentially cause underflow.
double theta = pow(numeric_limits<double>::min(), 0.75);
- double quaternion[4] = { cos(theta/2), sin(theta/2.0), 0, 0 };
+ double quaternion[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
double axis_angle[3];
- double expected[3] = { theta, 0, 0 };
+ double expected[3] = {theta, 0, 0};
QuaternionToAngleAxis(quaternion, axis_angle);
EXPECT_THAT(axis_angle, IsNearAngleAxis(expected));
}
@@ -328,9 +334,9 @@
quaternion[2] = 0.0;
quaternion[3] = 0.0;
QuaternionToAngleAxis(quaternion, angle_axis);
- const double angle = sqrt(angle_axis[0] * angle_axis[0] +
- angle_axis[1] * angle_axis[1] +
- angle_axis[2] * angle_axis[2]);
+ const double angle =
+ sqrt(angle_axis[0] * angle_axis[0] + angle_axis[1] * angle_axis[1] +
+ angle_axis[2] * angle_axis[2]);
EXPECT_LE(angle, kPi);
}
@@ -398,18 +404,18 @@
// Transforms a zero axis/angle to a rotation matrix.
TEST(Rotation, ZeroAngleAxisToRotationMatrix) {
- double axis_angle[3] = { 0, 0, 0 };
+ double axis_angle[3] = {0, 0, 0};
double matrix[9];
- double expected[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+ double expected[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
AngleAxisToRotationMatrix(axis_angle, matrix);
EXPECT_THAT(matrix, IsOrthonormal());
EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
}
TEST(Rotation, NearZeroAngleAxisToRotationMatrix) {
- double axis_angle[3] = { 1e-24, 2e-24, 3e-24 };
+ double axis_angle[3] = {1e-24, 2e-24, 3e-24};
double matrix[9];
- double expected[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+ double expected[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
AngleAxisToRotationMatrix(axis_angle, matrix);
EXPECT_THAT(matrix, IsOrthonormal());
EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -417,10 +423,10 @@
// Transforms a rotation by pi/2 around X to a rotation matrix and back.
TEST(Rotation, XRotationToRotationMatrix) {
- double axis_angle[3] = { kPi / 2, 0, 0 };
+ double axis_angle[3] = {kPi / 2, 0, 0};
double matrix[9];
// The rotation matrices are stored column-major.
- double expected[9] = { 1, 0, 0, 0, 0, 1, 0, -1, 0 };
+ double expected[9] = {1, 0, 0, 0, 0, 1, 0, -1, 0};
AngleAxisToRotationMatrix(axis_angle, matrix);
EXPECT_THAT(matrix, IsOrthonormal());
EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -432,9 +438,9 @@
// Transforms an axis angle that rotates by pi about the Y axis to a
// rotation matrix and back.
TEST(Rotation, YRotationToRotationMatrix) {
- double axis_angle[3] = { 0, kPi, 0 };
+ double axis_angle[3] = {0, kPi, 0};
double matrix[9];
- double expected[9] = { -1, 0, 0, 0, 1, 0, 0, 0, -1 };
+ double expected[9] = {-1, 0, 0, 0, 1, 0, 0, 0, -1};
AngleAxisToRotationMatrix(axis_angle, matrix);
EXPECT_THAT(matrix, IsOrthonormal());
EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -475,29 +481,31 @@
TEST(Rotation, AtPiAngleAxisRoundTrip) {
// A rotation of kPi about the X axis;
+ // clang-format off
static constexpr double kMatrix[3][3] = {
{1.0, 0.0, 0.0},
{0.0, -1.0, 0.0},
{0.0, 0.0, -1.0}
};
+ // clang-format on
double in_matrix[9];
// Fill it from kMatrix in col-major order.
for (int j = 0, k = 0; j < 3; ++j) {
- for (int i = 0; i < 3; ++i, ++k) {
- in_matrix[k] = kMatrix[i][j];
- }
+ for (int i = 0; i < 3; ++i, ++k) {
+ in_matrix[k] = kMatrix[i][j];
+ }
}
- const double expected_axis_angle[3] = { kPi, 0, 0 };
+ const double expected_axis_angle[3] = {kPi, 0, 0};
double out_matrix[9];
double axis_angle[3];
RotationMatrixToAngleAxis(in_matrix, axis_angle);
AngleAxisToRotationMatrix(axis_angle, out_matrix);
- LOG(INFO) << "AngleAxis = " << axis_angle[0] << " " << axis_angle[1]
- << " " << axis_angle[2];
+ LOG(INFO) << "AngleAxis = " << axis_angle[0] << " " << axis_angle[1] << " "
+ << axis_angle[2];
LOG(INFO) << "Expected AngleAxis = " << kPi << " 0 0";
double out_rowmajor[3][3];
for (int j = 0, k = 0; j < 3; ++j) {
@@ -526,13 +534,15 @@
// Transforms an axis angle that rotates by pi/3 about the Z axis to a
// rotation matrix.
TEST(Rotation, ZRotationToRotationMatrix) {
- double axis_angle[3] = { 0, 0, kPi / 3 };
+ double axis_angle[3] = {0, 0, kPi / 3};
double matrix[9];
// This is laid-out row-major on the screen but is actually stored
// column-major.
+ // clang-format off
double expected[9] = { 0.5, sqrt(3) / 2, 0, // Column 1
-sqrt(3) / 2, 0.5, 0, // Column 2
0, 0, 1 }; // Column 3
+ // clang-format on
AngleAxisToRotationMatrix(axis_angle, matrix);
EXPECT_THAT(matrix, IsOrthonormal());
EXPECT_THAT(matrix, IsNear3x3Matrix(expected));
@@ -602,13 +612,12 @@
RotationMatrixToAngleAxis(matrix, round_trip);
for (int i = 0; i < 3; ++i) {
- EXPECT_NEAR(round_trip[i], axis_angle[i],
- numeric_limits<double>::epsilon());
+ EXPECT_NEAR(
+ round_trip[i], axis_angle[i], numeric_limits<double>::epsilon());
}
}
}
-
// Transposes a 3x3 matrix.
static void Transpose3x3(double m[9]) {
swap(m[1], m[3]);
@@ -647,8 +656,7 @@
for (double x = -1.0; x <= 1.0; x += 1.0) {
for (double y = -1.0; y <= 1.0; y += 1.0) {
for (double z = -1.0; z <= 1.0; z += 1.0) {
- if ((x != 0) + (y != 0) + (z != 0) > 1)
- continue;
+ if ((x != 0) + (y != 0) + (z != 0) > 1) continue;
double axis_angle[3] = {x, y, z};
double euler_angles[3] = {x, y, z};
CompareEulerToAngleAxis(axis_angle, euler_angles);
@@ -710,7 +718,7 @@
} // namespace
template <int N>
-bool IsClose(const Jet<double, N> &x, const Jet<double, N> &y) {
+bool IsClose(const Jet<double, N>& x, const Jet<double, N>& y) {
if (!IsClose(x.a, y.a)) {
return false;
}
@@ -723,7 +731,7 @@
}
template <int M, int N>
-void ExpectJetArraysClose(const Jet<double, N> *x, const Jet<double, N> *y) {
+void ExpectJetArraysClose(const Jet<double, N>* x, const Jet<double, N>* y) {
for (int i = 0; i < M; i++) {
if (!IsClose(x[i], y[i])) {
LOG(ERROR) << "Jet " << i << "/" << M << " not equal";
@@ -742,11 +750,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(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 const int kTinyZeroLimit =
+ static_cast<int>(1 + log(numeric_limits<double>::min()) / log(10.0));
// Test that exact conversion works for small angles when jets are used.
TEST(Rotation, SmallAngleAxisToQuaternionForJets) {
@@ -754,27 +762,26 @@
// to be well within the range represented by doubles.
for (int i = -2; i >= kSmallTinyCutoff; i--) {
double theta = pow(10.0, i);
- J3 axis_angle[3] = { J3(theta, 0), J3(0, 1), J3(0, 2) };
+ J3 axis_angle[3] = {J3(theta, 0), J3(0, 1), J3(0, 2)};
J3 quaternion[4];
J3 expected[4] = {
- MakeJ3(cos(theta/2), -sin(theta/2)/2, 0, 0),
- MakeJ3(sin(theta/2), cos(theta/2)/2, 0, 0),
- MakeJ3(0, 0, sin(theta/2)/theta, 0),
- MakeJ3(0, 0, 0, sin(theta/2)/theta),
+ MakeJ3(cos(theta / 2), -sin(theta / 2) / 2, 0, 0),
+ MakeJ3(sin(theta / 2), cos(theta / 2) / 2, 0, 0),
+ MakeJ3(0, 0, sin(theta / 2) / theta, 0),
+ MakeJ3(0, 0, 0, sin(theta / 2) / theta),
};
AngleAxisToQuaternion(axis_angle, quaternion);
ExpectJetArraysClose<4, 3>(quaternion, expected);
}
}
-
// Test that conversion works for very small angles when jets are used.
TEST(Rotation, TinyAngleAxisToQuaternionForJets) {
// Examine tiny x rotations that extend all the way to where
// underflow occurs.
for (int i = kSmallTinyCutoff; i >= kTinyZeroLimit; i--) {
double theta = pow(10.0, i);
- J3 axis_angle[3] = { J3(theta, 0), J3(0, 1), J3(0, 2) };
+ J3 axis_angle[3] = {J3(theta, 0), J3(0, 1), J3(0, 2)};
J3 quaternion[4];
// To avoid loss of precision in the test itself,
// a finite expansion is used here, which will
@@ -792,7 +799,7 @@
// Test that derivatives are correct for zero rotation.
TEST(Rotation, ZeroAngleAxisToQuaternionForJets) {
- J3 axis_angle[3] = { J3(0, 0), J3(0, 1), J3(0, 2) };
+ J3 axis_angle[3] = {J3(0, 0), J3(0, 1), J3(0, 2)};
J3 quaternion[4];
J3 expected[4] = {
MakeJ3(1.0, 0, 0, 0),
@@ -812,13 +819,15 @@
double theta = pow(10.0, i);
double s = sin(theta);
double c = cos(theta);
- J4 quaternion[4] = { J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3) };
+ J4 quaternion[4] = {J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3)};
J4 axis_angle[3];
+ // clang-format off
J4 expected[3] = {
MakeJ4(2*theta, -2*s, 2*c, 0, 0),
MakeJ4(0, 0, 0, 2*theta/s, 0),
MakeJ4(0, 0, 0, 0, 2*theta/s),
};
+ // clang-format on
QuaternionToAngleAxis(quaternion, axis_angle);
ExpectJetArraysClose<3, 4>(axis_angle, expected);
}
@@ -832,16 +841,18 @@
double theta = pow(10.0, i);
double s = sin(theta);
double c = cos(theta);
- J4 quaternion[4] = { J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3) };
+ J4 quaternion[4] = {J4(c, 0), J4(s, 1), J4(0, 2), J4(0, 3)};
J4 axis_angle[3];
// To avoid loss of precision in the test itself,
// a finite expansion is used here, which will
// be exact up to machine precision for the test values used.
+ // clang-format off
J4 expected[3] = {
MakeJ4(2*theta, -2*s, 2.0, 0, 0),
MakeJ4(0, 0, 0, 2.0, 0),
MakeJ4(0, 0, 0, 0, 2.0),
};
+ // clang-format on
QuaternionToAngleAxis(quaternion, axis_angle);
ExpectJetArraysClose<3, 4>(axis_angle, expected);
}
@@ -849,7 +860,7 @@
// Test that conversion works for no rotation.
TEST(Rotation, ZeroQuaternionToAngleAxisForJets) {
- J4 quaternion[4] = { J4(1, 0), J4(0, 1), J4(0, 2), J4(0, 3) };
+ J4 quaternion[4] = {J4(1, 0), J4(0, 1), J4(0, 2), J4(0, 3)};
J4 axis_angle[3];
J4 expected[3] = {
MakeJ4(0, 0, 2.0, 0, 0),
@@ -863,20 +874,22 @@
TEST(Quaternion, RotatePointGivesSameAnswerAsRotationByMatrixCanned) {
// Canned data generated in octave.
double const q[4] = {
- +0.1956830471754074,
- -0.0150618562474847,
- +0.7634572982788086,
- -0.3019454777240753,
+ +0.1956830471754074,
+ -0.0150618562474847,
+ +0.7634572982788086,
+ -0.3019454777240753,
};
- double const Q[3][3] = { // Scaled rotation matrix.
- { -0.6355194033477252, 0.0951730541682254, 0.3078870197911186 },
- { -0.1411693904792992, 0.5297609702153905, -0.4551502574482019 },
- { -0.2896955822708862, -0.4669396571547050, -0.4536309793389248 },
+ double const Q[3][3] = {
+ // Scaled rotation matrix.
+ {-0.6355194033477252, +0.0951730541682254, +0.3078870197911186},
+ {-0.1411693904792992, +0.5297609702153905, -0.4551502574482019},
+ {-0.2896955822708862, -0.4669396571547050, -0.4536309793389248},
};
- double const R[3][3] = { // With unit rows and columns.
- { -0.8918859164053080, 0.1335655625725649, 0.4320876677394745 },
- { -0.1981166751680096, 0.7434648665444399, -0.6387564287225856 },
- { -0.4065578619806013, -0.6553016349046693, -0.6366242786393164 },
+ double const R[3][3] = {
+ // With unit rows and columns.
+ {-0.8918859164053080, +0.1335655625725649, +0.4320876677394745},
+ {-0.1981166751680096, +0.7434648665444399, -0.6387564287225856},
+ {-0.4065578619806013, -0.6553016349046693, -0.6366242786393164},
};
// Compute R from q and compare to known answer.
@@ -889,19 +902,18 @@
ExpectArraysClose(9, R[0], Rq[0], kTolerance);
}
-
TEST(Quaternion, RotatePointGivesSameAnswerAsRotationByMatrix) {
// Rotation defined by a unit quaternion.
double const q[4] = {
- 0.2318160216097109,
- -0.0178430356832060,
- 0.9044300776717159,
- -0.3576998641394597,
+ +0.2318160216097109,
+ -0.0178430356832060,
+ +0.9044300776717159,
+ -0.3576998641394597,
};
double const p[3] = {
- +0.11,
- -13.15,
- 1.17,
+ +0.11,
+ -13.15,
+ 1.17,
};
double R[3 * 3];
@@ -911,11 +923,10 @@
UnitQuaternionRotatePoint(q, p, result1);
double result2[3];
- VectorRef(result2, 3) = ConstMatrixRef(R, 3, 3)* ConstVectorRef(p, 3);
+ VectorRef(result2, 3) = ConstMatrixRef(R, 3, 3) * ConstVectorRef(p, 3);
ExpectArraysClose(3, result1, result2, kTolerance);
}
-
// Verify that (a * b) * c == a * (b * c).
TEST(Quaternion, MultiplicationIsAssociative) {
double a[4];
@@ -943,7 +954,6 @@
ASSERT_NEAR(ab_c[3], a_bc[3], kTolerance);
}
-
TEST(AngleAxis, RotatePointGivesSameAnswerAsRotationMatrix) {
double angle_axis[3];
double R[9];
@@ -973,6 +983,7 @@
AngleAxisRotatePoint(angle_axis, p, angle_axis_rotated_p);
for (int k = 0; k < 3; ++k) {
+ // clang-format off
EXPECT_NEAR(rotation_matrix_rotated_p[k],
angle_axis_rotated_p[k],
kTolerance) << "p: " << p[0]
@@ -981,6 +992,7 @@
<< " angle_axis: " << angle_axis[0]
<< " " << angle_axis[1]
<< " " << angle_axis[2];
+ // clang-format on
}
}
}
@@ -1001,7 +1013,7 @@
norm2 = angle_axis[k] * angle_axis[k];
}
- double theta = (2.0 * i * 0.0001 - 1.0) * 1e-16;
+ double theta = (2.0 * i * 0.0001 - 1.0) * 1e-16;
const double inv_norm = theta / sqrt(norm2);
for (int k = 0; k < 3; ++k) {
angle_axis[k] *= inv_norm;
@@ -1014,6 +1026,7 @@
AngleAxisRotatePoint(angle_axis, p, angle_axis_rotated_p);
for (int k = 0; k < 3; ++k) {
+ // clang-format off
EXPECT_NEAR(rotation_matrix_rotated_p[k],
angle_axis_rotated_p[k],
kTolerance) << "p: " << p[0]
@@ -1022,14 +1035,15 @@
<< " angle_axis: " << angle_axis[0]
<< " " << angle_axis[1]
<< " " << angle_axis[2];
+ // clang-format on
}
}
}
TEST(MatrixAdapter, RowMajor3x3ReturnTypeAndAccessIsCorrect) {
- double array[9] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
- const float const_array[9] =
- { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f };
+ double array[9] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
+ const float const_array[9] = {
+ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
MatrixAdapter<double, 3, 1> A = RowMajorAdapter3x3(array);
MatrixAdapter<const float, 3, 1> B = RowMajorAdapter3x3(const_array);
@@ -1037,16 +1051,16 @@
for (int j = 0; j < 3; ++j) {
// The values are integers from 1 to 9, so equality tests are appropriate
// even for float and double values.
- EXPECT_EQ(A(i, j), array[3*i+j]);
- EXPECT_EQ(B(i, j), const_array[3*i+j]);
+ EXPECT_EQ(A(i, j), array[3 * i + j]);
+ EXPECT_EQ(B(i, j), const_array[3 * i + j]);
}
}
}
TEST(MatrixAdapter, ColumnMajor3x3ReturnTypeAndAccessIsCorrect) {
- double array[9] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
- const float const_array[9] =
- { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f };
+ double array[9] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
+ const float const_array[9] = {
+ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
MatrixAdapter<double, 1, 3> A = ColumnMajorAdapter3x3(array);
MatrixAdapter<const float, 1, 3> B = ColumnMajorAdapter3x3(const_array);
@@ -1054,29 +1068,33 @@
for (int j = 0; j < 3; ++j) {
// The values are integers from 1 to 9, so equality tests are
// appropriate even for float and double values.
- EXPECT_EQ(A(i, j), array[3*j+i]);
- EXPECT_EQ(B(i, j), const_array[3*j+i]);
+ EXPECT_EQ(A(i, j), array[3 * j + i]);
+ EXPECT_EQ(B(i, j), const_array[3 * j + i]);
}
}
}
TEST(MatrixAdapter, RowMajor2x4IsCorrect) {
- const int expected[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+ const int expected[8] = {1, 2, 3, 4, 5, 6, 7, 8};
int array[8];
MatrixAdapter<int, 4, 1> M(array);
+ // clang-format off
M(0, 0) = 1; M(0, 1) = 2; M(0, 2) = 3; M(0, 3) = 4;
M(1, 0) = 5; M(1, 1) = 6; M(1, 2) = 7; M(1, 3) = 8;
+ // clang-format on
for (int k = 0; k < 8; ++k) {
EXPECT_EQ(array[k], expected[k]);
}
}
TEST(MatrixAdapter, ColumnMajor2x4IsCorrect) {
- const int expected[8] = { 1, 5, 2, 6, 3, 7, 4, 8 };
+ const int expected[8] = {1, 5, 2, 6, 3, 7, 4, 8};
int array[8];
MatrixAdapter<int, 1, 2> M(array);
+ // clang-format off
M(0, 0) = 1; M(0, 1) = 2; M(0, 2) = 3; M(0, 3) = 4;
M(1, 0) = 5; M(1, 1) = 6; M(1, 2) = 7; M(1, 3) = 8;
+ // clang-format on
for (int k = 0; k < 8; ++k) {
EXPECT_EQ(array[k], expected[k]);
}
@@ -1084,11 +1102,13 @@
TEST(RotationMatrixToAngleAxis, NearPiExampleOneFromTobiasStrauss) {
// Example from Tobias Strauss
+ // clang-format off
const double rotation_matrix[] = {
-0.999807135425239, -0.0128154391194470, -0.0148814136745799,
-0.0128154391194470, -0.148441438622958, 0.988838158557669,
-0.0148814136745799, 0.988838158557669, 0.148248574048196
};
+ // clang-format on
double angle_axis[3];
RotationMatrixToAngleAxis(RowMajorAdapter3x3(rotation_matrix), angle_axis);
diff --git a/internal/ceres/schur_complement_solver.cc b/internal/ceres/schur_complement_solver.cc
index 0083300..65e7854 100644
--- a/internal/ceres/schur_complement_solver.cc
+++ b/internal/ceres/schur_complement_solver.cc
@@ -139,10 +139,8 @@
//
// TODO(sameeragarwal): A more scalable template specialization
// mechanism that does not cause binary bloat.
- if (options_.row_block_size == 2 &&
- options_.e_block_size == 3 &&
- options_.f_block_size == 6 &&
- num_f_blocks == 1) {
+ if (options_.row_block_size == 2 && options_.e_block_size == 3 &&
+ options_.f_block_size == 6 && num_f_blocks == 1) {
eliminator_.reset(new SchurEliminatorForOneFBlock<2, 3, 6>);
} else {
eliminator_.reset(SchurEliminatorBase::Create(options_));
diff --git a/internal/ceres/schur_complement_solver.h b/internal/ceres/schur_complement_solver.h
index 87f0478..464af09 100644
--- a/internal/ceres/schur_complement_solver.h
+++ b/internal/ceres/schur_complement_solver.h
@@ -46,8 +46,8 @@
#include "ceres/types.h"
#ifdef CERES_USE_EIGEN_SPARSE
-#include "Eigen/SparseCholesky"
#include "Eigen/OrderingMethods"
+#include "Eigen/SparseCholesky"
#endif
namespace ceres {
@@ -179,8 +179,7 @@
const LinearSolver::PerSolveOptions& per_solve_options,
double* solution) final;
LinearSolver::Summary SolveReducedLinearSystemUsingConjugateGradients(
- const LinearSolver::PerSolveOptions& per_solve_options,
- double* solution);
+ const LinearSolver::PerSolveOptions& per_solve_options, double* solution);
// Size of the blocks in the Schur complement.
std::vector<int> blocks_;
diff --git a/internal/ceres/schur_complement_solver_test.cc b/internal/ceres/schur_complement_solver_test.cc
index 23d3674..550733e 100644
--- a/internal/ceres/schur_complement_solver_test.cc
+++ b/internal/ceres/schur_complement_solver_test.cc
@@ -74,9 +74,8 @@
std::unique_ptr<LinearSolver> qr(LinearSolver::Create(options));
- TripletSparseMatrix triplet_A(A->num_rows(),
- A->num_cols(),
- A->num_nonzeros());
+ TripletSparseMatrix triplet_A(
+ A->num_rows(), A->num_cols(), A->num_nonzeros());
A->ToTripletSparseMatrix(&triplet_A);
// Gold standard solutions using dense QR factorization.
@@ -99,8 +98,8 @@
SetUpFromProblemId(problem_id);
LinearSolver::Options options;
options.elimination_groups.push_back(num_eliminate_blocks);
- options.elimination_groups.push_back(
- A->block_structure()->cols.size() - num_eliminate_blocks);
+ options.elimination_groups.push_back(A->block_structure()->cols.size() -
+ num_eliminate_blocks);
options.type = linear_solver_type;
options.dense_linear_algebra_library_type =
dense_linear_algebra_library_type;
@@ -127,7 +126,6 @@
EXPECT_EQ(summary.termination_type, LINEAR_SOLVER_SUCCESS);
if (regularization) {
-
ASSERT_NEAR((sol_d - x).norm() / num_cols, 0, 1e-10)
<< "Regularized Expected solution: " << sol_d.transpose()
<< " Actual solution: " << x.transpose();
@@ -207,42 +205,40 @@
#endif // CERES_NO_SUITESPARSE
#ifndef CERES_NO_CXSPARSE
-TEST_F(SchurComplementSolverTest,
- SparseSchurWithCXSparseSmallProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithCXSparseSmallProblem) {
ComputeAndCompareSolutions(2, false, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
ComputeAndCompareSolutions(2, true, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
}
-TEST_F(SchurComplementSolverTest,
- SparseSchurWithCXSparseLargeProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithCXSparseLargeProblem) {
ComputeAndCompareSolutions(3, false, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
ComputeAndCompareSolutions(3, true, SPARSE_SCHUR, EIGEN, CX_SPARSE, true);
}
#endif // CERES_NO_CXSPARSE
#ifndef CERES_NO_ACCELERATE_SPARSE
-TEST_F(SchurComplementSolverTest,
- SparseSchurWithAccelerateSparseSmallProblem) {
- ComputeAndCompareSolutions(2, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
- ComputeAndCompareSolutions(2, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+TEST_F(SchurComplementSolverTest, SparseSchurWithAccelerateSparseSmallProblem) {
+ ComputeAndCompareSolutions(
+ 2, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+ ComputeAndCompareSolutions(
+ 2, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
}
-TEST_F(SchurComplementSolverTest,
- SparseSchurWithAccelerateSparseLargeProblem) {
- ComputeAndCompareSolutions(3, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
- ComputeAndCompareSolutions(3, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+TEST_F(SchurComplementSolverTest, SparseSchurWithAccelerateSparseLargeProblem) {
+ ComputeAndCompareSolutions(
+ 3, false, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
+ ComputeAndCompareSolutions(
+ 3, true, SPARSE_SCHUR, EIGEN, ACCELERATE_SPARSE, true);
}
#endif // CERES_NO_ACCELERATE_SPARSE
#ifdef CERES_USE_EIGEN_SPARSE
-TEST_F(SchurComplementSolverTest,
- SparseSchurWithEigenSparseSmallProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithEigenSparseSmallProblem) {
ComputeAndCompareSolutions(2, false, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
ComputeAndCompareSolutions(2, true, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
}
-TEST_F(SchurComplementSolverTest,
- SparseSchurWithEigenSparseLargeProblem) {
+TEST_F(SchurComplementSolverTest, SparseSchurWithEigenSparseLargeProblem) {
ComputeAndCompareSolutions(3, false, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
ComputeAndCompareSolutions(3, true, SPARSE_SCHUR, EIGEN, EIGEN_SPARSE, true);
}
diff --git a/internal/ceres/schur_eliminator_impl.h b/internal/ceres/schur_eliminator_impl.h
index bd0881e..1f0b4fa 100644
--- a/internal/ceres/schur_eliminator_impl.h
+++ b/internal/ceres/schur_eliminator_impl.h
@@ -46,7 +46,9 @@
#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 10
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
#include <algorithm>
#include <map>
@@ -152,7 +154,7 @@
++chunk.size;
}
- CHECK_GT(chunk.size, 0); // This check will need to be resolved.
+ CHECK_GT(chunk.size, 0); // This check will need to be resolved.
r += chunk.size;
}
const Chunk& chunk = chunks_.back();
@@ -174,13 +176,12 @@
}
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-Eliminate(const BlockSparseMatrixData& A,
- const double* b,
- const double* D,
- BlockRandomAccessMatrix* lhs,
- double* rhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::Eliminate(
+ const BlockSparseMatrixData& A,
+ const double* b,
+ const double* D,
+ BlockRandomAccessMatrix* lhs,
+ double* rhs) {
if (lhs->num_rows() > 0) {
lhs->SetZero();
if (rhs) {
@@ -193,27 +194,26 @@
// Add the diagonal to the schur complement.
if (D != NULL) {
- ParallelFor(
- context_,
- num_eliminate_blocks_,
- num_col_blocks,
- num_threads_,
- [&](int i) {
- const int block_id = i - num_eliminate_blocks_;
- int r, c, row_stride, col_stride;
- CellInfo* cell_info = lhs->GetCell(block_id, block_id, &r, &c,
- &row_stride, &col_stride);
- if (cell_info != NULL) {
- const int block_size = bs->cols[i].size;
- typename EigenTypes<Eigen::Dynamic>::ConstVectorRef diag(
- D + bs->cols[i].position, block_size);
+ ParallelFor(context_,
+ num_eliminate_blocks_,
+ num_col_blocks,
+ num_threads_,
+ [&](int i) {
+ const int block_id = i - num_eliminate_blocks_;
+ int r, c, row_stride, col_stride;
+ CellInfo* cell_info = lhs->GetCell(
+ block_id, block_id, &r, &c, &row_stride, &col_stride);
+ if (cell_info != NULL) {
+ const int block_size = bs->cols[i].size;
+ typename EigenTypes<Eigen::Dynamic>::ConstVectorRef diag(
+ D + bs->cols[i].position, block_size);
- std::lock_guard<std::mutex> l(cell_info->m);
- MatrixRef m(cell_info->values, row_stride, col_stride);
- m.block(r, c, block_size, block_size).diagonal() +=
- diag.array().square().matrix();
- }
- });
+ std::lock_guard<std::mutex> l(cell_info->m);
+ MatrixRef m(cell_info->values, row_stride, col_stride);
+ m.block(r, c, block_size, block_size).diagonal() +=
+ diag.array().square().matrix();
+ }
+ });
}
// Eliminate y blocks one chunk at a time. For each chunk, compute
@@ -242,12 +242,12 @@
VectorRef(buffer, buffer_size_).setZero();
- typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix
- ete(e_block_size, e_block_size);
+ typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix ete(e_block_size,
+ e_block_size);
if (D != NULL) {
- const typename EigenTypes<kEBlockSize>::ConstVectorRef
- diag(D + bs->cols[e_block_id].position, e_block_size);
+ const typename EigenTypes<kEBlockSize>::ConstVectorRef diag(
+ D + bs->cols[e_block_id].position, e_block_size);
ete = diag.array().square().matrix().asDiagonal();
} else {
ete.setZero();
@@ -299,31 +299,25 @@
// S -= F'E(E'E)^{-1}E'F
ChunkOuterProduct(
- thread_id, bs, inverse_ete, buffer, chunk.buffer_layout, lhs);
+ thread_id, bs, inverse_ete, buffer, chunk.buffer_layout, lhs);
});
// For rows with no e_blocks, the schur complement update reduces to
// S += F'F.
- NoEBlockRowsUpdate(A, b, uneliminated_row_begins_, lhs, rhs);
+ NoEBlockRowsUpdate(A, b, uneliminated_row_begins_, lhs, rhs);
}
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-BackSubstitute(const BlockSparseMatrixData& A,
- const double* b,
- const double* D,
- const double* z,
- double* y) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::BackSubstitute(
+ const BlockSparseMatrixData& A,
+ const double* b,
+ const double* D,
+ const double* z,
+ double* y) {
const CompressedRowBlockStructure* bs = A.block_structure();
const double* values = A.values();
- ParallelFor(
- context_,
- 0,
- int(chunks_.size()),
- num_threads_,
- [&](int i) {
+ ParallelFor(context_, 0, int(chunks_.size()), num_threads_, [&](int i) {
const Chunk& chunk = chunks_[i];
const int e_block_id = bs->rows[chunk.start].cells.front().block_id;
const int e_block_size = bs->cols[e_block_id].size;
@@ -331,11 +325,11 @@
double* y_ptr = y + bs->cols[e_block_id].position;
typename EigenTypes<kEBlockSize>::VectorRef y_block(y_ptr, e_block_size);
- typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix
- ete(e_block_size, e_block_size);
+ typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix ete(e_block_size,
+ e_block_size);
if (D != NULL) {
- const typename EigenTypes<kEBlockSize>::ConstVectorRef
- diag(D + bs->cols[e_block_id].position, e_block_size);
+ const typename EigenTypes<kEBlockSize>::ConstVectorRef diag(
+ D + bs->cols[e_block_id].position, e_block_size);
ete = diag.array().square().matrix().asDiagonal();
} else {
ete.setZero();
@@ -357,6 +351,7 @@
const int f_block_size = bs->cols[f_block_id].size;
const int r_block = f_block_id - num_eliminate_blocks_;
+ // clang-format off
MatrixVectorMultiply<kRowBlockSize, kFBlockSize, -1>(
values + row.cells[c].position, row.block.size, f_block_size,
z + lhs_row_layout_[r_block],
@@ -373,6 +368,7 @@
values + e_cell.position, row.block.size, e_block_size,
values + e_cell.position, row.block.size, e_block_size,
ete.data(), 0, 0, e_block_size, e_block_size);
+ // clang-format on
}
y_block =
@@ -384,14 +380,13 @@
//
// F'b - F'E(E'E)^(-1) E'b
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-UpdateRhs(const Chunk& chunk,
- const BlockSparseMatrixData& A,
- const double* b,
- int row_block_counter,
- const double* inverse_ete_g,
- double* rhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::UpdateRhs(
+ const Chunk& chunk,
+ const BlockSparseMatrixData& A,
+ const double* b,
+ int row_block_counter,
+ const double* inverse_ete_g,
+ double* rhs) {
const CompressedRowBlockStructure* bs = A.block_structure();
const double* values = A.values();
@@ -403,22 +398,26 @@
const Cell& e_cell = row.cells.front();
typename EigenTypes<kRowBlockSize>::Vector sj =
- typename EigenTypes<kRowBlockSize>::ConstVectorRef
- (b + b_pos, row.block.size);
+ typename EigenTypes<kRowBlockSize>::ConstVectorRef(b + b_pos,
+ row.block.size);
+ // clang-format off
MatrixVectorMultiply<kRowBlockSize, kEBlockSize, -1>(
values + e_cell.position, row.block.size, e_block_size,
inverse_ete_g, sj.data());
+ // clang-format on
for (int c = 1; c < row.cells.size(); ++c) {
const int block_id = row.cells[c].block_id;
const int block_size = bs->cols[block_id].size;
const int block = block_id - num_eliminate_blocks_;
std::lock_guard<std::mutex> l(*rhs_locks_[block]);
+ // clang-format off
MatrixTransposeVectorMultiply<kRowBlockSize, kFBlockSize, 1>(
values + row.cells[c].position,
row.block.size, block_size,
sj.data(), rhs + lhs_row_layout_[block]);
+ // clang-format on
}
b_pos += row.block.size;
}
@@ -444,17 +443,16 @@
//
// and the gradient of the e_block, E'b.
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-ChunkDiagonalBlockAndGradient(
- const Chunk& chunk,
- const BlockSparseMatrixData& A,
- const double* b,
- int row_block_counter,
- typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix* ete,
- double* g,
- double* buffer,
- BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ ChunkDiagonalBlockAndGradient(
+ const Chunk& chunk,
+ const BlockSparseMatrixData& A,
+ const double* b,
+ int row_block_counter,
+ typename EigenTypes<kEBlockSize, kEBlockSize>::Matrix* ete,
+ double* g,
+ double* buffer,
+ BlockRandomAccessMatrix* lhs) {
const CompressedRowBlockStructure* bs = A.block_structure();
const double* values = A.values();
@@ -474,18 +472,22 @@
// Extract the e_block, ETE += E_i' E_i
const Cell& e_cell = row.cells.front();
+ // clang-format off
MatrixTransposeMatrixMultiply
<kRowBlockSize, kEBlockSize, kRowBlockSize, kEBlockSize, 1>(
values + e_cell.position, row.block.size, e_block_size,
values + e_cell.position, row.block.size, e_block_size,
ete->data(), 0, 0, e_block_size, e_block_size);
+ // clang-format on
if (b) {
// g += E_i' b_i
+ // clang-format off
MatrixTransposeVectorMultiply<kRowBlockSize, kEBlockSize, 1>(
values + e_cell.position, row.block.size, e_block_size,
b + b_pos,
g);
+ // clang-format on
}
// buffer = E'F. This computation is done by iterating over the
@@ -493,13 +495,14 @@
for (int c = 1; c < row.cells.size(); ++c) {
const int f_block_id = row.cells[c].block_id;
const int f_block_size = bs->cols[f_block_id].size;
- double* buffer_ptr =
- buffer + FindOrDie(chunk.buffer_layout, f_block_id);
+ double* buffer_ptr = buffer + FindOrDie(chunk.buffer_layout, f_block_id);
+ // clang-format off
MatrixTransposeMatrixMultiply
<kRowBlockSize, kEBlockSize, kRowBlockSize, kFBlockSize, 1>(
values + e_cell.position, row.block.size, e_block_size,
values + row.cells[c].position, row.block.size, f_block_size,
buffer_ptr, 0, 0, e_block_size, f_block_size);
+ // clang-format on
}
b_pos += row.block.size;
}
@@ -510,14 +513,13 @@
//
// S -= F'E(E'E)^{-1}E'F.
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-ChunkOuterProduct(int thread_id,
- const CompressedRowBlockStructure* bs,
- const Matrix& inverse_ete,
- const double* buffer,
- const BufferLayoutType& buffer_layout,
- BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ ChunkOuterProduct(int thread_id,
+ const CompressedRowBlockStructure* bs,
+ const Matrix& inverse_ete,
+ const double* buffer,
+ const BufferLayoutType& buffer_layout,
+ BlockRandomAccessMatrix* lhs) {
// This is the most computationally expensive part of this
// code. Profiling experiments reveal that the bottleneck is not the
// computation of the right-hand matrix product, but memory
@@ -532,28 +534,31 @@
for (; it1 != buffer_layout.end(); ++it1) {
const int block1 = it1->first - num_eliminate_blocks_;
const int block1_size = bs->cols[it1->first].size;
+ // clang-format off
MatrixTransposeMatrixMultiply
<kEBlockSize, kFBlockSize, kEBlockSize, kEBlockSize, 0>(
buffer + it1->second, e_block_size, block1_size,
inverse_ete.data(), e_block_size, e_block_size,
b1_transpose_inverse_ete, 0, 0, block1_size, e_block_size);
+ // clang-format on
BufferLayoutType::const_iterator it2 = it1;
for (; it2 != buffer_layout.end(); ++it2) {
const int block2 = it2->first - num_eliminate_blocks_;
int r, c, row_stride, col_stride;
- CellInfo* cell_info = lhs->GetCell(block1, block2,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info =
+ lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
if (cell_info != NULL) {
const int block2_size = bs->cols[it2->first].size;
std::lock_guard<std::mutex> l(cell_info->m);
+ // clang-format off
MatrixMatrixMultiply
<kFBlockSize, kEBlockSize, kEBlockSize, kFBlockSize, -1>(
b1_transpose_inverse_ete, block1_size, e_block_size,
buffer + it2->second, e_block_size, block2_size,
cell_info->values, r, c, row_stride, col_stride);
+ // clang-format on
}
}
}
@@ -563,13 +568,12 @@
// += F'F. This function iterates over the rows of A with no e_block,
// and calls NoEBlockRowOuterProduct on each row.
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-NoEBlockRowsUpdate(const BlockSparseMatrixData& A,
- const double* b,
- int row_block_counter,
- BlockRandomAccessMatrix* lhs,
- double* rhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ NoEBlockRowsUpdate(const BlockSparseMatrixData& A,
+ const double* b,
+ int row_block_counter,
+ BlockRandomAccessMatrix* lhs,
+ double* rhs) {
const CompressedRowBlockStructure* bs = A.block_structure();
const double* values = A.values();
for (; row_block_counter < bs->rows.size(); ++row_block_counter) {
@@ -582,15 +586,16 @@
const int block_id = row.cells[c].block_id;
const int block_size = bs->cols[block_id].size;
const int block = block_id - num_eliminate_blocks_;
+ // clang-format off
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
values + row.cells[c].position, row.block.size, block_size,
b + row.block.position,
rhs + lhs_row_layout_[block]);
+ // clang-format on
}
}
}
-
// A row r of A, which has no e_blocks gets added to the Schur
// Complement as S += r r'. This function is responsible for computing
// the contribution of a single row r to the Schur complement. It is
@@ -606,11 +611,10 @@
// dynamic. Since the number of rows without e_blocks is small, the
// lack of templating is not an issue.
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-NoEBlockRowOuterProduct(const BlockSparseMatrixData& A,
- int row_block_index,
- BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ NoEBlockRowOuterProduct(const BlockSparseMatrixData& A,
+ int row_block_index,
+ BlockRandomAccessMatrix* lhs) {
const CompressedRowBlockStructure* bs = A.block_structure();
const double* values = A.values();
@@ -621,18 +625,19 @@
const int block1_size = bs->cols[row.cells[i].block_id].size;
int r, c, row_stride, col_stride;
- CellInfo* cell_info = lhs->GetCell(block1, block1,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info =
+ lhs->GetCell(block1, block1, &r, &c, &row_stride, &col_stride);
if (cell_info != NULL) {
std::lock_guard<std::mutex> l(cell_info->m);
// This multiply currently ignores the fact that this is a
// symmetric outer product.
+ // clang-format off
MatrixTransposeMatrixMultiply
<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, 1>(
values + row.cells[i].position, row.block.size, block1_size,
values + row.cells[i].position, row.block.size, block1_size,
cell_info->values, r, c, row_stride, col_stride);
+ // clang-format on
}
for (int j = i + 1; j < row.cells.size(); ++j) {
@@ -640,17 +645,18 @@
DCHECK_GE(block2, 0);
DCHECK_LT(block1, block2);
int r, c, row_stride, col_stride;
- CellInfo* cell_info = lhs->GetCell(block1, block2,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info =
+ lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
if (cell_info != NULL) {
const int block2_size = bs->cols[row.cells[j].block_id].size;
std::lock_guard<std::mutex> l(cell_info->m);
+ // clang-format off
MatrixTransposeMatrixMultiply
<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic, 1>(
values + row.cells[i].position, row.block.size, block1_size,
values + row.cells[j].position, row.block.size, block2_size,
cell_info->values, r, c, row_stride, col_stride);
+ // clang-format on
}
}
}
@@ -660,11 +666,10 @@
// function has the same structure as NoEBlockRowOuterProduct, except
// that this function uses the template parameters.
template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
-void
-SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
-EBlockRowOuterProduct(const BlockSparseMatrixData& A,
- int row_block_index,
- BlockRandomAccessMatrix* lhs) {
+void SchurEliminator<kRowBlockSize, kEBlockSize, kFBlockSize>::
+ EBlockRowOuterProduct(const BlockSparseMatrixData& A,
+ int row_block_index,
+ BlockRandomAccessMatrix* lhs) {
const CompressedRowBlockStructure* bs = A.block_structure();
const double* values = A.values();
@@ -675,17 +680,18 @@
const int block1_size = bs->cols[row.cells[i].block_id].size;
int r, c, row_stride, col_stride;
- CellInfo* cell_info = lhs->GetCell(block1, block1,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info =
+ lhs->GetCell(block1, block1, &r, &c, &row_stride, &col_stride);
if (cell_info != NULL) {
std::lock_guard<std::mutex> l(cell_info->m);
// block += b1.transpose() * b1;
+ // clang-format off
MatrixTransposeMatrixMultiply
<kRowBlockSize, kFBlockSize, kRowBlockSize, kFBlockSize, 1>(
values + row.cells[i].position, row.block.size, block1_size,
values + row.cells[i].position, row.block.size, block1_size,
cell_info->values, r, c, row_stride, col_stride);
+ // clang-format on
}
for (int j = i + 1; j < row.cells.size(); ++j) {
@@ -694,17 +700,18 @@
DCHECK_LT(block1, block2);
const int block2_size = bs->cols[row.cells[j].block_id].size;
int r, c, row_stride, col_stride;
- CellInfo* cell_info = lhs->GetCell(block1, block2,
- &r, &c,
- &row_stride, &col_stride);
+ CellInfo* cell_info =
+ lhs->GetCell(block1, block2, &r, &c, &row_stride, &col_stride);
if (cell_info != NULL) {
// block += b1.transpose() * b2;
std::lock_guard<std::mutex> l(cell_info->m);
+ // clang-format off
MatrixTransposeMatrixMultiply
<kRowBlockSize, kFBlockSize, kRowBlockSize, kFBlockSize, 1>(
values + row.cells[i].position, row.block.size, block1_size,
values + row.cells[j].position, row.block.size, block2_size,
cell_info->values, r, c, row_stride, col_stride);
+ // clang-format on
}
}
}
diff --git a/internal/ceres/scratch_evaluate_preparer.cc b/internal/ceres/scratch_evaluate_preparer.cc
index f01ef11..9905b22 100644
--- a/internal/ceres/scratch_evaluate_preparer.cc
+++ b/internal/ceres/scratch_evaluate_preparer.cc
@@ -37,9 +37,8 @@
namespace ceres {
namespace internal {
-ScratchEvaluatePreparer* ScratchEvaluatePreparer::Create(
- const Program &program,
- int num_threads) {
+ScratchEvaluatePreparer* ScratchEvaluatePreparer::Create(const Program& program,
+ int num_threads) {
ScratchEvaluatePreparer* preparers = new ScratchEvaluatePreparer[num_threads];
int max_derivatives_per_residual_block =
program.MaxDerivativesPerResidualBlock();
@@ -50,8 +49,7 @@
}
void ScratchEvaluatePreparer::Init(int max_derivatives_per_residual_block) {
- jacobian_scratch_.reset(
- new double[max_derivatives_per_residual_block]);
+ jacobian_scratch_.reset(new double[max_derivatives_per_residual_block]);
}
// Point the jacobian blocks into the scratch area of this evaluate preparer.
diff --git a/internal/ceres/scratch_evaluate_preparer.h b/internal/ceres/scratch_evaluate_preparer.h
index c8d9b93..2d2745d 100644
--- a/internal/ceres/scratch_evaluate_preparer.h
+++ b/internal/ceres/scratch_evaluate_preparer.h
@@ -47,7 +47,7 @@
class ScratchEvaluatePreparer {
public:
// Create num_threads ScratchEvaluatePreparers.
- static ScratchEvaluatePreparer* Create(const Program &program,
+ static ScratchEvaluatePreparer* Create(const Program& program,
int num_threads);
// EvaluatePreparer interface
diff --git a/internal/ceres/single_linkage_clustering.cc b/internal/ceres/single_linkage_clustering.cc
index 394492c..0e78131 100644
--- a/internal/ceres/single_linkage_clustering.cc
+++ b/internal/ceres/single_linkage_clustering.cc
@@ -30,8 +30,9 @@
#include "ceres/single_linkage_clustering.h"
-#include <unordered_set>
#include <unordered_map>
+#include <unordered_set>
+
#include "ceres/graph.h"
#include "ceres/graph_algorithms.h"
diff --git a/internal/ceres/single_linkage_clustering.h b/internal/ceres/single_linkage_clustering.h
index ccd6f8e..ef6bff4 100644
--- a/internal/ceres/single_linkage_clustering.h
+++ b/internal/ceres/single_linkage_clustering.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_SINGLE_LINKAGE_CLUSTERING_H_
#include <unordered_map>
+
#include "ceres/graph.h"
namespace ceres {
diff --git a/internal/ceres/single_linkage_clustering_test.cc b/internal/ceres/single_linkage_clustering_test.cc
index 281c281..28c7c41 100644
--- a/internal/ceres/single_linkage_clustering_test.cc
+++ b/internal/ceres/single_linkage_clustering_test.cc
@@ -31,6 +31,7 @@
#include "ceres/single_linkage_clustering.h"
#include <unordered_map>
+
#include "ceres/graph.h"
#include "gtest/gtest.h"
diff --git a/internal/ceres/small_blas.h b/internal/ceres/small_blas.h
index 81c5872..4ee9229 100644
--- a/internal/ceres/small_blas.h
+++ b/internal/ceres/small_blas.h
@@ -35,8 +35,8 @@
#ifndef CERES_INTERNAL_SMALL_BLAS_H_
#define CERES_INTERNAL_SMALL_BLAS_H_
-#include "ceres/internal/port.h"
#include "ceres/internal/eigen.h"
+#include "ceres/internal/port.h"
#include "glog/logging.h"
#include "small_blas_generic.h"
@@ -46,7 +46,7 @@
// The following three macros are used to share code and reduce
// template junk across the various GEMM variants.
#define CERES_GEMM_BEGIN(name) \
- template<int kRowA, int kColA, int kRowB, int kColB, int kOperation> \
+ template <int kRowA, int kColA, int kRowB, int kColB, int kOperation> \
inline void name(const double* A, \
const int num_row_a, \
const int num_col_a, \
@@ -59,56 +59,58 @@
const int row_stride_c, \
const int col_stride_c)
-#define CERES_GEMM_NAIVE_HEADER \
- DCHECK_GT(num_row_a, 0); \
- DCHECK_GT(num_col_a, 0); \
- DCHECK_GT(num_row_b, 0); \
- DCHECK_GT(num_col_b, 0); \
- DCHECK_GE(start_row_c, 0); \
- DCHECK_GE(start_col_c, 0); \
- DCHECK_GT(row_stride_c, 0); \
- DCHECK_GT(col_stride_c, 0); \
- DCHECK((kRowA == Eigen::Dynamic) || (kRowA == num_row_a)); \
- DCHECK((kColA == Eigen::Dynamic) || (kColA == num_col_a)); \
- DCHECK((kRowB == Eigen::Dynamic) || (kRowB == num_row_b)); \
- DCHECK((kColB == Eigen::Dynamic) || (kColB == num_col_b)); \
- const int NUM_ROW_A = (kRowA != Eigen::Dynamic ? kRowA : num_row_a); \
- const int NUM_COL_A = (kColA != Eigen::Dynamic ? kColA : num_col_a); \
- const int NUM_ROW_B = (kRowB != Eigen::Dynamic ? kRowB : num_row_b); \
+#define CERES_GEMM_NAIVE_HEADER \
+ DCHECK_GT(num_row_a, 0); \
+ DCHECK_GT(num_col_a, 0); \
+ DCHECK_GT(num_row_b, 0); \
+ DCHECK_GT(num_col_b, 0); \
+ DCHECK_GE(start_row_c, 0); \
+ DCHECK_GE(start_col_c, 0); \
+ DCHECK_GT(row_stride_c, 0); \
+ DCHECK_GT(col_stride_c, 0); \
+ DCHECK((kRowA == Eigen::Dynamic) || (kRowA == num_row_a)); \
+ DCHECK((kColA == Eigen::Dynamic) || (kColA == num_col_a)); \
+ DCHECK((kRowB == Eigen::Dynamic) || (kRowB == num_row_b)); \
+ DCHECK((kColB == Eigen::Dynamic) || (kColB == num_col_b)); \
+ const int NUM_ROW_A = (kRowA != Eigen::Dynamic ? kRowA : num_row_a); \
+ const int NUM_COL_A = (kColA != Eigen::Dynamic ? kColA : num_col_a); \
+ const int NUM_ROW_B = (kRowB != Eigen::Dynamic ? kRowB : num_row_b); \
const int NUM_COL_B = (kColB != Eigen::Dynamic ? kColB : num_col_b);
-#define CERES_GEMM_EIGEN_HEADER \
- const typename EigenTypes<kRowA, kColA>::ConstMatrixRef \
- Aref(A, num_row_a, num_col_a); \
- const typename EigenTypes<kRowB, kColB>::ConstMatrixRef \
- Bref(B, num_row_b, num_col_b); \
- MatrixRef Cref(C, row_stride_c, col_stride_c); \
+#define CERES_GEMM_EIGEN_HEADER \
+ const typename EigenTypes<kRowA, kColA>::ConstMatrixRef Aref( \
+ A, num_row_a, num_col_a); \
+ const typename EigenTypes<kRowB, kColB>::ConstMatrixRef Bref( \
+ B, num_row_b, num_col_b); \
+ MatrixRef Cref(C, row_stride_c, col_stride_c);
+// clang-format off
#define CERES_CALL_GEMM(name) \
name<kRowA, kColA, kRowB, kColB, kOperation>( \
A, num_row_a, num_col_a, \
B, num_row_b, num_col_b, \
C, start_row_c, start_col_c, row_stride_c, col_stride_c);
+// clang-format on
-#define CERES_GEMM_STORE_SINGLE(p, index, value) \
- if (kOperation > 0) { \
- p[index] += value; \
- } else if (kOperation < 0) { \
- p[index] -= value; \
- } else { \
- p[index] = value; \
+#define CERES_GEMM_STORE_SINGLE(p, index, value) \
+ if (kOperation > 0) { \
+ p[index] += value; \
+ } else if (kOperation < 0) { \
+ p[index] -= value; \
+ } else { \
+ p[index] = value; \
}
-#define CERES_GEMM_STORE_PAIR(p, index, v1, v2) \
- if (kOperation > 0) { \
- p[index] += v1; \
- p[index + 1] += v2; \
- } else if (kOperation < 0) { \
- p[index] -= v1; \
- p[index + 1] -= v2; \
- } else { \
- p[index] = v1; \
- p[index + 1] = v2; \
+#define CERES_GEMM_STORE_PAIR(p, index, v1, v2) \
+ if (kOperation > 0) { \
+ p[index] += v1; \
+ p[index + 1] += v2; \
+ } else if (kOperation < 0) { \
+ p[index] -= v1; \
+ p[index + 1] -= v2; \
+ } else { \
+ p[index] = v1; \
+ p[index + 1] = v2; \
}
// For the matrix-matrix functions below, there are three variants for
@@ -161,8 +163,8 @@
//
CERES_GEMM_BEGIN(MatrixMatrixMultiplyEigen) {
CERES_GEMM_EIGEN_HEADER
- Eigen::Block<MatrixRef, kRowA, kColB>
- block(Cref, start_row_c, start_col_c, num_row_a, num_col_b);
+ Eigen::Block<MatrixRef, kRowA, kColB> block(
+ Cref, start_row_c, start_col_c, num_row_a, num_col_b);
if (kOperation > 0) {
block.noalias() += Aref * Bref;
@@ -208,7 +210,7 @@
// Process the couple columns in remainder if present.
if (NUM_COL_C & 2) {
- int col = NUM_COL_C & (int)(~(span - 1)) ;
+ int col = NUM_COL_C & (int)(~(span - 1));
const double* pa = &A[0];
for (int row = 0; row < NUM_ROW_C; ++row, pa += NUM_COL_A) {
const double* pb = &B[col];
@@ -234,11 +236,12 @@
for (int col = 0; col < col_m; col += span) {
for (int row = 0; row < NUM_ROW_C; ++row) {
const int index = (row + start_row_c) * col_stride_c + start_col_c + col;
+ // clang-format off
MMM_mat1x4(NUM_COL_A, &A[row * NUM_COL_A],
&B[col], NUM_COL_B, &C[index], kOperation);
+ // clang-format on
}
}
-
}
CERES_GEMM_BEGIN(MatrixMatrixMultiply) {
@@ -261,9 +264,11 @@
CERES_GEMM_BEGIN(MatrixTransposeMatrixMultiplyEigen) {
CERES_GEMM_EIGEN_HEADER
+ // clang-format off
Eigen::Block<MatrixRef, kColA, kColB> block(Cref,
start_row_c, start_col_c,
num_col_a, num_col_b);
+ // clang-format on
if (kOperation > 0) {
block.noalias() += Aref.transpose() * Bref;
} else if (kOperation < 0) {
@@ -310,7 +315,7 @@
// Process the couple columns in remainder if present.
if (NUM_COL_C & 2) {
- int col = NUM_COL_C & (int)(~(span - 1)) ;
+ int col = NUM_COL_C & (int)(~(span - 1));
for (int row = 0; row < NUM_ROW_C; ++row) {
const double* pa = &A[row];
const double* pb = &B[col];
@@ -338,11 +343,12 @@
for (int col = 0; col < col_m; col += span) {
for (int row = 0; row < NUM_ROW_C; ++row) {
const int index = (row + start_row_c) * col_stride_c + start_col_c + col;
+ // clang-format off
MTM_mat1x4(NUM_ROW_A, &A[row], NUM_COL_A,
&B[col], NUM_COL_B, &C[index], kOperation);
+ // clang-format on
}
}
-
}
CERES_GEMM_BEGIN(MatrixTransposeMatrixMultiply) {
@@ -376,15 +382,15 @@
// kOperation = 1 -> c += A' * b
// kOperation = -1 -> c -= A' * b
// kOperation = 0 -> c = A' * b
-template<int kRowA, int kColA, int kOperation>
+template <int kRowA, int kColA, int kOperation>
inline void MatrixVectorMultiply(const double* A,
const int num_row_a,
const int num_col_a,
const double* b,
double* c) {
#ifdef CERES_NO_CUSTOM_BLAS
- const typename EigenTypes<kRowA, kColA>::ConstMatrixRef
- Aref(A, num_row_a, num_col_a);
+ const typename EigenTypes<kRowA, kColA>::ConstMatrixRef Aref(
+ A, num_row_a, num_col_a);
const typename EigenTypes<kColA>::ConstVectorRef bref(b, num_col_a);
typename EigenTypes<kRowA>::VectorRef cref(c, num_row_a);
@@ -412,7 +418,7 @@
// Process the last odd row if present.
if (NUM_ROW_A & 1) {
- int row = NUM_ROW_A - 1;
+ int row = NUM_ROW_A - 1;
const double* pa = &A[row * NUM_COL_A];
const double* pb = &b[0];
double tmp = 0.0;
@@ -450,8 +456,10 @@
// Calculate the main part with multiples of 4.
int row_m = NUM_ROW_A & (int)(~(span - 1));
for (int row = 0; row < row_m; row += span) {
+ // clang-format off
MVM_mat4x1(NUM_COL_A, &A[row * NUM_COL_A], NUM_COL_A,
&b[0], &c[row], kOperation);
+ // clang-format on
}
#endif // CERES_NO_CUSTOM_BLAS
@@ -460,15 +468,15 @@
// Similar to MatrixVectorMultiply, except that A is transposed, i.e.,
//
// c op A' * b;
-template<int kRowA, int kColA, int kOperation>
+template <int kRowA, int kColA, int kOperation>
inline void MatrixTransposeVectorMultiply(const double* A,
const int num_row_a,
const int num_col_a,
const double* b,
double* c) {
#ifdef CERES_NO_CUSTOM_BLAS
- const typename EigenTypes<kRowA, kColA>::ConstMatrixRef
- Aref(A, num_row_a, num_col_a);
+ const typename EigenTypes<kRowA, kColA>::ConstMatrixRef Aref(
+ A, num_row_a, num_col_a);
const typename EigenTypes<kRowA>::ConstVectorRef bref(b, num_row_a);
typename EigenTypes<kColA>::VectorRef cref(c, num_col_a);
@@ -496,7 +504,7 @@
// Process the last odd column if present.
if (NUM_COL_A & 1) {
- int row = NUM_COL_A - 1;
+ int row = NUM_COL_A - 1;
const double* pa = &A[row];
const double* pb = &b[0];
double tmp = 0.0;
@@ -519,10 +527,12 @@
const double* pb = &b[0];
double tmp1 = 0.0, tmp2 = 0.0;
for (int col = 0; col < NUM_ROW_A; ++col) {
+ // clang-format off
double bv = *pb++;
tmp1 += *(pa ) * bv;
tmp2 += *(pa + 1) * bv;
pa += NUM_COL_A;
+ // clang-format on
}
CERES_GEMM_STORE_PAIR(c, row, tmp1, tmp2);
@@ -535,8 +545,10 @@
// Calculate the main part with multiples of 4.
int row_m = NUM_COL_A & (int)(~(span - 1));
for (int row = 0; row < row_m; row += span) {
+ // clang-format off
MTV_mat4x1(NUM_ROW_A, &A[row], NUM_COL_A,
&b[0], &c[row], kOperation);
+ // clang-format on
}
#endif // CERES_NO_CUSTOM_BLAS
diff --git a/internal/ceres/small_blas_gemm_benchmark.cc b/internal/ceres/small_blas_gemm_benchmark.cc
index 0a760a5..aa6c41d 100644
--- a/internal/ceres/small_blas_gemm_benchmark.cc
+++ b/internal/ceres/small_blas_gemm_benchmark.cc
@@ -29,6 +29,7 @@
// Authors: sameeragarwal@google.com (Sameer Agarwal)
#include <iostream>
+
#include "Eigen/Dense"
#include "benchmark/benchmark.h"
#include "ceres/small_blas.h"
@@ -103,11 +104,13 @@
int iter = 0;
for (auto _ : state) {
// a += b * c
+ // clang-format off
MatrixMatrixMultiply
<Eigen::Dynamic, Eigen::Dynamic,Eigen::Dynamic,Eigen::Dynamic, 1>
(data.GetB(iter), b_rows, b_cols,
data.GetC(iter), c_rows, c_cols,
data.GetA(iter), 0, 0, a_rows, a_cols);
+ // clang-format on
iter = (iter + 1) % num_elements;
}
}
@@ -147,11 +150,13 @@
int iter = 0;
for (auto _ : state) {
// a += b' * c
+ // clang-format off
MatrixTransposeMatrixMultiply
<Eigen::Dynamic,Eigen::Dynamic,Eigen::Dynamic,Eigen::Dynamic, 1>
(data.GetB(iter), b_rows, b_cols,
data.GetC(iter), c_rows, c_cols,
data.GetA(iter), 0, 0, a_rows, a_cols);
+ // clang-format on
iter = (iter + 1) % num_elements;
}
}
@@ -159,7 +164,7 @@
BENCHMARK(BM_MatrixTransposeMatrixMultiplyDynamic)
->Apply(MatrixTransposeMatrixMultiplySizeArguments);
-} // internal
+} // namespace internal
} // namespace ceres
BENCHMARK_MAIN();
diff --git a/internal/ceres/small_blas_generic.h b/internal/ceres/small_blas_generic.h
index 978c5d5..3f3ea42 100644
--- a/internal/ceres/small_blas_generic.h
+++ b/internal/ceres/small_blas_generic.h
@@ -39,33 +39,33 @@
namespace internal {
// The following macros are used to share code
-#define CERES_GEMM_OPT_NAIVE_HEADER \
- double c0 = 0.0; \
- double c1 = 0.0; \
- double c2 = 0.0; \
- double c3 = 0.0; \
- const double* pa = a; \
- const double* pb = b; \
- const int span = 4; \
- int col_r = col_a & (span - 1); \
+#define CERES_GEMM_OPT_NAIVE_HEADER \
+ double c0 = 0.0; \
+ double c1 = 0.0; \
+ double c2 = 0.0; \
+ double c3 = 0.0; \
+ const double* pa = a; \
+ const double* pb = b; \
+ const int span = 4; \
+ int col_r = col_a & (span - 1); \
int col_m = col_a - col_r;
-#define CERES_GEMM_OPT_STORE_MAT1X4 \
- if (kOperation > 0) { \
- *c++ += c0; \
- *c++ += c1; \
- *c++ += c2; \
- *c++ += c3; \
- } else if (kOperation < 0) { \
- *c++ -= c0; \
- *c++ -= c1; \
- *c++ -= c2; \
- *c++ -= c3; \
- } else { \
- *c++ = c0; \
- *c++ = c1; \
- *c++ = c2; \
- *c++ = c3; \
+#define CERES_GEMM_OPT_STORE_MAT1X4 \
+ if (kOperation > 0) { \
+ *c++ += c0; \
+ *c++ += c1; \
+ *c++ += c2; \
+ *c++ += c3; \
+ } else if (kOperation < 0) { \
+ *c++ -= c0; \
+ *c++ -= c1; \
+ *c++ -= c2; \
+ *c++ -= c3; \
+ } else { \
+ *c++ = c0; \
+ *c++ = c1; \
+ *c++ = c2; \
+ *c++ = c3; \
}
// Matrix-Matrix Multiplication
@@ -97,14 +97,14 @@
double av = 0.0;
int bi = 0;
-#define CERES_GEMM_OPT_MMM_MAT1X4_MUL \
- av = pa[k]; \
- pb = b + bi; \
- c0 += av * *pb++; \
- c1 += av * *pb++; \
- c2 += av * *pb++; \
- c3 += av * *pb++; \
- bi += col_stride_b; \
+#define CERES_GEMM_OPT_MMM_MAT1X4_MUL \
+ av = pa[k]; \
+ pb = b + bi; \
+ c0 += av * *pb++; \
+ c1 += av * *pb++; \
+ c2 += av * *pb++; \
+ c3 += av * *pb++; \
+ bi += col_stride_b; \
k++;
for (int k = 0; k < col_m;) {
@@ -164,14 +164,14 @@
int ai = 0;
int bi = 0;
-#define CERES_GEMM_OPT_MTM_MAT1X4_MUL \
- av = pa[ai]; \
- pb = b + bi; \
- c0 += av * *pb++; \
- c1 += av * *pb++; \
- c2 += av * *pb++; \
- c3 += av * *pb++; \
- ai += col_stride_a; \
+#define CERES_GEMM_OPT_MTM_MAT1X4_MUL \
+ av = pa[ai]; \
+ pb = b + bi; \
+ c0 += av * *pb++; \
+ c1 += av * *pb++; \
+ c2 += av * *pb++; \
+ c3 += av * *pb++; \
+ ai += col_stride_a; \
bi += col_stride_b;
for (int k = 0; k < col_m; k += span) {
@@ -218,14 +218,16 @@
CERES_GEMM_OPT_NAIVE_HEADER
double bv = 0.0;
-#define CERES_GEMM_OPT_MVM_MAT4X1_MUL \
- bv = *pb; \
- c0 += *(pa ) * bv; \
- c1 += *(pa + col_stride_a ) * bv; \
- c2 += *(pa + col_stride_a * 2) * bv; \
- c3 += *(pa + col_stride_a * 3) * bv; \
- pa++; \
+ // clang-format off
+#define CERES_GEMM_OPT_MVM_MAT4X1_MUL \
+ bv = *pb; \
+ c0 += *(pa ) * bv; \
+ c1 += *(pa + col_stride_a ) * bv; \
+ c2 += *(pa + col_stride_a * 2) * bv; \
+ c3 += *(pa + col_stride_a * 3) * bv; \
+ pa++; \
pb++;
+ // clang-format on
for (int k = 0; k < col_m; k += span) {
CERES_GEMM_OPT_MVM_MAT4X1_MUL
@@ -281,14 +283,16 @@
CERES_GEMM_OPT_NAIVE_HEADER
double bv = 0.0;
-#define CERES_GEMM_OPT_MTV_MAT4X1_MUL \
- bv = *pb; \
- c0 += *(pa ) * bv; \
- c1 += *(pa + 1) * bv; \
- c2 += *(pa + 2) * bv; \
- c3 += *(pa + 3) * bv; \
- pa += col_stride_a; \
+ // clang-format off
+#define CERES_GEMM_OPT_MTV_MAT4X1_MUL \
+ bv = *pb; \
+ c0 += *(pa ) * bv; \
+ c1 += *(pa + 1) * bv; \
+ c2 += *(pa + 2) * bv; \
+ c3 += *(pa + 3) * bv; \
+ pa += col_stride_a; \
pb++;
+ // clang-format on
for (int k = 0; k < col_m; k += span) {
CERES_GEMM_OPT_MTV_MAT4X1_MUL
diff --git a/internal/ceres/small_blas_test.cc b/internal/ceres/small_blas_test.cc
index 2914244..6f819c4 100644
--- a/internal/ceres/small_blas_test.cc
+++ b/internal/ceres/small_blas_test.cc
@@ -31,8 +31,9 @@
#include "ceres/small_blas.h"
#include <limits>
-#include "gtest/gtest.h"
+
#include "ceres/internal/eigen.h"
+#include "gtest/gtest.h"
namespace ceres {
namespace internal {
@@ -62,6 +63,7 @@
Matrix C_plus_ref = C;
Matrix C_minus_ref = C;
Matrix C_assign_ref = C;
+ // clang-format off
for (int start_row_c = 0; start_row_c + kRowA < row_stride_c; ++start_row_c) {
for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
C_plus_ref.block(start_row_c, start_col_c, kRowA, kColB) +=
@@ -81,7 +83,6 @@
<< "Cref : \n" << C_plus_ref << "\n"
<< "C: \n" << C_plus;
-
C_minus_ref.block(start_row_c, start_col_c, kRowA, kColB) -=
A * B;
@@ -117,6 +118,7 @@
<< "C: \n" << C_assign;
}
}
+ // clang-format on
}
}
}
@@ -133,7 +135,7 @@
B.setOnes();
for (int row_stride_c = kColA; row_stride_c < 3 * kColA; ++row_stride_c) {
- for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
+ for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
Matrix C(row_stride_c, col_stride_c);
C.setOnes();
@@ -144,6 +146,7 @@
Matrix C_plus_ref = C;
Matrix C_minus_ref = C;
Matrix C_assign_ref = C;
+ // clang-format off
for (int start_row_c = 0; start_row_c + kColA < row_stride_c; ++start_row_c) {
for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
C_plus_ref.block(start_row_c, start_col_c, kColA, kColB) +=
@@ -198,6 +201,7 @@
<< "C: \n" << C_assign;
}
}
+ // clang-format on
}
}
}
@@ -228,6 +232,7 @@
Matrix C_plus_ref = C;
Matrix C_minus_ref = C;
Matrix C_assign_ref = C;
+ // clang-format off
for (int start_row_c = 0; start_row_c + kRowA < row_stride_c; ++start_row_c) {
for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
C_plus_ref.block(start_row_c, start_col_c, kRowA, kColB) +=
@@ -247,7 +252,6 @@
<< "Cref : \n" << C_plus_ref << "\n"
<< "C: \n" << C_plus;
-
C_minus_ref.block(start_row_c, start_col_c, kRowA, kColB) -=
A * B;
@@ -283,6 +287,7 @@
<< "C: \n" << C_assign;
}
}
+ // clang-format on
}
}
}
@@ -299,7 +304,7 @@
B.setOnes();
for (int row_stride_c = kColA; row_stride_c < 3 * kColA; ++row_stride_c) {
- for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
+ for (int col_stride_c = kColB; col_stride_c < 3 * kColB; ++col_stride_c) {
Matrix C(row_stride_c, col_stride_c);
C.setOnes();
@@ -310,6 +315,7 @@
Matrix C_plus_ref = C;
Matrix C_minus_ref = C;
Matrix C_assign_ref = C;
+ // clang-format off
for (int start_row_c = 0; start_row_c + kColA < row_stride_c; ++start_row_c) {
for (int start_col_c = 0; start_col_c + kColB < col_stride_c; ++start_col_c) {
C_plus_ref.block(start_row_c, start_col_c, kColA, kColB) +=
@@ -364,6 +370,7 @@
<< "C: \n" << C_assign;
}
}
+ // clang-format on
}
}
}
@@ -388,6 +395,7 @@
Vector c_minus_ref = c;
Vector c_assign_ref = c;
+ // clang-format off
c_plus_ref += A * b;
MatrixVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
A.data(), num_rows_a, num_cols_a,
@@ -417,6 +425,7 @@
<< "c += A * b \n"
<< "c_ref : \n" << c_assign_ref << "\n"
<< "c: \n" << c_assign;
+ // clang-format on
}
}
}
@@ -441,6 +450,7 @@
Vector c_minus_ref = c;
Vector c_assign_ref = c;
+ // clang-format off
c_plus_ref += A.transpose() * b;
MatrixTransposeVectorMultiply<Eigen::Dynamic, Eigen::Dynamic, 1>(
A.data(), num_rows_a, num_cols_a,
@@ -470,6 +480,7 @@
<< "c += A' * b \n"
<< "c_ref : \n" << c_assign_ref << "\n"
<< "c: \n" << c_assign;
+ // clang-format on
}
}
}
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 861d8d3..b7399e6 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -56,34 +56,34 @@
namespace ceres {
namespace {
+using internal::StringAppendF;
+using internal::StringPrintf;
using std::map;
using std::string;
using std::vector;
-using internal::StringAppendF;
-using internal::StringPrintf;
-#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 << "Violated constraint: "; \
- ss << string("Solver::Options::" #x " " #OP " "#y); \
- *error = ss.str(); \
- return false; \
+#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 << "Violated constraint: "; \
+ ss << string("Solver::Options::" #x " " #OP " " #y); \
+ *error = ss.str(); \
+ return false; \
}
-#define OPTION_OP_OPTION(x, y, OP) \
- 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 << "Violated constraint: "; \
- ss << string("Solver::Options::" #x); \
- ss << string(#OP " Solver::Options::" #y "."); \
- *error = ss.str(); \
- return false; \
+#define OPTION_OP_OPTION(x, y, OP) \
+ 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 << "Violated constraint: "; \
+ ss << string("Solver::Options::" #x); \
+ ss << string(#OP " Solver::Options::" #y "."); \
+ *error = ss.str(); \
+ return false; \
}
#define OPTION_GE(x, y) OPTION_OP(x, y, >=);
@@ -135,7 +135,8 @@
if (options.linear_solver_type == ITERATIVE_SCHUR &&
options.use_explicit_schur_complement &&
options.preconditioner_type != SCHUR_JACOBI) {
- *error = "use_explicit_schur_complement only supports "
+ *error =
+ "use_explicit_schur_complement only supports "
"SCHUR_JACOBI as the preconditioner.";
return false;
}
@@ -174,7 +175,8 @@
*error = StringPrintf(
"Can't use %s with "
"Solver::Options::sparse_linear_algebra_library_type = %s.",
- name, sparse_linear_algebra_library_name);
+ name,
+ sparse_linear_algebra_library_name);
return false;
} else if (!IsSparseLinearAlgebraLibraryTypeAvailable(
options.sparse_linear_algebra_library_type)) {
@@ -182,7 +184,8 @@
"Can't use %s with "
"Solver::Options::sparse_linear_algebra_library_type = %s, "
"because support was not enabled when Ceres Solver was built.",
- name, sparse_linear_algebra_library_name);
+ name,
+ sparse_linear_algebra_library_name);
return false;
}
}
@@ -191,7 +194,8 @@
if (options.trust_region_strategy_type == DOGLEG) {
if (options.linear_solver_type == ITERATIVE_SCHUR ||
options.linear_solver_type == CGNR) {
- *error = "DOGLEG only supports exact factorization based linear "
+ *error =
+ "DOGLEG only supports exact factorization based linear "
"solvers. If you want to use an iterative solver please "
"use LEVENBERG_MARQUARDT as the trust_region_strategy_type";
return false;
@@ -207,12 +211,13 @@
if (options.dynamic_sparsity) {
if (options.linear_solver_type != SPARSE_NORMAL_CHOLESKY) {
- *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
+ *error =
+ "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
return false;
}
if (options.sparse_linear_algebra_library_type == ACCELERATE_SPARSE) {
- *error = "ACCELERATE_SPARSE is not currently supported with dynamic "
- "sparsity.";
+ *error =
+ "ACCELERATE_SPARSE is not currently supported with dynamic sparsity.";
return false;
}
}
@@ -250,10 +255,11 @@
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(". When using (L)BFGS, "
- "Solver::Options::line_search_type must be set to WOLFE.");
+ string("Invalid configuration: Solver::Options::line_search_type = ") +
+ string(LineSearchTypeToString(options.line_search_type)) +
+ string(
+ ". When using (L)BFGS, "
+ "Solver::Options::line_search_type must be set to WOLFE.");
return false;
}
@@ -298,20 +304,24 @@
void SummarizeGivenProgram(const internal::Program& program,
Solver::Summary* summary) {
+ // clang-format off
summary->num_parameter_blocks = program.NumParameterBlocks();
summary->num_parameters = program.NumParameters();
summary->num_effective_parameters = program.NumEffectiveParameters();
summary->num_residual_blocks = program.NumResidualBlocks();
summary->num_residuals = program.NumResiduals();
+ // clang-format on
}
void SummarizeReducedProgram(const internal::Program& program,
Solver::Summary* summary) {
+ // clang-format off
summary->num_parameter_blocks_reduced = program.NumParameterBlocks();
summary->num_parameters_reduced = program.NumParameters();
summary->num_effective_parameters_reduced = program.NumEffectiveParameters();
summary->num_residual_blocks_reduced = program.NumResidualBlocks();
summary->num_residuals_reduced = program.NumResiduals();
+ // clang-format on
}
void PreSolveSummarize(const Solver::Options& options,
@@ -323,6 +333,7 @@
internal::OrderingToGroupSizes(options.inner_iteration_ordering.get(),
&(summary->inner_iteration_ordering_given));
+ // clang-format off
summary->dense_linear_algebra_library_type = options.dense_linear_algebra_library_type; // NOLINT
summary->dogleg_type = options.dogleg_type;
summary->inner_iteration_time_in_seconds = 0.0;
@@ -344,6 +355,7 @@
summary->sparse_linear_algebra_library_type = options.sparse_linear_algebra_library_type; // NOLINT
summary->trust_region_strategy_type = options.trust_region_strategy_type; // NOLINT
summary->visibility_clustering_type = options.visibility_clustering_type; // NOLINT
+ // clang-format on
}
void PostSolveSummarize(const internal::PreprocessedProblem& pp,
@@ -353,10 +365,12 @@
internal::OrderingToGroupSizes(pp.options.inner_iteration_ordering.get(),
&(summary->inner_iteration_ordering_used));
+ // clang-format off
summary->inner_iterations_used = pp.inner_iteration_minimizer.get() != NULL; // NOLINT
summary->linear_solver_type_used = pp.linear_solver_options.type;
summary->num_threads_used = pp.options.num_threads;
summary->preconditioner_type_used = pp.options.preconditioner_type;
+ // clang-format on
internal::SetSummaryFinalCost(summary);
@@ -402,14 +416,14 @@
}
}
-void Minimize(internal::PreprocessedProblem* pp,
- Solver::Summary* summary) {
- using internal::Program;
+void Minimize(internal::PreprocessedProblem* pp, Solver::Summary* summary) {
using internal::Minimizer;
+ using internal::Program;
Program* program = pp->reduced_program.get();
if (pp->reduced_program->NumParameterBlocks() == 0) {
- summary->message = "Function tolerance reached. "
+ summary->message =
+ "Function tolerance reached. "
"No non-constant parameter blocks found.";
summary->termination_type = CONVERGENCE;
VLOG_IF(1, pp->options.logging_type != SILENT) << summary->message;
@@ -421,31 +435,29 @@
const Vector original_reduced_parameters = pp->reduced_parameters;
std::unique_ptr<Minimizer> minimizer(
Minimizer::Create(pp->options.minimizer_type));
- minimizer->Minimize(pp->minimizer_options,
- pp->reduced_parameters.data(),
- summary);
+ minimizer->Minimize(
+ pp->minimizer_options, pp->reduced_parameters.data(), summary);
program->StateVectorToParameterBlocks(
- summary->IsSolutionUsable()
- ? pp->reduced_parameters.data()
- : original_reduced_parameters.data());
+ summary->IsSolutionUsable() ? pp->reduced_parameters.data()
+ : original_reduced_parameters.data());
program->CopyParameterBlockStateToUserState();
}
std::string SchurStructureToString(const int row_block_size,
const int e_block_size,
const int f_block_size) {
- const std::string row =
- (row_block_size == Eigen::Dynamic)
- ? "d" : internal::StringPrintf("%d", row_block_size);
+ const std::string row = (row_block_size == Eigen::Dynamic)
+ ? "d"
+ : internal::StringPrintf("%d", row_block_size);
- const std::string e =
- (e_block_size == Eigen::Dynamic)
- ? "d" : internal::StringPrintf("%d", e_block_size);
+ const std::string e = (e_block_size == Eigen::Dynamic)
+ ? "d"
+ : internal::StringPrintf("%d", e_block_size);
- const std::string f =
- (f_block_size == Eigen::Dynamic)
- ? "d" : internal::StringPrintf("%d", f_block_size);
+ const std::string f = (f_block_size == Eigen::Dynamic)
+ ? "d"
+ : internal::StringPrintf("%d", f_block_size);
return internal::StringPrintf("%s,%s,%s", row.c_str(), e.c_str(), f.c_str());
}
@@ -503,12 +515,11 @@
Solver::Options modified_options = options;
if (options.check_gradients) {
modified_options.callbacks.push_back(&gradient_checking_callback);
- gradient_checking_problem.reset(
- CreateGradientCheckingProblemImpl(
- problem_impl,
- options.gradient_check_numeric_derivative_relative_step_size,
- options.gradient_check_relative_precision,
- &gradient_checking_callback));
+ gradient_checking_problem.reset(CreateGradientCheckingProblemImpl(
+ problem_impl,
+ options.gradient_check_numeric_derivative_relative_step_size,
+ options.gradient_check_relative_precision,
+ &gradient_checking_callback));
problem_impl = gradient_checking_problem.get();
program = problem_impl->mutable_program();
}
@@ -524,7 +535,8 @@
Preprocessor::Create(modified_options.minimizer_type));
PreprocessedProblem pp;
- const bool status = preprocessor->Preprocess(modified_options, problem_impl, &pp);
+ const bool status =
+ preprocessor->Preprocess(modified_options, problem_impl, &pp);
// We check the linear_solver_options.type rather than
// modified_options.linear_solver_type because, depending on the
@@ -538,17 +550,16 @@
int e_block_size;
int f_block_size;
DetectStructure(*static_cast<internal::BlockSparseMatrix*>(
- pp.minimizer_options.jacobian.get())
- ->block_structure(),
+ pp.minimizer_options.jacobian.get())
+ ->block_structure(),
pp.linear_solver_options.elimination_groups[0],
&row_block_size,
&e_block_size,
&f_block_size);
summary->schur_structure_given =
SchurStructureToString(row_block_size, e_block_size, f_block_size);
- internal::GetBestSchurTemplateSpecialization(&row_block_size,
- &e_block_size,
- &f_block_size);
+ internal::GetBestSchurTemplateSpecialization(
+ &row_block_size, &e_block_size, &f_block_size);
summary->schur_structure_used =
SchurStructureToString(row_block_size, e_block_size, f_block_size);
}
@@ -595,15 +606,16 @@
}
string Solver::Summary::BriefReport() const {
- return StringPrintf("Ceres Solver Report: "
- "Iterations: %d, "
- "Initial cost: %e, "
- "Final cost: %e, "
- "Termination: %s",
- num_successful_steps + num_unsuccessful_steps,
- initial_cost,
- final_cost,
- TerminationTypeToString(termination_type));
+ return StringPrintf(
+ "Ceres Solver Report: "
+ "Iterations: %d, "
+ "Initial cost: %e, "
+ "Final cost: %e, "
+ "Termination: %s",
+ num_successful_steps + num_unsuccessful_steps,
+ initial_cost,
+ final_cost,
+ TerminationTypeToString(termination_type));
}
string Solver::Summary::FullReport() const {
@@ -612,28 +624,39 @@
string report = string("\nSolver Summary (v " + VersionString() + ")\n\n");
StringAppendF(&report, "%45s %21s\n", "Original", "Reduced");
- StringAppendF(&report, "Parameter blocks % 25d% 25d\n",
- num_parameter_blocks, num_parameter_blocks_reduced);
- StringAppendF(&report, "Parameters % 25d% 25d\n",
- num_parameters, num_parameters_reduced);
+ StringAppendF(&report,
+ "Parameter blocks % 25d% 25d\n",
+ num_parameter_blocks,
+ num_parameter_blocks_reduced);
+ StringAppendF(&report,
+ "Parameters % 25d% 25d\n",
+ num_parameters,
+ num_parameters_reduced);
if (num_effective_parameters_reduced != num_parameters_reduced) {
- StringAppendF(&report, "Effective parameters% 25d% 25d\n",
- num_effective_parameters, num_effective_parameters_reduced);
+ StringAppendF(&report,
+ "Effective parameters% 25d% 25d\n",
+ num_effective_parameters,
+ num_effective_parameters_reduced);
}
- StringAppendF(&report, "Residual blocks % 25d% 25d\n",
- num_residual_blocks, num_residual_blocks_reduced);
- StringAppendF(&report, "Residuals % 25d% 25d\n",
- num_residuals, num_residuals_reduced);
+ StringAppendF(&report,
+ "Residual blocks % 25d% 25d\n",
+ num_residual_blocks,
+ num_residual_blocks_reduced);
+ StringAppendF(&report,
+ "Residuals % 25d% 25d\n",
+ num_residuals,
+ num_residuals_reduced);
if (minimizer_type == TRUST_REGION) {
// TRUST_SEARCH HEADER
- StringAppendF(&report, "\nMinimizer %19s\n",
- "TRUST_REGION");
+ StringAppendF(
+ &report, "\nMinimizer %19s\n", "TRUST_REGION");
if (linear_solver_type_used == DENSE_NORMAL_CHOLESKY ||
linear_solver_type_used == DENSE_SCHUR ||
linear_solver_type_used == DENSE_QR) {
- StringAppendF(&report, "\nDense linear algebra library %15s\n",
+ StringAppendF(&report,
+ "\nDense linear algebra library %15s\n",
DenseLinearAlgebraLibraryTypeToString(
dense_linear_algebra_library_type));
}
@@ -643,14 +666,15 @@
(linear_solver_type_used == ITERATIVE_SCHUR &&
(preconditioner_type_used == CLUSTER_JACOBI ||
preconditioner_type_used == CLUSTER_TRIDIAGONAL))) {
- StringAppendF(&report, "\nSparse linear algebra library %15s\n",
+ StringAppendF(&report,
+ "\nSparse linear algebra library %15s\n",
SparseLinearAlgebraLibraryTypeToString(
sparse_linear_algebra_library_type));
}
- StringAppendF(&report, "Trust region strategy %19s",
- TrustRegionStrategyTypeToString(
- trust_region_strategy_type));
+ StringAppendF(&report,
+ "Trust region strategy %19s",
+ TrustRegionStrategyTypeToString(trust_region_strategy_type));
if (trust_region_strategy_type == DOGLEG) {
if (dogleg_type == TRADITIONAL_DOGLEG) {
StringAppendF(&report, " (TRADITIONAL)");
@@ -661,28 +685,32 @@
StringAppendF(&report, "\n");
StringAppendF(&report, "\n");
- StringAppendF(&report, "%45s %21s\n", "Given", "Used");
- StringAppendF(&report, "Linear solver %25s%25s\n",
+ StringAppendF(&report, "%45s %21s\n", "Given", "Used");
+ StringAppendF(&report,
+ "Linear solver %25s%25s\n",
LinearSolverTypeToString(linear_solver_type_given),
LinearSolverTypeToString(linear_solver_type_used));
if (linear_solver_type_given == CGNR ||
linear_solver_type_given == ITERATIVE_SCHUR) {
- StringAppendF(&report, "Preconditioner %25s%25s\n",
+ StringAppendF(&report,
+ "Preconditioner %25s%25s\n",
PreconditionerTypeToString(preconditioner_type_given),
PreconditionerTypeToString(preconditioner_type_used));
}
if (preconditioner_type_used == CLUSTER_JACOBI ||
preconditioner_type_used == CLUSTER_TRIDIAGONAL) {
- StringAppendF(&report, "Visibility clustering%24s%25s\n",
- VisibilityClusteringTypeToString(
- visibility_clustering_type),
- VisibilityClusteringTypeToString(
- visibility_clustering_type));
+ StringAppendF(
+ &report,
+ "Visibility clustering%24s%25s\n",
+ VisibilityClusteringTypeToString(visibility_clustering_type),
+ VisibilityClusteringTypeToString(visibility_clustering_type));
}
- StringAppendF(&report, "Threads % 25d% 25d\n",
- num_threads_given, num_threads_used);
+ StringAppendF(&report,
+ "Threads % 25d% 25d\n",
+ num_threads_given,
+ num_threads_used);
string given;
StringifyOrdering(linear_solver_ordering_given, &given);
@@ -711,68 +739,71 @@
StringifyOrdering(inner_iteration_ordering_given, &given);
string used;
StringifyOrdering(inner_iteration_ordering_used, &used);
- StringAppendF(&report,
- "Inner iteration ordering %20s %24s\n",
- given.c_str(),
- used.c_str());
+ StringAppendF(&report,
+ "Inner iteration ordering %20s %24s\n",
+ given.c_str(),
+ used.c_str());
}
} else {
// LINE_SEARCH HEADER
StringAppendF(&report, "\nMinimizer %19s\n", "LINE_SEARCH");
-
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) {
- line_search_direction_string =
- NonlinearConjugateGradientTypeToString(
- nonlinear_conjugate_gradient_type);
+ line_search_direction_string = NonlinearConjugateGradientTypeToString(
+ nonlinear_conjugate_gradient_type);
} else {
line_search_direction_string =
LineSearchDirectionTypeToString(line_search_direction_type);
}
- StringAppendF(&report, "Line search direction %19s\n",
+ StringAppendF(&report,
+ "Line search direction %19s\n",
line_search_direction_string.c_str());
- const string line_search_type_string =
- StringPrintf("%s %s",
- LineSearchInterpolationTypeToString(
- line_search_interpolation_type),
- LineSearchTypeToString(line_search_type));
- StringAppendF(&report, "Line search type %19s\n",
+ const string line_search_type_string = StringPrintf(
+ "%s %s",
+ LineSearchInterpolationTypeToString(line_search_interpolation_type),
+ LineSearchTypeToString(line_search_type));
+ StringAppendF(&report,
+ "Line search type %19s\n",
line_search_type_string.c_str());
StringAppendF(&report, "\n");
- StringAppendF(&report, "%45s %21s\n", "Given", "Used");
- StringAppendF(&report, "Threads % 25d% 25d\n",
- num_threads_given, num_threads_used);
+ StringAppendF(&report, "%45s %21s\n", "Given", "Used");
+ StringAppendF(&report,
+ "Threads % 25d% 25d\n",
+ num_threads_given,
+ num_threads_used);
}
StringAppendF(&report, "\nCost:\n");
StringAppendF(&report, "Initial % 30e\n", initial_cost);
- if (termination_type != FAILURE &&
- termination_type != USER_FAILURE) {
+ if (termination_type != FAILURE && termination_type != USER_FAILURE) {
StringAppendF(&report, "Final % 30e\n", final_cost);
- StringAppendF(&report, "Change % 30e\n",
- initial_cost - final_cost);
+ StringAppendF(&report, "Change % 30e\n", initial_cost - final_cost);
}
- StringAppendF(&report, "\nMinimizer iterations % 16d\n",
+ StringAppendF(&report,
+ "\nMinimizer iterations % 16d\n",
num_successful_steps + num_unsuccessful_steps);
// Successful/Unsuccessful steps only matter in the case of the
// trust region solver. Line search terminates when it encounters
// the first unsuccessful step.
if (minimizer_type == TRUST_REGION) {
- StringAppendF(&report, "Successful steps % 14d\n",
+ StringAppendF(&report,
+ "Successful steps % 14d\n",
num_successful_steps);
- StringAppendF(&report, "Unsuccessful steps % 14d\n",
+ StringAppendF(&report,
+ "Unsuccessful steps % 14d\n",
num_unsuccessful_steps);
}
if (inner_iterations_used) {
- StringAppendF(&report, "Steps with inner iterations % 14d\n",
+ StringAppendF(&report,
+ "Steps with inner iterations % 14d\n",
num_inner_iteration_steps);
}
@@ -781,53 +812,66 @@
(minimizer_type == TRUST_REGION && is_constrained));
if (line_search_used) {
- StringAppendF(&report, "Line search steps % 14d\n",
+ StringAppendF(&report,
+ "Line search steps % 14d\n",
num_line_search_steps);
}
StringAppendF(&report, "\nTime (in seconds):\n");
- StringAppendF(&report, "Preprocessor %25.6f\n",
- preprocessor_time_in_seconds);
+ StringAppendF(
+ &report, "Preprocessor %25.6f\n", preprocessor_time_in_seconds);
- StringAppendF(&report, "\n Residual only evaluation %18.6f (%d)\n",
- residual_evaluation_time_in_seconds, num_residual_evaluations);
+ StringAppendF(&report,
+ "\n Residual only evaluation %18.6f (%d)\n",
+ residual_evaluation_time_in_seconds,
+ num_residual_evaluations);
if (line_search_used) {
- StringAppendF(&report, " Line search cost evaluation %10.6f\n",
+ StringAppendF(&report,
+ " Line search cost evaluation %10.6f\n",
line_search_cost_evaluation_time_in_seconds);
}
- StringAppendF(&report, " Jacobian & residual evaluation %12.6f (%d)\n",
- jacobian_evaluation_time_in_seconds, num_jacobian_evaluations);
+ StringAppendF(&report,
+ " Jacobian & residual evaluation %12.6f (%d)\n",
+ jacobian_evaluation_time_in_seconds,
+ num_jacobian_evaluations);
if (line_search_used) {
- StringAppendF(&report, " Line search gradient evaluation %6.6f\n",
+ StringAppendF(&report,
+ " Line search gradient evaluation %6.6f\n",
line_search_gradient_evaluation_time_in_seconds);
}
if (minimizer_type == TRUST_REGION) {
- StringAppendF(&report, " Linear solver %23.6f (%d)\n",
- linear_solver_time_in_seconds, num_linear_solves);
+ StringAppendF(&report,
+ " Linear solver %23.6f (%d)\n",
+ linear_solver_time_in_seconds,
+ num_linear_solves);
}
if (inner_iterations_used) {
- StringAppendF(&report, " Inner iterations %23.6f\n",
+ StringAppendF(&report,
+ " Inner iterations %23.6f\n",
inner_iteration_time_in_seconds);
}
if (line_search_used) {
- StringAppendF(&report, " Line search polynomial minimization %.6f\n",
+ StringAppendF(&report,
+ " Line search polynomial minimization %.6f\n",
line_search_polynomial_minimization_time_in_seconds);
}
- StringAppendF(&report, "Minimizer %25.6f\n\n",
- minimizer_time_in_seconds);
+ StringAppendF(
+ &report, "Minimizer %25.6f\n\n", minimizer_time_in_seconds);
- StringAppendF(&report, "Postprocessor %24.6f\n",
- postprocessor_time_in_seconds);
+ StringAppendF(
+ &report, "Postprocessor %24.6f\n", postprocessor_time_in_seconds);
- StringAppendF(&report, "Total %25.6f\n\n",
- total_time_in_seconds);
+ StringAppendF(
+ &report, "Total %25.6f\n\n", total_time_in_seconds);
- StringAppendF(&report, "Termination: %25s (%s)\n",
- TerminationTypeToString(termination_type), message.c_str());
+ StringAppendF(&report,
+ "Termination: %25s (%s)\n",
+ TerminationTypeToString(termination_type),
+ message.c_str());
return report;
}
diff --git a/internal/ceres/solver_utils.cc b/internal/ceres/solver_utils.cc
index 177a928..b6faa2a 100644
--- a/internal/ceres/solver_utils.cc
+++ b/internal/ceres/solver_utils.cc
@@ -28,22 +28,22 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/solver_utils.h"
+
#include <string>
-#include "ceres/internal/config.h"
-
#include "Eigen/Core"
+#include "ceres/internal/config.h"
#include "ceres/internal/port.h"
-#include "ceres/solver_utils.h"
#include "ceres/version.h"
namespace ceres {
namespace internal {
-#define CERES_EIGEN_VERSION \
- CERES_TO_STRING(EIGEN_WORLD_VERSION) "." \
- CERES_TO_STRING(EIGEN_MAJOR_VERSION) "." \
- CERES_TO_STRING(EIGEN_MINOR_VERSION)
+#define CERES_EIGEN_VERSION \
+ CERES_TO_STRING(EIGEN_WORLD_VERSION) \
+ "." CERES_TO_STRING(EIGEN_MAJOR_VERSION) "." CERES_TO_STRING( \
+ EIGEN_MINOR_VERSION)
std::string VersionString() {
std::string value = std::string(CERES_VERSION_STRING);
diff --git a/internal/ceres/sparse_cholesky.cc b/internal/ceres/sparse_cholesky.cc
index 0639ea9..91cdf67 100644
--- a/internal/ceres/sparse_cholesky.cc
+++ b/internal/ceres/sparse_cholesky.cc
@@ -89,7 +89,8 @@
if (options.use_mixed_precision_solves) {
sparse_cholesky = AppleAccelerateCholesky<float>::Create(ordering_type);
} else {
- sparse_cholesky = AppleAccelerateCholesky<double>::Create(ordering_type);
+ sparse_cholesky =
+ AppleAccelerateCholesky<double>::Create(ordering_type);
}
break;
#else
diff --git a/internal/ceres/sparse_cholesky.h b/internal/ceres/sparse_cholesky.h
index bbe4237..9be98bd 100644
--- a/internal/ceres/sparse_cholesky.h
+++ b/internal/ceres/sparse_cholesky.h
@@ -32,9 +32,12 @@
#define CERES_INTERNAL_SPARSE_CHOLESKY_H_
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
#include <memory>
+
#include "ceres/linear_solver.h"
#include "glog/logging.h"
@@ -88,8 +91,8 @@
// Subsequent calls to Factorize will use that symbolic
// factorization assuming that the sparsity of the matrix has
// remained constant.
- virtual LinearSolverTerminationType Factorize(
- CompressedRowSparseMatrix* lhs, std::string* message) = 0;
+ virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+ std::string* message) = 0;
// Computes the solution to the equation
//
@@ -106,7 +109,6 @@
const double* rhs,
double* solution,
std::string* message);
-
};
class IterativeRefiner;
@@ -120,8 +122,8 @@
virtual ~RefinedSparseCholesky();
virtual CompressedRowSparseMatrix::StorageType StorageType() const;
- virtual LinearSolverTerminationType Factorize(
- CompressedRowSparseMatrix* lhs, std::string* message);
+ virtual LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+ std::string* message);
virtual LinearSolverTerminationType Solve(const double* rhs,
double* solution,
std::string* message);
diff --git a/internal/ceres/sparse_matrix.cc b/internal/ceres/sparse_matrix.cc
index f95ff32..32388f5 100644
--- a/internal/ceres/sparse_matrix.cc
+++ b/internal/ceres/sparse_matrix.cc
@@ -33,8 +33,7 @@
namespace ceres {
namespace internal {
-SparseMatrix::~SparseMatrix() {
-}
+SparseMatrix::~SparseMatrix() {}
} // namespace internal
} // namespace ceres
diff --git a/internal/ceres/sparse_matrix.h b/internal/ceres/sparse_matrix.h
index 074d847..b8a3918 100644
--- a/internal/ceres/sparse_matrix.h
+++ b/internal/ceres/sparse_matrix.h
@@ -34,8 +34,9 @@
#define CERES_INTERNAL_SPARSE_MATRIX_H_
#include <cstdio>
-#include "ceres/linear_operator.h"
+
#include "ceres/internal/eigen.h"
+#include "ceres/linear_operator.h"
#include "ceres/types.h"
namespace ceres {
diff --git a/internal/ceres/sparse_normal_cholesky_solver.h b/internal/ceres/sparse_normal_cholesky_solver.h
index cbff2bd..ef32743 100644
--- a/internal/ceres/sparse_normal_cholesky_solver.h
+++ b/internal/ceres/sparse_normal_cholesky_solver.h
@@ -35,9 +35,12 @@
#define CERES_INTERNAL_SPARSE_NORMAL_CHOLESKY_SOLVER_H_
// This include must come before any #ifndef check on Ceres compile options.
+// clang-format off
#include "ceres/internal/port.h"
+// clang-format on
#include <vector>
+
#include "ceres/linear_solver.h"
namespace ceres {
@@ -58,11 +61,10 @@
virtual ~SparseNormalCholeskySolver();
private:
- LinearSolver::Summary SolveImpl(
- BlockSparseMatrix* A,
- const double* b,
- const LinearSolver::PerSolveOptions& options,
- double* x) final;
+ LinearSolver::Summary SolveImpl(BlockSparseMatrix* A,
+ const double* b,
+ const LinearSolver::PerSolveOptions& options,
+ double* x) final;
const LinearSolver::Options options_;
Vector rhs_;
diff --git a/internal/ceres/sparse_normal_cholesky_solver_test.cc b/internal/ceres/sparse_normal_cholesky_solver_test.cc
index 10f898b..8acb98e 100644
--- a/internal/ceres/sparse_normal_cholesky_solver_test.cc
+++ b/internal/ceres/sparse_normal_cholesky_solver_test.cc
@@ -29,6 +29,8 @@
// Author: sameeragarwal@google.com (Sameer Agarwal)
#include <memory>
+
+#include "Eigen/Cholesky"
#include "ceres/block_sparse_matrix.h"
#include "ceres/casts.h"
#include "ceres/context_impl.h"
@@ -39,8 +41,6 @@
#include "glog/logging.h"
#include "gtest/gtest.h"
-#include "Eigen/Cholesky"
-
namespace ceres {
namespace internal {
diff --git a/internal/ceres/split.cc b/internal/ceres/split.cc
index 3a09e86..804f441 100644
--- a/internal/ceres/split.cc
+++ b/internal/ceres/split.cc
@@ -75,10 +75,9 @@
}
template <typename StringType, typename ITR>
-static inline
-void SplitStringToIteratorUsing(const StringType& full,
- const char* delim,
- ITR& result) {
+static inline void SplitStringToIteratorUsing(const StringType& full,
+ const char* delim,
+ ITR& result) {
// Optimize the common case where delim is a single character.
if (delim[0] != '\0' && delim[1] == '\0') {
char c = delim[0];
diff --git a/internal/ceres/split.h b/internal/ceres/split.h
index 94b773d..f513023 100644
--- a/internal/ceres/split.h
+++ b/internal/ceres/split.h
@@ -33,6 +33,7 @@
#include <string>
#include <vector>
+
#include "ceres/internal/port.h"
namespace ceres {
@@ -41,7 +42,8 @@
// Split a string using one or more character delimiters, presented as a
// nul-terminated c string. Append the components to 'result'. If there are
// consecutive delimiters, this function skips over all of them.
-void SplitStringUsing(const std::string& full, const char* delim,
+void SplitStringUsing(const std::string& full,
+ const char* delim,
std::vector<std::string>* res);
} // namespace internal
diff --git a/internal/ceres/stl_util.h b/internal/ceres/stl_util.h
index 0595a4c..d3411b7 100644
--- a/internal/ceres/stl_util.h
+++ b/internal/ceres/stl_util.h
@@ -46,8 +46,7 @@
// advanced, which could result in the hash function trying to deference a
// stale pointer.
template <class ForwardIterator>
-void STLDeleteContainerPointers(ForwardIterator begin,
- ForwardIterator end) {
+void STLDeleteContainerPointers(ForwardIterator begin, ForwardIterator end) {
while (begin != end) {
ForwardIterator temp = begin;
++begin;
@@ -80,7 +79,7 @@
// ElementDeleter (defined below), which ensures that your container's elements
// are deleted when the ElementDeleter goes out of scope.
template <class T>
-void STLDeleteElements(T *container) {
+void STLDeleteElements(T* container) {
if (!container) return;
STLDeleteContainerPointers(container->begin(), container->end());
container->clear();
diff --git a/internal/ceres/stringprintf.cc b/internal/ceres/stringprintf.cc
index 7a21f0e..b0e2acc 100644
--- a/internal/ceres/stringprintf.cc
+++ b/internal/ceres/stringprintf.cc
@@ -62,7 +62,7 @@
return;
}
-#if defined (_MSC_VER)
+#if defined(_MSC_VER)
// Error or MSVC running out of space. MSVC 8.0 and higher
// can be asked about space needed with the special idiom below:
va_copy(backup_ap, ap);
@@ -78,7 +78,7 @@
// Increase the buffer size to the size requested by vsnprintf,
// plus one for the closing \0.
- int length = result+1;
+ int length = result + 1;
char* buf = new char[length];
// Restore the va_list before we use it again
@@ -93,7 +93,6 @@
delete[] buf;
}
-
string StringPrintf(const char* format, ...) {
va_list ap;
va_start(ap, format);
diff --git a/internal/ceres/stringprintf.h b/internal/ceres/stringprintf.h
index feeb9c2..98e98cd 100644
--- a/internal/ceres/stringprintf.h
+++ b/internal/ceres/stringprintf.h
@@ -55,9 +55,9 @@
// have an implicit 'this' argument, the arguments of such methods
// should be counted from two, not one."
#define CERES_PRINTF_ATTRIBUTE(string_index, first_to_check) \
- __attribute__((__format__ (__printf__, string_index, first_to_check)))
+ __attribute__((__format__(__printf__, string_index, first_to_check)))
#define CERES_SCANF_ATTRIBUTE(string_index, first_to_check) \
- __attribute__((__format__ (__scanf__, string_index, first_to_check)))
+ __attribute__((__format__(__scanf__, string_index, first_to_check)))
#else
#define CERES_PRINTF_ATTRIBUTE(string_index, first_to_check)
#endif
@@ -68,7 +68,9 @@
CERES_PRINTF_ATTRIBUTE(1, 2);
// Store result into a supplied string and return it.
-extern const std::string& SStringPrintf(std::string* dst, const char* format, ...)
+extern const std::string& SStringPrintf(std::string* dst,
+ const char* format,
+ ...)
// Tell the compiler to do printf format string checking.
CERES_PRINTF_ATTRIBUTE(2, 3);
diff --git a/internal/ceres/subset_preconditioner.cc b/internal/ceres/subset_preconditioner.cc
index 7c24ae9..779a34a 100644
--- a/internal/ceres/subset_preconditioner.cc
+++ b/internal/ceres/subset_preconditioner.cc
@@ -32,6 +32,7 @@
#include <memory>
#include <string>
+
#include "ceres/compressed_row_sparse_matrix.h"
#include "ceres/inner_product_computer.h"
#include "ceres/linear_solver.h"
@@ -50,8 +51,7 @@
LinearSolver::Options sparse_cholesky_options;
sparse_cholesky_options.sparse_linear_algebra_library_type =
options_.sparse_linear_algebra_library_type;
- sparse_cholesky_options.use_postordering =
- options_.use_postordering;
+ sparse_cholesky_options.use_postordering = options_.use_postordering;
sparse_cholesky_ = SparseCholesky::Create(sparse_cholesky_options);
}
diff --git a/internal/ceres/subset_preconditioner.h b/internal/ceres/subset_preconditioner.h
index 6f3c9ec..f83153c 100644
--- a/internal/ceres/subset_preconditioner.h
+++ b/internal/ceres/subset_preconditioner.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_SUBSET_PRECONDITIONER_H_
#include <memory>
+
#include "ceres/preconditioner.h"
namespace ceres {
diff --git a/internal/ceres/subset_preconditioner_test.cc b/internal/ceres/subset_preconditioner_test.cc
index ec0ea9a..202110b 100644
--- a/internal/ceres/subset_preconditioner_test.cc
+++ b/internal/ceres/subset_preconditioner_test.cc
@@ -31,6 +31,7 @@
#include "ceres/subset_preconditioner.h"
#include <memory>
+
#include "Eigen/Dense"
#include "Eigen/SparseCore"
#include "ceres/block_sparse_matrix.h"
diff --git a/internal/ceres/suitesparse.cc b/internal/ceres/suitesparse.cc
index 190d175..0d6f6bd 100644
--- a/internal/ceres/suitesparse.cc
+++ b/internal/ceres/suitesparse.cc
@@ -32,13 +32,12 @@
#include "ceres/internal/port.h"
#ifndef CERES_NO_SUITESPARSE
-#include "ceres/suitesparse.h"
-
#include <vector>
#include "ceres/compressed_col_sparse_matrix_utils.h"
#include "ceres/compressed_row_sparse_matrix.h"
#include "ceres/linear_solver.h"
+#include "ceres/suitesparse.h"
#include "ceres/triplet_sparse_matrix.h"
#include "cholmod.h"
@@ -353,7 +352,8 @@
std::unique_ptr<SparseCholesky> SuiteSparseCholesky::Create(
const OrderingType ordering_type) {
- return std::unique_ptr<SparseCholesky>(new SuiteSparseCholesky(ordering_type));
+ return std::unique_ptr<SparseCholesky>(
+ new SuiteSparseCholesky(ordering_type));
}
SuiteSparseCholesky::SuiteSparseCholesky(const OrderingType ordering_type)
diff --git a/internal/ceres/suitesparse.h b/internal/ceres/suitesparse.h
index b77b296..5dcc53f 100644
--- a/internal/ceres/suitesparse.h
+++ b/internal/ceres/suitesparse.h
@@ -41,6 +41,7 @@
#include <cstring>
#include <string>
#include <vector>
+
#include "SuiteSparseQR.hpp"
#include "ceres/linear_solver.h"
#include "ceres/sparse_cholesky.h"
@@ -116,20 +117,23 @@
// for symmetric scaling which scales both the rows and the columns
// - diag(scale) * A * diag(scale).
void Scale(cholmod_dense* scale, int mode, cholmod_sparse* A) {
- cholmod_scale(scale, mode, A, &cc_);
+ cholmod_scale(scale, mode, A, &cc_);
}
// Create and return a matrix m = A * A'. Caller owns the
// result. The matrix A is not modified.
cholmod_sparse* AATranspose(cholmod_sparse* A) {
- cholmod_sparse*m = cholmod_aat(A, NULL, A->nrow, 1, &cc_);
+ cholmod_sparse* m = cholmod_aat(A, NULL, A->nrow, 1, &cc_);
m->stype = 1; // Pay attention to the upper triangular part.
return m;
}
// y = alpha * A * x + beta * y. Only y is modified.
- void SparseDenseMultiply(cholmod_sparse* A, double alpha, double beta,
- cholmod_dense* x, cholmod_dense* y) {
+ void SparseDenseMultiply(cholmod_sparse* A,
+ double alpha,
+ double beta,
+ cholmod_dense* x,
+ cholmod_dense* y) {
double alpha_[2] = {alpha, 0};
double beta_[2] = {beta, 0};
cholmod_sdmult(A, 0, alpha_, beta_, x, y, &cc_);
@@ -195,7 +199,9 @@
// NULL is returned. Caller owns the result.
//
// message contains an explanation of the failures if any.
- cholmod_dense* Solve(cholmod_factor* L, cholmod_dense* b, std::string* message);
+ cholmod_dense* Solve(cholmod_factor* L,
+ cholmod_dense* b,
+ std::string* message);
// By virtue of the modeling layer in Ceres being block oriented,
// all the matrices used by Ceres are also block oriented. When
@@ -229,7 +235,6 @@
// ordering.
bool ApproximateMinimumDegreeOrdering(cholmod_sparse* matrix, int* ordering);
-
// Before SuiteSparse version 4.2.0, cholmod_camd was only enabled
// if SuiteSparse was compiled with Metis support. This makes
// calling and linking into cholmod_camd problematic even though it
@@ -262,7 +267,7 @@
int* ordering);
void Free(cholmod_sparse* m) { cholmod_free_sparse(&m, &cc_); }
- void Free(cholmod_dense* m) { cholmod_free_dense(&m, &cc_); }
+ void Free(cholmod_dense* m) { cholmod_free_dense(&m, &cc_); }
void Free(cholmod_factor* m) { cholmod_free_factor(&m, &cc_); }
void Print(cholmod_sparse* m, const std::string& name) {
@@ -285,17 +290,17 @@
class SuiteSparseCholesky : public SparseCholesky {
public:
- static std::unique_ptr<SparseCholesky> Create(
- OrderingType ordering_type);
+ static std::unique_ptr<SparseCholesky> Create(OrderingType ordering_type);
// SparseCholesky interface.
virtual ~SuiteSparseCholesky();
CompressedRowSparseMatrix::StorageType StorageType() const final;
- LinearSolverTerminationType Factorize(
- CompressedRowSparseMatrix* lhs, std::string* message) final;
+ LinearSolverTerminationType Factorize(CompressedRowSparseMatrix* lhs,
+ std::string* message) final;
LinearSolverTerminationType Solve(const double* rhs,
double* solution,
std::string* message) final;
+
private:
SuiteSparseCholesky(const OrderingType ordering_type);
diff --git a/internal/ceres/system_test.cc b/internal/ceres/system_test.cc
index 3f635d0..429973f 100644
--- a/internal/ceres/system_test.cc
+++ b/internal/ceres/system_test.cc
@@ -64,10 +64,10 @@
class PowellsFunction {
public:
PowellsFunction() {
- x_[0] = 3.0;
+ x_[0] = 3.0;
x_[1] = -1.0;
- x_[2] = 0.0;
- x_[3] = 1.0;
+ x_[2] = 0.0;
+ x_[3] = 1.0;
problem_.AddResidualBlock(
new AutoDiffCostFunction<F1, 1, 1, 1>(new F1), NULL, &x_[0], &x_[1]);
@@ -94,9 +94,8 @@
// functions.
class F1 {
public:
- template <typename T> bool operator()(const T* const x1,
- const T* const x2,
- T* residual) const {
+ template <typename T>
+ bool operator()(const T* const x1, const T* const x2, T* residual) const {
// f1 = x1 + 10 * x2;
*residual = *x1 + 10.0 * *x2;
return true;
@@ -105,9 +104,8 @@
class F2 {
public:
- template <typename T> bool operator()(const T* const x3,
- const T* const x4,
- T* residual) const {
+ template <typename T>
+ bool operator()(const T* const x3, const T* const x4, T* residual) const {
// f2 = sqrt(5) (x3 - x4)
*residual = sqrt(5.0) * (*x3 - *x4);
return true;
@@ -116,9 +114,8 @@
class F3 {
public:
- template <typename T> bool operator()(const T* const x2,
- const T* const x4,
- T* residual) const {
+ template <typename T>
+ bool operator()(const T* const x2, const T* const x4, T* residual) const {
// f3 = (x2 - 2 x3)^2
residual[0] = (x2[0] - 2.0 * x4[0]) * (x2[0] - 2.0 * x4[0]);
return true;
@@ -127,9 +124,8 @@
class F4 {
public:
- template <typename T> bool operator()(const T* const x1,
- const T* const x4,
- T* residual) const {
+ template <typename T>
+ bool operator()(const T* const x1, const T* const x4, T* residual) const {
// f4 = sqrt(10) (x1 - x4)^2
residual[0] = sqrt(10.0) * (x1[0] - x4[0]) * (x1[0] - x4[0]);
return true;
diff --git a/internal/ceres/thread_pool.cc b/internal/ceres/thread_pool.cc
index 5a52c9d..821431c 100644
--- a/internal/ceres/thread_pool.cc
+++ b/internal/ceres/thread_pool.cc
@@ -33,11 +33,11 @@
#ifdef CERES_USE_CXX_THREADS
-#include "ceres/thread_pool.h"
-
#include <cmath>
#include <limits>
+#include "ceres/thread_pool.h"
+
namespace ceres {
namespace internal {
namespace {
@@ -53,16 +53,13 @@
const int num_hardware_threads = std::thread::hardware_concurrency();
// hardware_concurrency() can return 0 if the value is not well defined or not
// computable.
- return num_hardware_threads == 0
- ? std::numeric_limits<int>::max()
- : num_hardware_threads;
+ return num_hardware_threads == 0 ? std::numeric_limits<int>::max()
+ : num_hardware_threads;
}
-ThreadPool::ThreadPool() { }
+ThreadPool::ThreadPool() {}
-ThreadPool::ThreadPool(int num_threads) {
- Resize(num_threads);
-}
+ThreadPool::ThreadPool(int num_threads) { Resize(num_threads); }
ThreadPool::~ThreadPool() {
std::lock_guard<std::mutex> lock(thread_pool_mutex_);
@@ -106,11 +103,9 @@
}
}
-void ThreadPool::Stop() {
- task_queue_.StopWaiters();
-}
+void ThreadPool::Stop() { task_queue_.StopWaiters(); }
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_pool_test.cc b/internal/ceres/thread_pool_test.cc
index 48ba9d1..e39f673 100644
--- a/internal/ceres/thread_pool_test.cc
+++ b/internal/ceres/thread_pool_test.cc
@@ -33,16 +33,15 @@
#ifdef CERES_USE_CXX_THREADS
-#include "ceres/thread_pool.h"
-
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <thread>
+#include "ceres/thread_pool.h"
+#include "glog/logging.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
-#include "glog/logging.h"
namespace ceres {
namespace internal {
@@ -59,14 +58,14 @@
for (int i = 0; i < num_tasks; ++i) {
thread_pool.AddTask([&]() {
- std::lock_guard<std::mutex> lock(mutex);
- ++value;
- condition.notify_all();
- });
+ std::lock_guard<std::mutex> lock(mutex);
+ ++value;
+ condition.notify_all();
+ });
}
std::unique_lock<std::mutex> lock(mutex);
- condition.wait(lock, [&](){return value == num_tasks;});
+ condition.wait(lock, [&]() { return value == num_tasks; });
}
EXPECT_EQ(num_tasks, value);
@@ -116,7 +115,7 @@
// Unlock the mutex to unblock all of the threads and wait until all of the
// tasks are completed.
- condition.wait(lock, [&](){return value == num_tasks;});
+ condition.wait(lock, [&]() { return value == num_tasks; });
}
EXPECT_EQ(num_tasks, value);
@@ -197,4 +196,4 @@
} // namespace internal
} // namespace ceres
-#endif // CERES_USE_CXX_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_token_provider.cc b/internal/ceres/thread_token_provider.cc
index b04cf84..c7ec67f 100644
--- a/internal/ceres/thread_token_provider.cc
+++ b/internal/ceres/thread_token_provider.cc
@@ -44,7 +44,6 @@
pool_.Push(i);
}
#endif
-
}
int ThreadTokenProvider::Acquire() {
@@ -61,7 +60,6 @@
CHECK(pool_.Wait(&thread_id));
return thread_id;
#endif
-
}
void ThreadTokenProvider::Release(int thread_id) {
@@ -69,7 +67,6 @@
#ifdef CERES_USE_CXX_THREADS
pool_.Push(thread_id);
#endif
-
}
} // namespace internal
diff --git a/internal/ceres/tiny_solver_autodiff_function_test.cc b/internal/ceres/tiny_solver_autodiff_function_test.cc
index 90033fc..2598188 100644
--- a/internal/ceres/tiny_solver_autodiff_function_test.cc
+++ b/internal/ceres/tiny_solver_autodiff_function_test.cc
@@ -30,27 +30,27 @@
// Author: mierle@gmail.com (Keir Mierle)
#include "ceres/tiny_solver_autodiff_function.h"
-#include "ceres/tiny_solver.h"
-#include "ceres/tiny_solver_test_util.h"
#include <algorithm>
#include <cmath>
#include <limits>
+#include "ceres/tiny_solver.h"
+#include "ceres/tiny_solver_test_util.h"
#include "gtest/gtest.h"
namespace ceres {
struct AutoDiffTestFunctor {
- template<typename T>
+ template <typename T>
bool operator()(const T* const parameters, T* residuals) const {
// Shift the parameters so the solution is not at the origin, to prevent
// accidentally showing "PASS".
const T& a = parameters[0] - T(1.0);
const T& b = parameters[1] - T(2.0);
const T& c = parameters[2] - T(3.0);
- residuals[0] = 2.*a + 0.*b + 1.*c;
- residuals[1] = 0.*a + 4.*b + 6.*c;
+ residuals[0] = 2. * a + 0. * b + 1. * c;
+ residuals[1] = 0. * a + 4. * b + 6. * c;
return true;
}
};
@@ -103,11 +103,9 @@
NUM_PARAMETERS = 3,
};
- int NumResiduals() const {
- return 2;
- }
+ int NumResiduals() const { return 2; }
- template<typename T>
+ template <typename T>
bool operator()(const T* parameters, T* residuals) const {
// Jacobian is not evaluated by cost function, but by autodiff.
T* jacobian = nullptr;
@@ -115,7 +113,7 @@
}
};
-template<typename Function, typename Vector>
+template <typename Function, typename Vector>
void TestHelper(const Function& f, const Vector& x0) {
Vector x = x0;
Eigen::Vector2d residuals;
@@ -133,10 +131,8 @@
Eigen::Vector3d x0(0.76026643, -30.01799744, 0.55192142);
DynamicResidualsFunctor f;
- using AutoDiffCostFunctor =
- ceres::TinySolverAutoDiffFunction<DynamicResidualsFunctor,
- Eigen::Dynamic,
- 3>;
+ using AutoDiffCostFunctor = ceres::
+ TinySolverAutoDiffFunction<DynamicResidualsFunctor, Eigen::Dynamic, 3>;
AutoDiffCostFunctor f_autodiff(f);
Eigen::Vector2d residuals;
diff --git a/internal/ceres/tiny_solver_cost_function_adapter_test.cc b/internal/ceres/tiny_solver_cost_function_adapter_test.cc
index 13ad406..6f57193 100644
--- a/internal/ceres/tiny_solver_cost_function_adapter_test.cc
+++ b/internal/ceres/tiny_solver_cost_function_adapter_test.cc
@@ -40,7 +40,7 @@
namespace ceres {
-class CostFunction2x3 : public SizedCostFunction<2,3> {
+class CostFunction2x3 : public SizedCostFunction<2, 3> {
bool Evaluate(double const* const* parameters,
double* residuals,
double** jacobians) const final {
@@ -48,7 +48,7 @@
double y = parameters[0][1];
double z = parameters[0][2];
- residuals[0] = x + 2*y + 4*z;
+ residuals[0] = x + 2 * y + 4 * z;
residuals[1] = y * z;
if (jacobians && jacobians[0]) {
@@ -65,10 +65,11 @@
}
};
-template<int kNumResiduals, int kNumParameters>
+template <int kNumResiduals, int kNumParameters>
void TestHelper() {
std::unique_ptr<CostFunction> cost_function(new CostFunction2x3);
- typedef TinySolverCostFunctionAdapter<kNumResiduals, kNumParameters> CostFunctionAdapter;
+ typedef TinySolverCostFunctionAdapter<kNumResiduals, kNumParameters>
+ CostFunctionAdapter;
CostFunctionAdapter cfa(*cost_function);
EXPECT_EQ(CostFunctionAdapter::NUM_RESIDUALS, kNumResiduals);
EXPECT_EQ(CostFunctionAdapter::NUM_PARAMETERS, kNumParameters);
@@ -80,7 +81,7 @@
Eigen::Matrix<double, 2, 3, Eigen::ColMajor> actual_jacobian;
Eigen::Matrix<double, 2, 3, Eigen::RowMajor> expected_jacobian;
- double xyz[3] = { 1.0, -1.0, 2.0};
+ double xyz[3] = {1.0, -1.0, 2.0};
double* parameters[1] = {xyz};
// Check that residual only evaluation works.
diff --git a/internal/ceres/tiny_solver_test.cc b/internal/ceres/tiny_solver_test.cc
index 2a8cd39..2e70694 100644
--- a/internal/ceres/tiny_solver_test.cc
+++ b/internal/ceres/tiny_solver_test.cc
@@ -30,11 +30,11 @@
// Author: mierle@gmail.com (Keir Mierle)
#include "ceres/tiny_solver.h"
-#include "ceres/tiny_solver_test_util.h"
#include <algorithm>
#include <cmath>
+#include "ceres/tiny_solver_test_util.h"
#include "gtest/gtest.h"
namespace ceres {
@@ -66,9 +66,7 @@
NUM_PARAMETERS = Eigen::Dynamic,
};
- int NumParameters() const {
- return 3;
- }
+ int NumParameters() const { return 3; }
bool operator()(const double* parameters,
double* residuals,
@@ -85,9 +83,7 @@
NUM_PARAMETERS = 3,
};
- int NumResiduals() const {
- return 2;
- }
+ int NumResiduals() const { return 2; }
bool operator()(const double* parameters,
double* residuals,
@@ -104,13 +100,9 @@
NUM_PARAMETERS = Eigen::Dynamic,
};
- int NumResiduals() const {
- return 2;
- }
+ int NumResiduals() const { return 2; }
- int NumParameters() const {
- return 3;
- }
+ int NumParameters() const { return 3; }
bool operator()(const double* parameters,
double* residuals,
@@ -119,7 +111,7 @@
}
};
-template<typename Function, typename Vector>
+template <typename Function, typename Vector>
void TestHelper(const Function& f, const Vector& x0) {
Vector x = x0;
Vec2 residuals;
diff --git a/internal/ceres/tiny_solver_test_util.h b/internal/ceres/tiny_solver_test_util.h
index 48fe955..310bb35 100644
--- a/internal/ceres/tiny_solver_test_util.h
+++ b/internal/ceres/tiny_solver_test_util.h
@@ -34,7 +34,7 @@
namespace ceres {
-template<typename T>
+template <typename T>
bool EvaluateResidualsAndJacobians(const T* parameters,
T* residuals,
T* jacobian) {
diff --git a/internal/ceres/triplet_sparse_matrix.cc b/internal/ceres/triplet_sparse_matrix.cc
index 54b588b..5dbf0e7 100644
--- a/internal/ceres/triplet_sparse_matrix.cc
+++ b/internal/ceres/triplet_sparse_matrix.cc
@@ -43,11 +43,7 @@
namespace internal {
TripletSparseMatrix::TripletSparseMatrix()
- : num_rows_(0),
- num_cols_(0),
- max_num_nonzeros_(0),
- num_nonzeros_(0) {}
-
+ : num_rows_(0), num_cols_(0), max_num_nonzeros_(0), num_nonzeros_(0) {}
TripletSparseMatrix::~TripletSparseMatrix() {}
@@ -111,9 +107,11 @@
bool TripletSparseMatrix::AllTripletsWithinBounds() const {
for (int i = 0; i < num_nonzeros_; ++i) {
+ // clang-format off
if ((rows_[i] < 0) || (rows_[i] >= num_rows_) ||
(cols_[i] < 0) || (cols_[i] >= num_cols_))
return false;
+ // clang-format on
}
return true;
}
@@ -123,8 +121,7 @@
<< "Reallocation will cause data loss";
// Nothing to do if we have enough space already.
- if (new_max_num_nonzeros <= max_num_nonzeros_)
- return;
+ if (new_max_num_nonzeros <= max_num_nonzeros_) return;
int* new_rows = new int[new_max_num_nonzeros];
int* new_cols = new int[new_max_num_nonzeros];
@@ -168,15 +165,15 @@
}
}
-void TripletSparseMatrix::RightMultiply(const double* x, double* y) const {
+void TripletSparseMatrix::RightMultiply(const double* x, double* y) const {
for (int i = 0; i < num_nonzeros_; ++i) {
- y[rows_[i]] += values_[i]*x[cols_[i]];
+ y[rows_[i]] += values_[i] * x[cols_[i]];
}
}
void TripletSparseMatrix::LeftMultiply(const double* x, double* y) const {
for (int i = 0; i < num_nonzeros_; ++i) {
- y[cols_[i]] += values_[i]*x[rows_[i]];
+ y[cols_[i]] += values_[i] * x[rows_[i]];
}
}
@@ -226,10 +223,9 @@
num_cols_ = num_cols_ + B.num_cols();
}
-
void TripletSparseMatrix::Resize(int new_num_rows, int new_num_cols) {
if ((new_num_rows >= num_rows_) && (new_num_cols >= num_cols_)) {
- num_rows_ = new_num_rows;
+ num_rows_ = new_num_rows;
num_cols_ = new_num_cols;
return;
}
@@ -245,9 +241,9 @@
for (int i = 0; i < num_nonzeros_; ++i) {
if ((r_ptr[i] < num_rows_) && (c_ptr[i] < num_cols_)) {
if (dropped_terms) {
- r_ptr[i-dropped_terms] = r_ptr[i];
- c_ptr[i-dropped_terms] = c_ptr[i];
- v_ptr[i-dropped_terms] = v_ptr[i];
+ r_ptr[i - dropped_terms] = r_ptr[i];
+ c_ptr[i - dropped_terms] = c_ptr[i];
+ v_ptr[i - dropped_terms] = v_ptr[i];
}
} else {
++dropped_terms;
diff --git a/internal/ceres/triplet_sparse_matrix.h b/internal/ceres/triplet_sparse_matrix.h
index 2ee0fa9..cbda253 100644
--- a/internal/ceres/triplet_sparse_matrix.h
+++ b/internal/ceres/triplet_sparse_matrix.h
@@ -33,8 +33,9 @@
#include <memory>
#include <vector>
-#include "ceres/sparse_matrix.h"
+
#include "ceres/internal/eigen.h"
+#include "ceres/sparse_matrix.h"
#include "ceres/types.h"
namespace ceres {
@@ -68,11 +69,13 @@
void ScaleColumns(const double* scale) final;
void ToDenseMatrix(Matrix* dense_matrix) const final;
void ToTextFile(FILE* file) const final;
+ // clang-format off
int num_rows() const final { return num_rows_; }
int num_cols() const final { return num_cols_; }
int num_nonzeros() const final { return num_nonzeros_; }
const double* values() const final { return values_.get(); }
double* mutable_values() final { return values_.get(); }
+ // clang-format on
void set_num_nonzeros(int num_nonzeros);
// Increase max_num_nonzeros and correspondingly increase the size
@@ -94,11 +97,13 @@
// bounds are dropped and the num_non_zeros changed accordingly.
void Resize(int new_num_rows, int new_num_cols);
+ // clang-format off
int max_num_nonzeros() const { return max_num_nonzeros_; }
const int* rows() const { return rows_.get(); }
const int* cols() const { return cols_.get(); }
int* mutable_rows() { return rows_.get(); }
int* mutable_cols() { return cols_.get(); }
+ // clang-format on
// Returns true if the entries of the matrix obey the row, column,
// and column size bounds and false otherwise.
diff --git a/internal/ceres/triplet_sparse_matrix_test.cc b/internal/ceres/triplet_sparse_matrix_test.cc
index 881fabc..3af634f 100644
--- a/internal/ceres/triplet_sparse_matrix_test.cc
+++ b/internal/ceres/triplet_sparse_matrix_test.cc
@@ -31,6 +31,7 @@
#include "ceres/triplet_sparse_matrix.h"
#include <memory>
+
#include "gtest/gtest.h"
namespace ceres {
@@ -309,15 +310,14 @@
TEST(TripletSparseMatrix, CreateDiagonalMatrix) {
std::unique_ptr<double[]> values(new double[10]);
- for (int i = 0; i < 10; ++i)
- values[i] = i;
+ for (int i = 0; i < 10; ++i) values[i] = i;
std::unique_ptr<TripletSparseMatrix> m(
TripletSparseMatrix::CreateSparseDiagonalMatrix(values.get(), 10));
EXPECT_EQ(m->num_rows(), 10);
EXPECT_EQ(m->num_cols(), 10);
ASSERT_EQ(m->num_nonzeros(), 10);
- for (int i = 0; i < 10 ; ++i) {
+ for (int i = 0; i < 10; ++i) {
EXPECT_EQ(m->rows()[i], i);
EXPECT_EQ(m->cols()[i], i);
EXPECT_EQ(m->values()[i], i);
@@ -331,7 +331,7 @@
for (int j = 0; j < 20; ++j) {
m.mutable_rows()[nnz] = i;
m.mutable_cols()[nnz] = j;
- m.mutable_values()[nnz++] = i+j;
+ m.mutable_values()[nnz++] = i + j;
}
}
m.set_num_nonzeros(nnz);
diff --git a/internal/ceres/trust_region_minimizer.h b/internal/ceres/trust_region_minimizer.h
index b5c4122..e18193c 100644
--- a/internal/ceres/trust_region_minimizer.h
+++ b/internal/ceres/trust_region_minimizer.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_TRUST_REGION_MINIMIZER_H_
#include <memory>
+
#include "ceres/internal/eigen.h"
#include "ceres/minimizer.h"
#include "ceres/solver.h"
diff --git a/internal/ceres/trust_region_minimizer_test.cc b/internal/ceres/trust_region_minimizer_test.cc
index 952f878..8993273 100644
--- a/internal/ceres/trust_region_minimizer_test.cc
+++ b/internal/ceres/trust_region_minimizer_test.cc
@@ -33,7 +33,10 @@
// implementation, rather than having a test that goes through all the
// Program and Problem machinery.
+#include "ceres/trust_region_minimizer.h"
+
#include <cmath>
+
#include "ceres/autodiff_cost_function.h"
#include "ceres/cost_function.h"
#include "ceres/dense_qr_solver.h"
@@ -43,7 +46,6 @@
#include "ceres/linear_solver.h"
#include "ceres/minimizer.h"
#include "ceres/problem.h"
-#include "ceres/trust_region_minimizer.h"
#include "ceres/trust_region_strategy.h"
#include "gtest/gtest.h"
@@ -59,6 +61,7 @@
template <bool col1, bool col2, bool col3, bool col4>
class PowellEvaluator2 : public Evaluator {
public:
+ // clang-format off
PowellEvaluator2()
: num_active_cols_(
(col1 ? 1 : 0) +
@@ -71,6 +74,7 @@
<< col3 << " "
<< col4;
}
+ // clang-format on
virtual ~PowellEvaluator2() {}
@@ -111,7 +115,7 @@
<< "f3=" << f3 << ", "
<< "f4=" << f4 << ".";
- *cost = (f1*f1 + f2*f2 + f3*f3 + f4*f4) / 2.0;
+ *cost = (f1 * f1 + f2 * f2 + f3 * f3 + f4 * f4) / 2.0;
VLOG(1) << "Cost: " << *cost;
@@ -132,34 +136,42 @@
int column_index = 0;
if (col1) {
+ // clang-format off
jacobian_matrix.col(column_index++) <<
1.0,
0.0,
0.0,
sqrt(10.0) * 2.0 * (x1 - x4) * (1.0 - x4);
+ // clang-format on
}
if (col2) {
+ // clang-format off
jacobian_matrix.col(column_index++) <<
10.0,
0.0,
2.0*(x2 - 2.0*x3)*(1.0 - 2.0*x3),
0.0;
+ // clang-format on
}
if (col3) {
+ // clang-format off
jacobian_matrix.col(column_index++) <<
0.0,
sqrt(5.0),
2.0*(x2 - 2.0*x3)*(x2 - 2.0),
0.0;
+ // clang-format on
}
if (col4) {
+ // clang-format off
jacobian_matrix.col(column_index++) <<
0.0,
-sqrt(5.0),
0.0,
sqrt(10.0) * 2.0 * (x1 - x4) * (x1 - 1.0);
+ // clang-format on
}
VLOG(1) << "\n" << jacobian_matrix;
}
@@ -167,7 +179,7 @@
if (gradient != NULL) {
int column_index = 0;
if (col1) {
- gradient[column_index++] = f1 + f4 * sqrt(10.0) * 2.0 * (x1 - x4);
+ gradient[column_index++] = f1 + f4 * sqrt(10.0) * 2.0 * (x1 - x4);
}
if (col2) {
@@ -192,16 +204,16 @@
const double* delta,
double* state_plus_delta) const final {
int delta_index = 0;
- state_plus_delta[0] = (col1 ? state[0] + delta[delta_index++] : state[0]);
- state_plus_delta[1] = (col2 ? state[1] + delta[delta_index++] : state[1]);
- state_plus_delta[2] = (col3 ? state[2] + delta[delta_index++] : state[2]);
- state_plus_delta[3] = (col4 ? state[3] + delta[delta_index++] : state[3]);
+ state_plus_delta[0] = (col1 ? state[0] + delta[delta_index++] : state[0]);
+ state_plus_delta[1] = (col2 ? state[1] + delta[delta_index++] : state[1]);
+ state_plus_delta[2] = (col3 ? state[2] + delta[delta_index++] : state[2]);
+ state_plus_delta[3] = (col4 ? state[3] + delta[delta_index++] : state[3]);
return true;
}
int NumEffectiveParameters() const final { return num_active_cols_; }
- int NumParameters() const final { return 4; }
- int NumResiduals() const final { return 4; }
+ int NumParameters() const final { return 4; }
+ int NumResiduals() const final { return 4; }
private:
const int num_active_cols_;
@@ -209,13 +221,13 @@
// Templated function to hold a subset of the columns fixed and check
// if the solver converges to the optimal values or not.
-template<bool col1, bool col2, bool col3, bool col4>
+template <bool col1, bool col2, bool col3, bool col4>
void IsTrustRegionSolveSuccessful(TrustRegionStrategyType strategy_type) {
Solver::Options solver_options;
LinearSolver::Options linear_solver_options;
DenseQRSolver linear_solver(linear_solver_options);
- double parameters[4] = { 3, -1, 0, 1.0 };
+ double parameters[4] = {3, -1, 0, 1.0};
// If the column is inactive, then set its value to the optimal
// value.
@@ -263,6 +275,7 @@
// IsSolveSuccessful<true, true, false, true>();
const TrustRegionStrategyType kStrategy = LEVENBERG_MARQUARDT;
+ // clang-format off
IsTrustRegionSolveSuccessful<true, true, true, true >(kStrategy);
IsTrustRegionSolveSuccessful<true, true, true, false>(kStrategy);
IsTrustRegionSolveSuccessful<true, false, true, true >(kStrategy);
@@ -277,6 +290,7 @@
IsTrustRegionSolveSuccessful<false, true, false, false>(kStrategy);
IsTrustRegionSolveSuccessful<false, false, true, false>(kStrategy);
IsTrustRegionSolveSuccessful<false, false, false, true >(kStrategy);
+ // clang-format on
}
TEST(TrustRegionMinimizer, PowellsSingularFunctionUsingDogleg) {
@@ -287,6 +301,7 @@
// IsTrustRegionSolveSuccessful<true, true, true, true >(kStrategy);
const TrustRegionStrategyType kStrategy = DOGLEG;
+ // clang-format off
IsTrustRegionSolveSuccessful<true, true, true, false>(kStrategy);
IsTrustRegionSolveSuccessful<true, false, true, true >(kStrategy);
IsTrustRegionSolveSuccessful<false, true, true, true >(kStrategy);
@@ -300,9 +315,9 @@
IsTrustRegionSolveSuccessful<false, true, false, false>(kStrategy);
IsTrustRegionSolveSuccessful<false, false, true, false>(kStrategy);
IsTrustRegionSolveSuccessful<false, false, false, true >(kStrategy);
+ // clang-format on
}
-
class CurveCostFunction : public CostFunction {
public:
CurveCostFunction(int num_vertices, double target_length)
@@ -352,11 +367,11 @@
for (int dim = 0; dim < 2; dim++) {
jacobians[i][dim] = 0.;
- if (norm_u > std::numeric_limits< double >::min()) {
+ if (norm_u > std::numeric_limits<double>::min()) {
jacobians[i][dim] -= u[dim] / norm_u;
}
- if (norm_v > std::numeric_limits< double >::min()) {
+ if (norm_v > std::numeric_limits<double>::min()) {
jacobians[i][dim] += v[dim] / norm_v;
}
}
@@ -367,8 +382,8 @@
}
private:
- int num_vertices_;
- double target_length_;
+ int num_vertices_;
+ double target_length_;
};
TEST(TrustRegionMinimizer, JacobiScalingTest) {
@@ -376,7 +391,7 @@
std::vector<double*> y(N);
const double pi = 3.1415926535897932384626433;
for (int i = 0; i < N; i++) {
- double theta = i * 2. * pi/ static_cast< double >(N);
+ double theta = i * 2. * pi / static_cast<double>(N);
y[i] = new double[2];
y[i][0] = cos(theta);
y[i][1] = sin(theta);
@@ -391,7 +406,7 @@
EXPECT_LE(summary.final_cost, 1e-10);
for (int i = 0; i < N; i++) {
- delete []y[i];
+ delete[] y[i];
}
}
@@ -403,8 +418,7 @@
}
static CostFunction* Create() {
- return new AutoDiffCostFunction<ExpCostFunctor, 1, 1>(
- new ExpCostFunctor);
+ return new AutoDiffCostFunction<ExpCostFunctor, 1, 1>(new ExpCostFunctor);
}
};
diff --git a/internal/ceres/trust_region_preprocessor_test.cc b/internal/ceres/trust_region_preprocessor_test.cc
index c344812..a2a9523 100644
--- a/internal/ceres/trust_region_preprocessor_test.cc
+++ b/internal/ceres/trust_region_preprocessor_test.cc
@@ -28,6 +28,8 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/trust_region_preprocessor.h"
+
#include <array>
#include <map>
@@ -35,7 +37,6 @@
#include "ceres/problem_impl.h"
#include "ceres/sized_cost_function.h"
#include "ceres/solver.h"
-#include "ceres/trust_region_preprocessor.h"
#include "gtest/gtest.h"
namespace ceres {
@@ -147,8 +148,10 @@
x_ = 1.0;
y_ = 1.0;
z_ = 1.0;
- problem_.AddResidualBlock(new DummyCostFunction<1, 1, 1>, nullptr, &x_, &y_);
- problem_.AddResidualBlock(new DummyCostFunction<1, 1, 1>, nullptr, &y_, &z_);
+ problem_.AddResidualBlock(
+ new DummyCostFunction<1, 1, 1>, nullptr, &x_, &y_);
+ problem_.AddResidualBlock(
+ new DummyCostFunction<1, 1, 1>, nullptr, &y_, &z_);
}
void PreprocessForGivenLinearSolverAndVerify(
@@ -322,8 +325,7 @@
EXPECT_TRUE(pp.inner_iteration_minimizer.get() != nullptr);
}
-TEST_F(LinearSolverAndEvaluatorCreationTest,
- InvalidInnerIterationsOrdering) {
+TEST_F(LinearSolverAndEvaluatorCreationTest, InvalidInnerIterationsOrdering) {
Solver::Options options;
options.use_inner_iterations = true;
options.inner_iteration_ordering.reset(new ParameterBlockOrdering);
diff --git a/internal/ceres/trust_region_step_evaluator.cc b/internal/ceres/trust_region_step_evaluator.cc
index 33b0c41..19045ae 100644
--- a/internal/ceres/trust_region_step_evaluator.cc
+++ b/internal/ceres/trust_region_step_evaluator.cc
@@ -28,17 +28,18 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/trust_region_step_evaluator.h"
+
#include <algorithm>
#include <limits>
-#include "ceres/trust_region_step_evaluator.h"
+
#include "glog/logging.h"
namespace ceres {
namespace internal {
TrustRegionStepEvaluator::TrustRegionStepEvaluator(
- const double initial_cost,
- const int max_consecutive_nonmonotonic_steps)
+ const double initial_cost, const int max_consecutive_nonmonotonic_steps)
: max_consecutive_nonmonotonic_steps_(max_consecutive_nonmonotonic_steps),
minimum_cost_(initial_cost),
current_cost_(initial_cost),
@@ -46,12 +47,10 @@
candidate_cost_(initial_cost),
accumulated_reference_model_cost_change_(0.0),
accumulated_candidate_model_cost_change_(0.0),
- num_consecutive_nonmonotonic_steps_(0){
-}
+ num_consecutive_nonmonotonic_steps_(0) {}
double TrustRegionStepEvaluator::StepQuality(
- const double cost,
- const double model_cost_change) const {
+ const double cost, const double model_cost_change) const {
// If the function evaluation for this step was a failure, in which
// case the TrustRegionMinimizer would have set the cost to
// std::numeric_limits<double>::max(). In this case, the division by
@@ -68,9 +67,8 @@
return std::max(relative_decrease, historical_relative_decrease);
}
-void TrustRegionStepEvaluator::StepAccepted(
- const double cost,
- const double model_cost_change) {
+void TrustRegionStepEvaluator::StepAccepted(const double cost,
+ const double model_cost_change) {
// Algorithm 10.1.2 from Trust Region Methods by Conn, Gould &
// Toint.
//
diff --git a/internal/ceres/trust_region_strategy.cc b/internal/ceres/trust_region_strategy.cc
index 2db6a6c..7e429d5 100644
--- a/internal/ceres/trust_region_strategy.cc
+++ b/internal/ceres/trust_region_strategy.cc
@@ -31,6 +31,7 @@
// keir@google.com (Keir Mierle)
#include "ceres/trust_region_strategy.h"
+
#include "ceres/dogleg_strategy.h"
#include "ceres/levenberg_marquardt_strategy.h"
diff --git a/internal/ceres/trust_region_strategy.h b/internal/ceres/trust_region_strategy.h
index 5751691..48e7347 100644
--- a/internal/ceres/trust_region_strategy.h
+++ b/internal/ceres/trust_region_strategy.h
@@ -32,6 +32,7 @@
#define CERES_INTERNAL_TRUST_REGION_STRATEGY_H_
#include <string>
+
#include "ceres/internal/port.h"
#include "ceres/linear_solver.h"
diff --git a/internal/ceres/types.cc b/internal/ceres/types.cc
index 93c4cfc..39bb2d8 100644
--- a/internal/ceres/types.cc
+++ b/internal/ceres/types.cc
@@ -28,18 +28,22 @@
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
+#include "ceres/types.h"
+
#include <algorithm>
#include <cctype>
#include <string>
-#include "ceres/types.h"
+
#include "glog/logging.h"
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;}
+#define STRENUM(x) if (value == #x) { *type = x; return true; }
+// clang-format on
static void UpperCase(string* input) {
std::transform(input->begin(), input->end(), input->begin(), ::toupper);
@@ -109,8 +113,7 @@
}
bool StringToSparseLinearAlgebraLibraryType(
- string value,
- SparseLinearAlgebraLibraryType* type) {
+ string value, SparseLinearAlgebraLibraryType* type) {
UpperCase(&value);
STRENUM(SUITE_SPARSE);
STRENUM(CX_SPARSE);
@@ -131,8 +134,7 @@
}
bool StringToDenseLinearAlgebraLibraryType(
- string value,
- DenseLinearAlgebraLibraryType* type) {
+ string value, DenseLinearAlgebraLibraryType* type) {
UpperCase(&value);
STRENUM(EIGEN);
STRENUM(LAPACK);
@@ -236,9 +238,8 @@
}
}
-bool StringToLineSearchInterpolationType(
- string value,
- LineSearchInterpolationType* type) {
+bool StringToLineSearchInterpolationType(string value,
+ LineSearchInterpolationType* type) {
UpperCase(&value);
STRENUM(BISECTION);
STRENUM(QUADRATIC);
@@ -258,8 +259,7 @@
}
bool StringToNonlinearConjugateGradientType(
- string value,
- NonlinearConjugateGradientType* type) {
+ string value, NonlinearConjugateGradientType* type) {
UpperCase(&value);
STRENUM(FLETCHER_REEVES);
STRENUM(POLAK_RIBIERE);
@@ -267,8 +267,7 @@
return false;
}
-const char* CovarianceAlgorithmTypeToString(
- CovarianceAlgorithmType type) {
+const char* CovarianceAlgorithmTypeToString(CovarianceAlgorithmType type) {
switch (type) {
CASESTR(DENSE_SVD);
CASESTR(SPARSE_QR);
@@ -277,17 +276,15 @@
}
}
-bool StringToCovarianceAlgorithmType(
- string value,
- CovarianceAlgorithmType* type) {
+bool StringToCovarianceAlgorithmType(string value,
+ CovarianceAlgorithmType* type) {
UpperCase(&value);
STRENUM(DENSE_SVD);
STRENUM(SPARSE_QR);
return false;
}
-const char* NumericDiffMethodTypeToString(
- NumericDiffMethodType type) {
+const char* NumericDiffMethodTypeToString(NumericDiffMethodType type) {
switch (type) {
CASESTR(CENTRAL);
CASESTR(FORWARD);
@@ -297,9 +294,7 @@
}
}
-bool StringToNumericDiffMethodType(
- string value,
- NumericDiffMethodType* type) {
+bool StringToNumericDiffMethodType(string value, NumericDiffMethodType* type) {
UpperCase(&value);
STRENUM(CENTRAL);
STRENUM(FORWARD);
@@ -307,8 +302,7 @@
return false;
}
-const char* VisibilityClusteringTypeToString(
- VisibilityClusteringType type) {
+const char* VisibilityClusteringTypeToString(VisibilityClusteringType type) {
switch (type) {
CASESTR(CANONICAL_VIEWS);
CASESTR(SINGLE_LINKAGE);
@@ -317,9 +311,8 @@
}
}
-bool StringToVisibilityClusteringType(
- string value,
- VisibilityClusteringType* type) {
+bool StringToVisibilityClusteringType(string value,
+ VisibilityClusteringType* type) {
UpperCase(&value);
STRENUM(CANONICAL_VIEWS);
STRENUM(SINGLE_LINKAGE);
@@ -354,9 +347,8 @@
return false;
}
-
const char* DumpFormatTypeToString(DumpFormatType type) {
- switch (type) {
+ switch (type) {
CASESTR(CONSOLE);
CASESTR(TEXTFILE);
default:
@@ -375,9 +367,11 @@
#undef STRENUM
bool IsSchurType(LinearSolverType type) {
+ // clang-format off
return ((type == SPARSE_SCHUR) ||
(type == DENSE_SCHUR) ||
(type == ITERATIVE_SCHUR));
+ // clang-format on
}
bool IsSparseLinearAlgebraLibraryTypeAvailable(
diff --git a/internal/ceres/visibility.cc b/internal/ceres/visibility.cc
index 0981eed..82bf6f1 100644
--- a/internal/ceres/visibility.cc
+++ b/internal/ceres/visibility.cc
@@ -30,13 +30,14 @@
#include "ceres/visibility.h"
+#include <algorithm>
#include <cmath>
#include <ctime>
-#include <algorithm>
#include <set>
-#include <vector>
#include <unordered_map>
#include <utility>
+#include <vector>
+
#include "ceres/block_structure.h"
#include "ceres/graph.h"
#include "ceres/pair_hash.h"
@@ -138,9 +139,10 @@
const int count = camera_pair_count.second;
DCHECK_NE(camera1, camera2);
// Static cast necessary for Windows.
- const double weight = static_cast<double>(count) /
- (sqrt(static_cast<double>(
- visibility[camera1].size() * visibility[camera2].size())));
+ const double weight =
+ static_cast<double>(count) /
+ (sqrt(static_cast<double>(visibility[camera1].size() *
+ visibility[camera2].size())));
graph->AddEdge(camera1, camera2, weight);
}
diff --git a/internal/ceres/visibility.h b/internal/ceres/visibility.h
index 115d45f..ed25d53 100644
--- a/internal/ceres/visibility.h
+++ b/internal/ceres/visibility.h
@@ -37,6 +37,7 @@
#include <set>
#include <vector>
+
#include "ceres/graph.h"
namespace ceres {
diff --git a/internal/ceres/visibility_based_preconditioner.h b/internal/ceres/visibility_based_preconditioner.h
index aa582d5..0457b9a 100644
--- a/internal/ceres/visibility_based_preconditioner.h
+++ b/internal/ceres/visibility_based_preconditioner.h
@@ -162,8 +162,9 @@
std::vector<std::set<int>>* cluster_visibility) const;
WeightedGraph<int>* CreateClusterGraph(
const std::vector<std::set<int>>& visibility) const;
- void ForestToClusterPairs(const WeightedGraph<int>& forest,
- std::unordered_set<std::pair<int, int>, pair_hash>* cluster_pairs) const;
+ void ForestToClusterPairs(
+ const WeightedGraph<int>& forest,
+ std::unordered_set<std::pair<int, int>, pair_hash>* cluster_pairs) const;
void ComputeBlockPairsInPreconditioner(const CompressedRowBlockStructure& bs);
bool IsBlockPairInPreconditioner(int block1, int block2) const;
bool IsBlockPairOffDiagonal(int block1, int block2) const;
diff --git a/internal/ceres/visibility_based_preconditioner_test.cc b/internal/ceres/visibility_based_preconditioner_test.cc
index a006d98..10aa619 100644
--- a/internal/ceres/visibility_based_preconditioner_test.cc
+++ b/internal/ceres/visibility_based_preconditioner_test.cc
@@ -31,6 +31,7 @@
#include "ceres/visibility_based_preconditioner.h"
#include <memory>
+
#include "Eigen/Dense"
#include "ceres/block_random_access_dense_matrix.h"
#include "ceres/block_random_access_sparse_matrix.h"
diff --git a/internal/ceres/visibility_test.cc b/internal/ceres/visibility_test.cc
index 5028e01..a199963 100644
--- a/internal/ceres/visibility_test.cc
+++ b/internal/ceres/visibility_test.cc
@@ -46,8 +46,7 @@
using std::set;
using std::vector;
-class VisibilityTest : public ::testing::Test {
-};
+class VisibilityTest : public ::testing::Test {};
TEST(VisibilityTest, SimpleMatrix) {
// A = [1 0 0 0 0 1
@@ -100,14 +99,15 @@
}
bs.cols.resize(num_cols);
- vector< set<int>> visibility;
+ vector<set<int>> visibility;
ComputeVisibility(bs, num_eliminate_blocks, &visibility);
ASSERT_EQ(visibility.size(), num_cols - num_eliminate_blocks);
for (int i = 0; i < visibility.size(); ++i) {
ASSERT_EQ(visibility[i].size(), 1);
}
- std::unique_ptr<WeightedGraph<int> > graph(CreateSchurComplementGraph(visibility));
+ std::unique_ptr<WeightedGraph<int>> graph(
+ CreateSchurComplementGraph(visibility));
EXPECT_EQ(graph->vertices().size(), visibility.size());
for (int i = 0; i < visibility.size(); ++i) {
EXPECT_EQ(graph->VertexWeight(i), 1.0);
@@ -121,14 +121,12 @@
}
EXPECT_EQ(graph->EdgeWeight(i, j), edge_weight)
- << "Edge: " << i << " " << j
- << " weight: " << graph->EdgeWeight(i, j)
+ << "Edge: " << i << " " << j << " weight: " << graph->EdgeWeight(i, j)
<< " expected weight: " << edge_weight;
}
}
}
-
TEST(VisibilityTest, NoEBlocks) {
// A = [1 0 0 0 0 0
// 1 0 0 0 0 0
@@ -183,8 +181,8 @@
ASSERT_EQ(visibility[i].size(), 0);
}
- std::unique_ptr<WeightedGraph<int> > graph(
- CreateSchurComplementGraph(visibility));
+ std::unique_ptr<WeightedGraph<int>> graph(
+ CreateSchurComplementGraph(visibility));
EXPECT_EQ(graph->vertices().size(), visibility.size());
for (int i = 0; i < visibility.size(); ++i) {
EXPECT_EQ(graph->VertexWeight(i), 1.0);
@@ -197,8 +195,7 @@
edge_weight = 1.0;
}
EXPECT_EQ(graph->EdgeWeight(i, j), edge_weight)
- << "Edge: " << i << " " << j
- << " weight: " << graph->EdgeWeight(i, j)
+ << "Edge: " << i << " " << j << " weight: " << graph->EdgeWeight(i, j)
<< " expected weight: " << edge_weight;
}
}
diff --git a/internal/ceres/wall_time.h b/internal/ceres/wall_time.h
index ed0610f..3f465e8 100644
--- a/internal/ceres/wall_time.h
+++ b/internal/ceres/wall_time.h
@@ -33,6 +33,7 @@
#include <map>
#include <string>
+
#include "ceres/internal/port.h"
#include "ceres/stringprintf.h"
#include "glog/logging.h"
diff --git a/scripts/format_all.sh b/scripts/format_all.sh
new file mode 100755
index 0000000..565ac0c
--- /dev/null
+++ b/scripts/format_all.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+# Format all source files in the project.
+#
+# Set CLANG_FORMAT_CMD environment variable to specify executable used (default: `clang-format`).
+
+set -e
+
+################################################################################
+# Configuration
+
+# folders to search
+FOLDERS="
+ include
+ internal
+ examples
+"
+
+# paths to ignore
+EXCLUDE_PATHS="
+ internal/ceres/gtest/*
+ internal/ceres/gmock/*
+ internal/ceres/gmock_gtest_all.cc
+ internal/ceres/gmock_main.cc
+ internal/ceres/generated/*
+ internal/ceres/generated_bundle_adjustment_tests/*
+ internal/ceres/schur_eliminator.cc
+ internal/ceres/partitioned_matrix_view.cc
+ internal/ceres/schur_templates.cc
+"
+
+################################################################################
+# Implementation
+
+# directory of this script and the repository root
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+REPO_DIR="$SCRIPT_DIR/.."
+
+# set default for CLANG_FORMAT_CMD
+CLANG_FORMAT_CMD=${CLANG_FORMAT_CMD:-clang-format}
+echo "Formatting with $CLANG_FORMAT_CMD (`$CLANG_FORMAT_CMD --version`)"
+
+# prepare arguments to exclude ignored paths
+EXCLUDE_ARGS=""
+for p in $EXCLUDE_PATHS; do
+ EXCLUDE_ARGS="-not -path */$p $EXCLUDE_ARGS"
+done
+
+# for each folder, format header and source dirs
+for d in $FOLDERS; do
+ d="$REPO_DIR/$d"
+ find "$d" \( -name "*.h" -or -name "*.cc" \) $EXCLUDE_ARGS | xargs $CLANG_FORMAT_CMD -verbose -i
+done
