Various minor fixes.
1. Unused variable warnings and fixes.
2. Minor documentation update.
Change-Id: I815588a5806df1030a7c8750f4fb594c503f8998
diff --git a/CMakeLists.txt b/CMakeLists.txt
index eac5816..80d6f22 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -617,7 +617,7 @@
# GCC is not strict enough by default, so enable most of the warnings.
IF ("${UNIX}")
SET(CMAKE_CXX_FLAGS
- "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused -Wno-unused-parameter")
+ "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-return-type-c-linkage")
ENDIF ("${UNIX}")
ADD_SUBDIRECTORY(internal/ceres)
diff --git a/docs/source/introduction.rst b/docs/source/introduction.rst
index 4e9e967..5df765b 100644
--- a/docs/source/introduction.rst
+++ b/docs/source/introduction.rst
@@ -60,11 +60,14 @@
:ref:`chapter-tutorial`.
.. [#f2] While there is some debate as to who invented the method of
- Least Squares [Stigler]_, there is no debate that it was Carl
- Friedrich brought it to the attention of the world. Using
- just 22 observations of the newly discovered asteroid Ceres,
- Gauss used the method of least squares to correctly predict
- when and where the asteroid will emerge from behind the Sun
+ Least Squares [Stigler]_, there is no debate that it was
+ `Carl Friedrich Gauss
+ <http://en.wikipedia.org/wiki/Carl_Friedrich_Gauss>`_ who
+ brought it to the attention of the world. Using just 22
+ observations of the newly discovered asteroid `Ceres
+ <http://en.wikipedia.org/wiki/Ceres_(dwarf_planet)>`_, Gauss
+ used the method of least squares to correctly predict when
+ and where the asteroid will emerge from behind the Sun
[TenenbaumDirector]_. We named our solver after Ceres to
celebrate this seminal event in the history of astronomy,
statistics and optimization.
diff --git a/docs/source/modeling.rst b/docs/source/modeling.rst
index 9235094..d8d73bf 100644
--- a/docs/source/modeling.rst
+++ b/docs/source/modeling.rst
@@ -988,30 +988,127 @@
.. function:: ResidualBlockId Problem::AddResidualBlock(CostFunction* cost_function, LossFunction* loss_function, const vector<double*> parameter_blocks)
+ Add a residual block to the overall cost function. The cost
+ function carries with it information about the sizes of the
+ parameter blocks it expects. The function checks that these match
+ the sizes of the parameter blocks listed in parameter_blocks. The
+ program aborts if a mismatch is detected. loss_function can be
+ NULL, in which case the cost of the term is just the squared norm
+ of the residuals.
+
+ The user has the option of explicitly adding the parameter blocks
+ using AddParameterBlock. This causes additional correctness
+ checking; however, AddResidualBlock implicitly adds the parameter
+ blocks if they are not present, so calling AddParameterBlock
+ explicitly is not required.
+
+ The Problem object by default takes ownership of the
+ cost_function and loss_function pointers. These objects remain
+ live for the life of the Problem object. If the user wishes to
+ keep control over the destruction of these objects, then they can
+ do this by setting the corresponding enums in the Options struct.
+
+ Note: Even though the Problem takes ownership of cost_function
+ and loss_function, it does not preclude the user from re-using
+ them in another residual block. The destructor takes care to call
+ delete on each cost_function or loss_function pointer only once,
+ regardless of how many residual blocks refer to them.
+
+ Example usage:
+
+ .. code-block:: c++
+
+ double x1[] = {1.0, 2.0, 3.0};
+ double x2[] = {1.0, 2.0, 5.0, 6.0};
+ double x3[] = {3.0, 6.0, 2.0, 5.0, 1.0};
+
+ Problem problem;
+
+ problem.AddResidualBlock(new MyUnaryCostFunction(...), NULL, x1);
+ problem.AddResidualBlock(new MyBinaryCostFunction(...), NULL, x2, x1);
+
.. function:: void Problem::AddParameterBlock(double* values, int size, LocalParameterization* local_parameterization)
- void Problem::AddParameterBlock(double* values, int size)
+
+ Add a parameter block with appropriate size to the problem.
+ Repeated calls with the same arguments are ignored. Repeated calls
+ with the same double pointer but a different size results in
+ undefined behaviour.
+
+.. function:: void Problem::AddParameterBlock(double* values, int size)
+
+ Add a parameter block with appropriate size and parameterization to
+ the problem. Repeated calls with the same arguments are
+ ignored. Repeated calls with the same double pointer but a
+ different size results in undefined behaviour.
+
+.. function:: void Problem::RemoveResidualBlock(ResidualBlockId residual_block)
+
+ Remove a parameter block from the problem. The parameterization of
+ the parameter block, if it exists, will persist until the deletion
+ of the problem (similar to cost/loss functions in residual block
+ removal). Any residual blocks that depend on the parameter are also
+ removed, as described above in RemoveResidualBlock(). If
+ Problem::Options::enable_fast_parameter_block_removal is true, then
+ the removal is fast (almost constant time). Otherwise, removing a
+ parameter block will incur a scan of the entire Problem object.
+
+ WARNING: Removing a residual or parameter block will destroy the
+ implicit ordering, rendering the jacobian or residuals returned
+ from the solver uninterpretable. If you depend on the evaluated
+ jacobian, do not use remove! This may change in a future release.
+
+.. function:: void Problem::RemoveResidualBlock(ResidualBlockId residual_block)
+
+ Remove a residual block from the problem. Any parameters that the residual
+ block depends on are not removed. The cost and loss functions for the
+ residual block will not get deleted immediately; won't happen until the
+ problem itself is deleted.
+
+ WARNING: Removing a residual or parameter block will destroy the implicit
+ ordering, rendering the jacobian or residuals returned from the solver
+ uninterpretable. If you depend on the evaluated jacobian, do not use
+ remove! This may change in a future release.
+ Hold the indicated parameter block constant during optimization.
.. function:: void Problem::SetParameterBlockConstant(double* values)
+ Hold the indicated parameter block constant during optimization.
+
.. function:: void Problem::SetParameterBlockVariable(double* values)
+ Allow the indicated parameter to vary during optimization.
+
.. function:: void Problem::SetParameterization(double* values, LocalParameterization* local_parameterization)
+ Set the local parameterization for one of the parameter blocks.
+ The local_parameterization is owned by the Problem by default. It
+ is acceptable to set the same parameterization for multiple
+ parameters; the destructor is careful to delete local
+ parameterizations only once. The local parameterization can only be
+ set once per parameter, and cannot be changed once set.
.. function:: int Problem::NumParameterBlocks() const
+ Number of parameter blocks in the problem. Always equals
+ parameter_blocks().size() and parameter_block_sizes().size().
.. function:: int Problem::NumParameters() const
+ The size of the parameter vector obtained by summing over the sizes
+ of all the parameter blocks.
.. function:: int Problem::NumResidualBlocks() const
+ Number of residual blocks in the problem. Always equals
+ residual_blocks().size().
.. function:: int Problem::NumResiduals() const
+ The size of the residual vector obtained by summing over the sizes
+ of all of the residual blocks.
``rotation.h``
diff --git a/docs/source/version_history.rst b/docs/source/version_history.rst
index dbfc758..8de716c 100644
--- a/docs/source/version_history.rst
+++ b/docs/source/version_history.rst
@@ -9,6 +9,10 @@
New Features
------------
+#. Problem now supports removal of ParameterBlocks and
+ ResidualBlocks. There is a space/time tradeoff in doing this which
+ is controlled by
+ ``Problem::Options::enable_fast_parameter_block_removal`.
#. Ceres now supports Line search based optimization algorithms in
addition to trust region algorithms. Currently there is support for
@@ -39,11 +43,13 @@
#. Automatic differenatiation with a dynamic number of parameter
blocks. (Based on an idea by Thad Hughes).
-#. Speeded up problem construction destruction.
+#. Speeded up problem construction and destruction.
#. Added matrix adapters to ``rotation.h`` so that the rotation matrix
routines can work with row and column major matrices. (Markus Moll)
+#. ``SCHUR_JACOBI`` can now be used without ``SuiteSparse``.
+
Bug Fixes
---------
diff --git a/internal/ceres/dogleg_strategy_test.cc b/internal/ceres/dogleg_strategy_test.cc
index 9e2ed9f..24c526e 100644
--- a/internal/ceres/dogleg_strategy_test.cc
+++ b/internal/ceres/dogleg_strategy_test.cc
@@ -206,10 +206,7 @@
DoglegStrategy strategy(options_);
TrustRegionStrategy::PerSolveOptions pso;
- TrustRegionStrategy::Summary summary = strategy.ComputeStep(pso,
- jacobian_.get(),
- residual_.data(),
- x_.data());
+ strategy.ComputeStep(pso, jacobian_.get(), residual_.data(), x_.data());
// Check if the basis is orthonormal.
const Matrix basis = strategy.subspace_basis();
@@ -288,4 +285,3 @@
} // namespace internal
} // namespace ceres
-
diff --git a/internal/ceres/schur_complement_solver_test.cc b/internal/ceres/schur_complement_solver_test.cc
index 71c6cfd..1820bc9 100644
--- a/internal/ceres/schur_complement_solver_test.cc
+++ b/internal/ceres/schur_complement_solver_test.cc
@@ -75,20 +75,12 @@
// Gold standard solutions using dense QR factorization.
DenseSparseMatrix dense_A(triplet_A);
- LinearSolver::Summary summary1 =
- qr->Solve(&dense_A,
- b.get(),
- LinearSolver::PerSolveOptions(),
- sol.get());
+ qr->Solve(&dense_A, b.get(), LinearSolver::PerSolveOptions(), sol.get());
// Gold standard solution with appended diagonal.
LinearSolver::PerSolveOptions per_solve_options;
per_solve_options.D = D.get();
- LinearSolver::Summary summary2 =
- qr->Solve(&dense_A,
- b.get(),
- per_solve_options,
- sol_d.get());
+ qr->Solve(&dense_A, b.get(), per_solve_options, sol_d.get());
}
void ComputeAndCompareSolutions(
diff --git a/internal/ceres/solver_impl.cc b/internal/ceres/solver_impl.cc
index c6ee86a..803b711 100644
--- a/internal/ceres/solver_impl.cc
+++ b/internal/ceres/solver_impl.cc
@@ -490,9 +490,6 @@
double post_process_start_time = WallTimeInSeconds();
-
-
-
// Evaluate the final cost, residual vector and the jacobian
// matrix if requested by the user.
if (options.return_final_residuals ||
@@ -820,6 +817,8 @@
// Ensure the program state is set to the user parameters on the way out.
original_program->SetParameterBlockStatePtrsToUserStatePtrs();
+ summary->postprocessor_time_in_seconds =
+ WallTimeInSeconds() - post_process_start_time;
return;
}
@@ -886,6 +885,9 @@
summary->termination_type = NUMERICAL_FAILURE;
summary->error = "Unable to evaluate the final cost.";
LOG(ERROR) << summary->error;
+
+ summary->postprocessor_time_in_seconds =
+ WallTimeInSeconds() - post_process_start_time;
return;
}
}
@@ -901,9 +903,6 @@
summary->jacobian_evaluation_time_in_seconds =
FindWithDefault(evaluator_time_statistics, "Evaluator::Jacobian", 0.0);
- summary->postprocessor_time_in_seconds =
- WallTimeInSeconds() - post_process_start_time;
-
// Stick a fork in it, we're done.
summary->postprocessor_time_in_seconds =
WallTimeInSeconds() - post_process_start_time;
