Ceres: Update to the latest version
authorSergey Sharybin <sergey.vfx@gmail.com>
Wed, 28 Oct 2015 13:55:04 +0000 (18:55 +0500)
committerSergey Sharybin <sergey.vfx@gmail.com>
Wed, 28 Oct 2015 14:20:50 +0000 (19:20 +0500)
It brings all the performance improvements, bug fixes and stability improvements
which were done in the last year of Ceres development.

268 files changed:
extern/libmv/third_party/ceres/CMakeLists.txt
extern/libmv/third_party/ceres/ChangeLog
extern/libmv/third_party/ceres/SConscript
extern/libmv/third_party/ceres/bundle.sh
extern/libmv/third_party/ceres/config/ceres/internal/config.h
extern/libmv/third_party/ceres/files.txt
extern/libmv/third_party/ceres/include/ceres/autodiff_cost_function.h
extern/libmv/third_party/ceres/include/ceres/autodiff_local_parameterization.h
extern/libmv/third_party/ceres/include/ceres/c_api.h
extern/libmv/third_party/ceres/include/ceres/ceres.h
extern/libmv/third_party/ceres/include/ceres/conditioned_cost_function.h
extern/libmv/third_party/ceres/include/ceres/cost_function.h
extern/libmv/third_party/ceres/include/ceres/cost_function_to_functor.h
extern/libmv/third_party/ceres/include/ceres/covariance.h
extern/libmv/third_party/ceres/include/ceres/crs_matrix.h
extern/libmv/third_party/ceres/include/ceres/dynamic_autodiff_cost_function.h
extern/libmv/third_party/ceres/include/ceres/dynamic_cost_function_to_functor.h [new file with mode: 0644]
extern/libmv/third_party/ceres/include/ceres/dynamic_numeric_diff_cost_function.h
extern/libmv/third_party/ceres/include/ceres/fpclassify.h
extern/libmv/third_party/ceres/include/ceres/gradient_checker.h
extern/libmv/third_party/ceres/include/ceres/gradient_problem.h
extern/libmv/third_party/ceres/include/ceres/gradient_problem_solver.h
extern/libmv/third_party/ceres/include/ceres/internal/autodiff.h
extern/libmv/third_party/ceres/include/ceres/internal/disable_warnings.h
extern/libmv/third_party/ceres/include/ceres/internal/eigen.h
extern/libmv/third_party/ceres/include/ceres/internal/fixed_array.h
extern/libmv/third_party/ceres/include/ceres/internal/macros.h
extern/libmv/third_party/ceres/include/ceres/internal/manual_constructor.h
extern/libmv/third_party/ceres/include/ceres/internal/numeric_diff.h
extern/libmv/third_party/ceres/include/ceres/internal/port.h
extern/libmv/third_party/ceres/include/ceres/internal/reenable_warnings.h
extern/libmv/third_party/ceres/include/ceres/internal/scoped_ptr.h
extern/libmv/third_party/ceres/include/ceres/internal/variadic_evaluate.h
extern/libmv/third_party/ceres/include/ceres/iteration_callback.h
extern/libmv/third_party/ceres/include/ceres/jet.h
extern/libmv/third_party/ceres/include/ceres/local_parameterization.h
extern/libmv/third_party/ceres/include/ceres/loss_function.h
extern/libmv/third_party/ceres/include/ceres/normal_prior.h
extern/libmv/third_party/ceres/include/ceres/numeric_diff_cost_function.h
extern/libmv/third_party/ceres/include/ceres/numeric_diff_options.h [new file with mode: 0644]
extern/libmv/third_party/ceres/include/ceres/ordered_groups.h
extern/libmv/third_party/ceres/include/ceres/problem.h
extern/libmv/third_party/ceres/include/ceres/rotation.h
extern/libmv/third_party/ceres/include/ceres/sized_cost_function.h
extern/libmv/third_party/ceres/include/ceres/solver.h
extern/libmv/third_party/ceres/include/ceres/types.h
extern/libmv/third_party/ceres/include/ceres/version.h
extern/libmv/third_party/ceres/internal/ceres/array_utils.cc
extern/libmv/third_party/ceres/internal/ceres/array_utils.h
extern/libmv/third_party/ceres/internal/ceres/blas.cc
extern/libmv/third_party/ceres/internal/ceres/blas.h
extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.cc
extern/libmv/third_party/ceres/internal/ceres/block_evaluate_preparer.h
extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.cc
extern/libmv/third_party/ceres/internal/ceres/block_jacobi_preconditioner.h
extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.cc
extern/libmv/third_party/ceres/internal/ceres/block_jacobian_writer.h
extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/block_random_access_dense_matrix.h
extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/block_random_access_diagonal_matrix.h
extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/block_random_access_matrix.h
extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/block_random_access_sparse_matrix.h
extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/block_sparse_matrix.h
extern/libmv/third_party/ceres/internal/ceres/block_structure.cc
extern/libmv/third_party/ceres/internal/ceres/block_structure.h
extern/libmv/third_party/ceres/internal/ceres/c_api.cc
extern/libmv/third_party/ceres/internal/ceres/callbacks.cc
extern/libmv/third_party/ceres/internal/ceres/callbacks.h
extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.cc
extern/libmv/third_party/ceres/internal/ceres/canonical_views_clustering.h
extern/libmv/third_party/ceres/internal/ceres/casts.h
extern/libmv/third_party/ceres/internal/ceres/cgnr_linear_operator.h
extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.cc
extern/libmv/third_party/ceres/internal/ceres/cgnr_solver.h
extern/libmv/third_party/ceres/internal/ceres/collections_port.h
extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.cc
extern/libmv/third_party/ceres/internal/ceres/compressed_col_sparse_matrix_utils.h
extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.cc
extern/libmv/third_party/ceres/internal/ceres/compressed_row_jacobian_writer.h
extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/compressed_row_sparse_matrix.h
extern/libmv/third_party/ceres/internal/ceres/conditioned_cost_function.cc
extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.cc
extern/libmv/third_party/ceres/internal/ceres/conjugate_gradients_solver.h
extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.cc
extern/libmv/third_party/ceres/internal/ceres/coordinate_descent_minimizer.h
extern/libmv/third_party/ceres/internal/ceres/corrector.cc
extern/libmv/third_party/ceres/internal/ceres/corrector.h
extern/libmv/third_party/ceres/internal/ceres/covariance.cc
extern/libmv/third_party/ceres/internal/ceres/covariance_impl.cc
extern/libmv/third_party/ceres/internal/ceres/covariance_impl.h
extern/libmv/third_party/ceres/internal/ceres/cxsparse.cc
extern/libmv/third_party/ceres/internal/ceres/cxsparse.h
extern/libmv/third_party/ceres/internal/ceres/dense_jacobian_writer.h
extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.cc
extern/libmv/third_party/ceres/internal/ceres/dense_normal_cholesky_solver.h
extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.cc
extern/libmv/third_party/ceres/internal/ceres/dense_qr_solver.h
extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/dense_sparse_matrix.h
extern/libmv/third_party/ceres/internal/ceres/detect_structure.cc
extern/libmv/third_party/ceres/internal/ceres/detect_structure.h
extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.cc
extern/libmv/third_party/ceres/internal/ceres/dogleg_strategy.h
extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_finalizer.h
extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_jacobian_writer.h
extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/dynamic_compressed_row_sparse_matrix.h
extern/libmv/third_party/ceres/internal/ceres/evaluator.cc
extern/libmv/third_party/ceres/internal/ceres/evaluator.h
extern/libmv/third_party/ceres/internal/ceres/execution_summary.h
extern/libmv/third_party/ceres/internal/ceres/file.cc
extern/libmv/third_party/ceres/internal/ceres/file.h
extern/libmv/third_party/ceres/internal/ceres/generate_eliminator_specialization.py
extern/libmv/third_party/ceres/internal/ceres/generate_partitioned_matrix_view_specializations.py
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_2.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_2_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_6.cc [new file with mode: 0644]
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_9.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_3_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_8.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_9.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_4_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_2_d_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_2.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_4_4_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/partitioned_matrix_view_d_d_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_2.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_2_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_6.cc [new file with mode: 0644]
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_9.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_3_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_8.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_9.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_4_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_2_d_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_2.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_3.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_4.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_4_4_d.cc
extern/libmv/third_party/ceres/internal/ceres/generated/schur_eliminator_d_d_d.cc
extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.cc
extern/libmv/third_party/ceres/internal/ceres/gradient_checking_cost_function.h
extern/libmv/third_party/ceres/internal/ceres/gradient_problem.cc
extern/libmv/third_party/ceres/internal/ceres/gradient_problem_evaluator.h
extern/libmv/third_party/ceres/internal/ceres/gradient_problem_solver.cc
extern/libmv/third_party/ceres/internal/ceres/graph.h
extern/libmv/third_party/ceres/internal/ceres/graph_algorithms.h
extern/libmv/third_party/ceres/internal/ceres/householder_vector.h [new file with mode: 0644]
extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.cc
extern/libmv/third_party/ceres/internal/ceres/implicit_schur_complement.h
extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.cc [deleted file]
extern/libmv/third_party/ceres/internal/ceres/incomplete_lq_factorization.h [deleted file]
extern/libmv/third_party/ceres/internal/ceres/integral_types.h
extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.cc
extern/libmv/third_party/ceres/internal/ceres/iterative_schur_complement_solver.h
extern/libmv/third_party/ceres/internal/ceres/lapack.cc
extern/libmv/third_party/ceres/internal/ceres/lapack.h
extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.cc
extern/libmv/third_party/ceres/internal/ceres/levenberg_marquardt_strategy.h
extern/libmv/third_party/ceres/internal/ceres/line_search.cc
extern/libmv/third_party/ceres/internal/ceres/line_search.h
extern/libmv/third_party/ceres/internal/ceres/line_search_direction.cc
extern/libmv/third_party/ceres/internal/ceres/line_search_direction.h
extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.cc
extern/libmv/third_party/ceres/internal/ceres/line_search_minimizer.h
extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.cc
extern/libmv/third_party/ceres/internal/ceres/line_search_preprocessor.h
extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.cc
extern/libmv/third_party/ceres/internal/ceres/linear_least_squares_problems.h
extern/libmv/third_party/ceres/internal/ceres/linear_operator.cc
extern/libmv/third_party/ceres/internal/ceres/linear_operator.h
extern/libmv/third_party/ceres/internal/ceres/linear_solver.cc
extern/libmv/third_party/ceres/internal/ceres/linear_solver.h
extern/libmv/third_party/ceres/internal/ceres/local_parameterization.cc
extern/libmv/third_party/ceres/internal/ceres/loss_function.cc
extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.cc
extern/libmv/third_party/ceres/internal/ceres/low_rank_inverse_hessian.h
extern/libmv/third_party/ceres/internal/ceres/map_util.h
extern/libmv/third_party/ceres/internal/ceres/minimizer.cc
extern/libmv/third_party/ceres/internal/ceres/minimizer.h
extern/libmv/third_party/ceres/internal/ceres/mutex.h
extern/libmv/third_party/ceres/internal/ceres/normal_prior.cc
extern/libmv/third_party/ceres/internal/ceres/parameter_block.h
extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.cc
extern/libmv/third_party/ceres/internal/ceres/parameter_block_ordering.h
extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.cc
extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view.h
extern/libmv/third_party/ceres/internal/ceres/partitioned_matrix_view_impl.h
extern/libmv/third_party/ceres/internal/ceres/polynomial.cc
extern/libmv/third_party/ceres/internal/ceres/polynomial.h
extern/libmv/third_party/ceres/internal/ceres/preconditioner.cc
extern/libmv/third_party/ceres/internal/ceres/preconditioner.h
extern/libmv/third_party/ceres/internal/ceres/preprocessor.cc
extern/libmv/third_party/ceres/internal/ceres/preprocessor.h
extern/libmv/third_party/ceres/internal/ceres/problem.cc
extern/libmv/third_party/ceres/internal/ceres/problem_impl.cc
extern/libmv/third_party/ceres/internal/ceres/problem_impl.h
extern/libmv/third_party/ceres/internal/ceres/program.cc
extern/libmv/third_party/ceres/internal/ceres/program.h
extern/libmv/third_party/ceres/internal/ceres/program_evaluator.h
extern/libmv/third_party/ceres/internal/ceres/random.h
extern/libmv/third_party/ceres/internal/ceres/reorder_program.cc
extern/libmv/third_party/ceres/internal/ceres/reorder_program.h
extern/libmv/third_party/ceres/internal/ceres/residual_block.cc
extern/libmv/third_party/ceres/internal/ceres/residual_block.h
extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.cc
extern/libmv/third_party/ceres/internal/ceres/residual_block_utils.h
extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.cc
extern/libmv/third_party/ceres/internal/ceres/schur_complement_solver.h
extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.cc
extern/libmv/third_party/ceres/internal/ceres/schur_eliminator.h
extern/libmv/third_party/ceres/internal/ceres/schur_eliminator_impl.h
extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.cc
extern/libmv/third_party/ceres/internal/ceres/schur_jacobi_preconditioner.h
extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.cc
extern/libmv/third_party/ceres/internal/ceres/scratch_evaluate_preparer.h
extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.cc
extern/libmv/third_party/ceres/internal/ceres/single_linkage_clustering.h
extern/libmv/third_party/ceres/internal/ceres/small_blas.h
extern/libmv/third_party/ceres/internal/ceres/solver.cc
extern/libmv/third_party/ceres/internal/ceres/solver_utils.cc
extern/libmv/third_party/ceres/internal/ceres/solver_utils.h
extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/sparse_matrix.h
extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.cc
extern/libmv/third_party/ceres/internal/ceres/sparse_normal_cholesky_solver.h
extern/libmv/third_party/ceres/internal/ceres/split.cc
extern/libmv/third_party/ceres/internal/ceres/split.h
extern/libmv/third_party/ceres/internal/ceres/stl_util.h
extern/libmv/third_party/ceres/internal/ceres/stringprintf.cc
extern/libmv/third_party/ceres/internal/ceres/stringprintf.h
extern/libmv/third_party/ceres/internal/ceres/suitesparse.cc
extern/libmv/third_party/ceres/internal/ceres/suitesparse.h
extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.cc
extern/libmv/third_party/ceres/internal/ceres/triplet_sparse_matrix.h
extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.cc
extern/libmv/third_party/ceres/internal/ceres/trust_region_minimizer.h
extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.cc
extern/libmv/third_party/ceres/internal/ceres/trust_region_preprocessor.h
extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.cc
extern/libmv/third_party/ceres/internal/ceres/trust_region_strategy.h
extern/libmv/third_party/ceres/internal/ceres/types.cc
extern/libmv/third_party/ceres/internal/ceres/visibility.cc
extern/libmv/third_party/ceres/internal/ceres/visibility.h
extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.cc
extern/libmv/third_party/ceres/internal/ceres/visibility_based_preconditioner.h
extern/libmv/third_party/ceres/internal/ceres/wall_time.cc
extern/libmv/third_party/ceres/internal/ceres/wall_time.h

index 694982ec606ae4904135f8b64aa299bdbb738fb0..f9a7d0631c0d1ed8dd84a15ba3231ad2cac10a48 100644 (file)
@@ -80,7 +80,6 @@ set(SRC
        internal/ceres/gradient_problem.cc
        internal/ceres/gradient_problem_solver.cc
        internal/ceres/implicit_schur_complement.cc
-       internal/ceres/incomplete_lq_factorization.cc
        internal/ceres/iterative_schur_complement_solver.cc
        internal/ceres/lapack.cc
        internal/ceres/levenberg_marquardt_strategy.cc
@@ -209,7 +208,6 @@ set(SRC
        internal/ceres/graph_algorithms.h
        internal/ceres/graph.h
        internal/ceres/implicit_schur_complement.h
-       internal/ceres/incomplete_lq_factorization.h
        internal/ceres/integral_types.h
        internal/ceres/iterative_schur_complement_solver.h
        internal/ceres/lapack.h
@@ -270,6 +268,7 @@ if(WITH_LIBMV_SCHUR_SPECIALIZATIONS)
                internal/ceres/generated/partitioned_matrix_view_2_2_d.cc
                internal/ceres/generated/partitioned_matrix_view_2_3_3.cc
                internal/ceres/generated/partitioned_matrix_view_2_3_4.cc
+               internal/ceres/generated/partitioned_matrix_view_2_3_6.cc
                internal/ceres/generated/partitioned_matrix_view_2_3_9.cc
                internal/ceres/generated/partitioned_matrix_view_2_3_d.cc
                internal/ceres/generated/partitioned_matrix_view_2_4_3.cc
@@ -288,6 +287,7 @@ if(WITH_LIBMV_SCHUR_SPECIALIZATIONS)
                internal/ceres/generated/schur_eliminator_2_2_d.cc
                internal/ceres/generated/schur_eliminator_2_3_3.cc
                internal/ceres/generated/schur_eliminator_2_3_4.cc
+               internal/ceres/generated/schur_eliminator_2_3_6.cc
                internal/ceres/generated/schur_eliminator_2_3_9.cc
                internal/ceres/generated/schur_eliminator_2_3_d.cc
                internal/ceres/generated/schur_eliminator_2_4_3.cc
index b4f78ee073118d17bac3668e71c60fcedb0a7cbf..0e6c195174c06278cc4f80871ad782b22130ea2b 100644 (file)
-commit 0435246de5f45e69b2c97d244ed61bedd340215a
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Oct 8 18:12:53 2014 -0700
+commit aef9c9563b08d5f39eee1576af133a84749d1b48
+Author: Alessandro Gentilini <agentilini@gmail.com>
+Date:   Tue Oct 6 20:43:45 2015 +0200
 
-    Add seene to users.rst
+    Add test for Bessel functions.
     
-    Change-Id: If40726775a3d4b234b6e10517fe9943d122a3384
+    Change-Id: Ief5881e8027643d7ef627e60a88fdbad17f3d884
 
-commit fdf32b315f39553639f0becf078ad4eec763a10e
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Oct 8 16:04:32 2014 -0700
+commit 49c86018e00f196c4aa9bd25daccb9919917efee
+Author: Alessandro Gentilini <agentilini@gmail.com>
+Date:   Wed Sep 23 21:59:44 2015 +0200
 
-    Fix some errant tabs.
+    Add Bessel functions in order to use them in residual code.
     
-    Change-Id: Iaf1906eaade49467ba282656cf0a10879d258b1f
+    See "How can I use the Bessel function in the residual function?" at
+    https://groups.google.com/d/msg/ceres-solver/Vh1gpqac8v0/NIK1EiWJCAAJ
+    
+    Change-Id: I3e80d9f9d1cadaf7177076e493ff46ace5233b76
 
-commit 6768b3586a027bb850c0a50e2a27380f5d80142a
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Oct 8 12:48:16 2014 -0700
+commit dfb201220c034fde00a242d0533bef3f73b2907d
+Author: Simon Rutishauser <simon.rutishauser@pix4d.com>
+Date:   Tue Oct 13 07:33:58 2015 +0200
 
-    Minor cleanups in preparation for a release.
+    Make miniglog threadsafe on non-windows system by using
+    localtime_r() instead of localtime() for time formatting
     
-    1. Fix the release script to ignore the version.h checking.
-    2. Fix some ceres documentation formatting errors.
-    
-    Change-Id: I3fd6b85e771b242f463d6a36c3efd8d691f9242f
+    Change-Id: Ib8006c685cd8ed4f374893bef56c4061ca2c9747
 
-commit 7b6bd1cd31aa0b8cb7fb97600c1b9999846e3152
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Oct 2 16:16:26 2014 -0700
+commit 41455566ac633e55f222bce7c4d2cb4cc33d5c72
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Mon Sep 28 22:43:42 2015 +0100
 
-    Documentation update.
+    Remove link-time optimisation (LTO).
     
-    1. Complete restructuring of the documentation to account for
-       GradientProblemSolver.
-    2. Update the version history to account for changes since 1.9.0.
-    3. Add links and document the various examples that ship with ceres.
-    4. Documentation for GradientProblem GradientProblemSolver.
+    - On GCC 4.9+ although GCC supports LTO, it requires use of the
+      non-default gcc-ar & gcc-ranlib.  Whilst we can ensure Ceres is
+      compiled with these, doing so with GCC 4.9 causes multiple definition
+      linker errors of static ints inside Eigen when compiling the tests
+      and examples when they are not also built with LTO.
+    - On OS X (Xcode 6 & 7) after the latest update to gtest, if LTO
+      is used when compiling the tests (& examples), two tests fail
+      due to typeinfo::operator== (things are fine if only Ceres itself is
+      compiled with LTO).
+    - This patch disables LTO for all compilers. It should be revisited when
+      the performance is more stable across our supported compilers.
     
-    Change-Id: If3a18f2850cbc98be1bc34435e9ea468785b8b27
+    Change-Id: I17b52957faefbdeff0aa40846dc9b342db1b02e3
 
-commit b7d321f505e936b6c09aeb43ae3f7b1252388a95
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Fri Oct 3 15:47:59 2014 -0700
+commit 89c40005bfceadb4163bd16b7464b3c2ce740daf
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sun Sep 27 13:37:26 2015 +0100
 
-    Relax the warning/error handing in GCC.
+    Only use LTO when compiling Ceres itself, not tests or examples.
     
-    Thanks to Matthew Woehlke for suggesting this.
+    - If Ceres is built as a shared library, and LTO is enabled for Ceres
+      and the tests, then type_info::operator==() incorrectly returns false
+      in gtests' CheckedDowncastToActualType() in the following tests:
+    -- levenberg_marquardt_strategy_test.
+    -- gradient_checking_cost_function_test.
+      on at least Xcode 6 & 7 as reported here:
+      https://github.com/google/googletest/issues/595.
+    - This does not appear to be a gtest issue, but is perhaps an LLVM bug
+      or an RTTI shared library issue.  Either way, disabling the use of
+      LTO when compiling the test application resolves the issue.
+    - Allow LTO to be enabled for GCC, if it is supported.
+    - Add CMake function to allow easy appending to target properties s/t
+      Ceres library-specific compile flags can be iteratively constructed.
     
-    Change-Id: Iae754465c086b0841a7816df1a36781371d0dc9a
+    Change-Id: I923e6aae4f7cefa098cf32b2f8fc19389e7918c9
 
-commit 94c6e7d27b5d48d81ab54ed9cdcbc55c3c099311
+commit 0794f41cca440f7f65d9a44e671f66f6e498ef7c
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Oct 1 15:55:13 2014 -0700
+Date:   Sat Sep 26 14:10:15 2015 -0700
 
-    Improve multithreading when using inner iterations.
-    
-    Inner iterations by default would use problems where the evaluator
-    was configured to use exactly one thread for doing the evaluation.
-    This is fine when there are multiple inner iteration problems
-    being executed concurrently, but every now and then there are
-    problem decompositions where there is just one parameter block
-    in the current independent set and it touches every single
-    residual block. In such cases it is essential that the evaluator
-    be configured to use multiple threads.
+    Documentation updates.
     
-    We now pay attention to the size of the independent set and
-    dynamically configure the number of threads being used by the
-    outer loop and the evaluator loop.
+    1. Fix a typo in the Trust Region algorithm.
+    2. Add ARL in the list of users.
+    3. Update the version history.
     
-    Thanks to William Rucklidge for reporting this issue and providing
-    a test problem to debug.
-    
-    Change-Id: Iaff9a4ab6d2658cf7b61ea213575d23aab604e3b
+    Change-Id: Ic286e8ef1a71af07f3890b7592dd3aed9c5f87ce
 
-commit 9e11cd16d09403b9270e621e839d5948b6a74b8d
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Mon Sep 29 14:27:58 2014 -0700
+commit 90e32a8dc437dfb0e6747ce15a1f3193c13b7d5b
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Mon Sep 21 21:08:25 2015 +0100
 
-    Faster  BlockRandomAccessSparseMatrix::SymmetricRightMultiply.
-    
-    Trade a small amount of memory to improve the cache coherency of
-    the SymmetricRightMultiply operation.
+    Use old minimum iOS version flags on Xcode < 7.0.
     
-    The resulting code leads to a 10-20% speedup in the linear solver
-    end to end.
+    - The newer style, which are more specific and match the SDK names
+      are not available on Xcode < 7.0.
     
-    Change-Id: I8ab2fe152099e849b211b5b19e4ef9f03d8e7f1c
+    Change-Id: I2f07a0365183d2781157cdb05fd49b30ae001ac5
 
-commit 46b8461fd010c1e7ffce6bb2bdf8a84b659d5e09
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Mon Sep 29 15:10:58 2014 -0700
+commit 26cd5326a1fb99ae02c667eab9942e1308046984
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Mon Sep 21 10:16:01 2015 +0100
 
-    Various minor fixes from William Rucklidge.
+    Add gtest-specific flags when building/using as a shared library.
+    
+    - Currently these flags are only used to define the relevant DLL export
+      prefix for Windows.
     
-    Change-Id: Ibe731d5db374ad8ee148d62a9fdd8d726b607a3f
+    Change-Id: I0c05207b512cb4a985390aefc779b91febdabb38
 
-commit b44cfdef25f6bf0917a23b3fd65cce38aa6a3362
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Mon Sep 29 07:53:54 2014 -0700
+commit c4c79472112a49bc1340da0074af2d15b1c89749
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sun Sep 20 18:26:59 2015 +0100
 
-    Let ITERATIVE_SCHUR use an explicit Schur Complement matrix.
-    
-    Up till now ITERATIVE_SCHUR evaluates matrix-vector products
-    between the Schur complement and a vector implicitly by exploiting
-    the algebraic expression for the Schur complement.
-    
-    This cost of this evaluation scales with the number of non-zeros
-    in the Jacobian.
-    
-    For small to medium sized problems there is a sweet spot where
-    computing the Schur complement is cheap enough that it is much
-    more efficient to explicitly compute it and use it for evaluating
-    the matrix-vector products.
-    
-    This changes implements support for an explicit Schur complement
-    in ITERATIVE_SCHUR in combination with the SCHUR_JACOBI preconditioner.
-    
-    API wise a new bool Solver::Options::use_explicit_schur_complement
-    has been added.
-    
-    The implementation extends the SparseSchurComplementSolver to use
-    Conjugate Gradients.
-    
-    Example speedup:
-    
-    use_explicit_schur_complement = false
-    
-    Time (in seconds):
-    Preprocessor                            0.585
-    
-      Residual evaluation                   0.319
-      Jacobian evaluation                   1.590
-      Linear solver                        25.685
-    Minimizer                              27.990
-    
-    Postprocessor                           0.010
-    Total                                  28.585
+    Clean up iOS.cmake to use xcrun/xcodebuild & libtool.
     
-    use_explicit_schur_complement = true
+    - Substantial cleanup of iOS.cmake to use xcrun & xcodebuild to
+      determine the SDK & tool paths.
+    - Use libtool -static to link libraries instead of ar + ranlib, which
+      is not compatible with Xcode 7+, this change should be backwards
+      compatible to at least Xcode 6.
+    - Force locations of unordered_map & shared_ptr on iOS to work around
+      check_cxx_source_compiles() running in a forked CMake instance without
+      access to the variables (IOS_PLATFORM) defined by the user.
+    - Minor CMake style updates.
     
-    Time (in seconds):
-    Preprocessor                            0.638
-    
-      Residual evaluation                   0.318
-      Jacobian evaluation                   1.507
-      Linear solver                         5.930
-    Minimizer                               8.144
-    
-    Postprocessor                           0.010
-    Total                                   8.791
-    
-    Which indicates an end-to-end speedup of more than 3x, with the linear
-    solver being sped up by > 4x.
-    
-    The idea to explore this optimization was inspired by the recent paper:
-    
-    Mining structure fragments for smart bundle adjustment
-    L. Carlone, P. Alcantarilla, H. Chiu, K. Zsolt, F. Dellaert
-    British Machine Vision Conference, 2014
-    
-    which uses a more complicated algorithm to compute parts of the
-    Schur complement to speed up the matrix-vector product.
-    
-    Change-Id: I95324af0ab351faa1600f5204039a1d2a64ae61d
+    Change-Id: I5f83a60607db34d461ebe85f9dce861f53d98277
 
-commit 4ad91490827f2ebebcc70d17e63ef653bf06fd0d
+commit 155765bbb358f1d19f072a4b54825faf1c059910
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Sep 24 23:54:18 2014 -0700
+Date:   Wed Sep 16 06:56:08 2015 -0700
 
-    Simplify the Block Jacobi and Schur Jacobi preconditioners.
-    
-    1. Extend the implementation of BlockRandomAccessDiagonalMatrix
-    by adding Invert and RightMultiply methods.
+    Import the latest version of gtest and gmock.
     
-    2. Simplify the implementation of the Schur Jacobi preconditioner
-    using these new methods.
-    
-    3. Replace the custom storage used inside Block Jacobi preconditioner
-    with BlockRandomAccessDiagonalMatrix and simplify its implementation
-    too.
-    
-    Change-Id: I9d4888b35f0f228c08244abbdda5298b3ce9c466
+    Change-Id: I4b686c44bba823cab1dae40efa99e31340d2b52a
 
-commit 8f7be1036b853addc33224d97b92412b5a1281b6
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Mon Sep 29 08:13:35 2014 -0700
+commit 0c4647b8f1496c97c6b9376d9c49ddc204aa08dd
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Wed Sep 16 20:01:11 2015 +0100
 
-    Fix a formatting error TrustRegionMinimizer logging.
+    Remove FAQ about increasing inlining threshold for Clang.
     
-    Change-Id: Iad1873c51eece46c3fdee1356d154367cfd7925e
+    - Changing the inlining threshold for Clang as described has a minimal
+      effect on user performance.
+    - The problem that originally prompted the belief that it did was
+      due to an erroneous CXX flag configuration (in user code).
+    
+    Change-Id: I03017241c0f87b8dcefb8c984ec3b192afd97fc2
 
-commit c99872d48e322662ea19efb9010a62b7432687ae
+commit f4b768b69afcf282568f9ab3a3f0eb8078607468
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Sep 24 21:30:02 2014 -0700
+Date:   Mon Sep 14 13:53:24 2015 -0700
 
-    Add BlockRandomAccessSparseMatrix::SymmetricRightMultiply.
+    Lint changes from William Rucklidge
     
-    Change-Id: Ib06a22a209b4c985ba218162dfb6bf46bd93169e
+    Change-Id: I0dac2549a8fa2bfd12f745a8d8a0db623b7ec1ac
 
-commit d3ecd18625ba260e0d00912a305a448b566acc59
+commit 5f2f05c726443e35767d677daba6d25dbc2d7ff8
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Tue Sep 23 10:12:42 2014 -0700
+Date:   Fri Sep 11 22:19:38 2015 -0700
 
-    Add an explicit include for local_parameterization.h
+    Refactor system_test
+    
+    1. Move common test infrastructure into test_util.
+    2. system_test now only contains powells function.
+    3. Add bundle_adjustment_test.
     
-    Thanks to cooordz for reporting this.
+    Instead of a single function which computes everything,
+    there is now a test for each solver configuration which
+    uses the reference solution computed by the fixture.
     
-    Change-Id: I7d345404e362a94ff1eb433ad6b9dcc4960ba76d
+    Change-Id: I16a9a9a83a845a7aaf28762bcecf1a8ff5aee805
 
-commit 5dd76869cf45122c79579423f09e0de08cf04092
+commit 1936d47e213142b8bf29d3f548905116092b093d
 Author: Alex Stewart <alexs.mac@gmail.com>
-Date:   Fri Sep 19 16:08:25 2014 +0100
+Date:   Tue Sep 8 23:27:42 2015 +0100
 
-    Fix unused-function warning with Eigen < 3.2.2.
+    Revert increased inline threshold (iff Clang) to exported Ceres target.
     
-    - CreateBlockJacobian() is only ever used when Eigen >= 3.2.2 is
-      detected, but was previously defined whenever CERES_USE_EIGEN_SPARSE
-      was defined with no check on the Eigen version.
-    - This resulted in an unused-function compile warning that became an
-      error due to -Werror, preventing compilation when using Eigen < 3.2.2.
+    - Increasing the inline threshold results in very variable performance
+      improvements, and could potentially confuse users if they are trying
+      to set the inline threshold themselves.
+    - As such, we no longer export our inline threshold configuration for
+      Clang, but instead document how to change it in the FAQs.
     
-    Change-Id: I24628ff329f14b087ece66bf2626bdc0de4ba224
+    Change-Id: I88e2e0001e4586ba2718535845ed1e4b1a5b72bc
 
-commit 820cb7b14831aa03eca1e8186000cebfdf0a42f3
+commit a66d89dcda47cefda83758bfb9e7374bec4ce866
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Sep 17 09:46:08 2014 -0700
+Date:   Sat Sep 5 16:50:20 2015 -0700
 
-    Add solver_utils.cc to Android.mk
+    Get ready for 1.11.0RC1
+    
+    Update version numbers.
+    Drop CERES_VERSION_ABI macro.
     
-    Change-Id: I358522971711280f4362a1fa39b1568160e21e63
+    Change-Id: Ib3eadabb318afe206bb196a5221b195d26cbeaa0
 
-commit 092b94970a073f8b47179d96160226fc19095898
+commit 1ac3dd223c179fbadaed568ac532af4139c75d84
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Fri Sep 5 11:56:29 2014 -0700
+Date:   Sat Sep 5 15:30:01 2015 -0700
 
-    Add GradientProblem and GradientProblemSolver.
+    Fix a bug in CompressedRowSparseMatrix::AppendRows
     
-    The line search minimizer in Ceres does not require that the
-    problems that is solving is a sum of squares. Over the past
-    year there have been multiple requests to expose this algorithm
-    on its own so that it can be used to solve unconstrained
-    non-linear minimization problems on its own.
+    The test for CompressedRowSparseMatrix::AppendRows tries to add
+    a matrix of size zero, which results in an invalid pointer deferencing
+    even though that pointer is never written to.
     
-    With this change, a new optimization problem called
-    GradientProblem is introduced which is basically a thin
-    wrapper around a user defined functor that evaluates cost
-    and gradients (FirstOrderFunction) and an optional LocalParameterization.
-    
-    Corresponding to it, a GradientProblemSolver and its associated
-    options and summary structs are introduced too.
-    
-    An example that uses the new API to find the minimum of Rosenbrock's
-    function is also added.
-    
-    Change-Id: I42bf687540da25de991e9bdb00e321239244e8b4
+    Change-Id: I97dba37082bd5dad242ae1af0447a9178cd92027
 
-commit 6c45d6b891aac01489b478a021f99081c61792cb
+commit 67622b080c8d37b5e932120a53d4ce76b80543e5
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Sep 11 07:48:30 2014 -0700
+Date:   Sat Sep 5 13:18:38 2015 -0700
 
-    Add more inspection methods to Problem.
-    
-    Problem::GetCostFunctionForResidualBlock
-    Problem::GetLossFunctionForResidualBlock
+    Fix a pointer access bug in Ridders' algorithm.
     
-    are added, so that users do not have to maintain this mapping
-    outside the Problem.
+    A pointer to an Eigen matrix was being used as an array.
     
-    Change-Id: I38356dfa094b2c7eec90651dafeaf3a33c5f5f56
+    Change-Id: Ifaea14fa3416eda5953de49afb78dc5a6ea816eb
 
-commit 6ad9b8e2ae66c9009441d0f9304486ec8dfa9a6a
+commit 5742b7d0f14d2d170054623ccfee09ea214b8ed9
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Tue Sep 9 14:29:28 2014 -0700
+Date:   Wed Aug 26 09:24:33 2015 -0700
 
-    Ignore row/column blocks structure when using dynamic sparsity
+    Improve performance of SPARSE_NORMAL_CHOLESKY + dynamic_sparsity
     
-    The row/column blocks can be huge when using dynamic sparsity. This
-    can result in very large memory usage when augmenting the jacobian
-    with the LM diagonal.
+    The outer product computation logic in SparseNormalCholeskySolver
+    does not work well with dynamic sparsity. The overhead of computing
+    the sparsity pattern of the normal equations is only amortized if
+    the sparsity is constant. If the sparsity can change from call to call
+    SparseNormalCholeskySolver will actually be more expensive.
     
-    Thanks to Mingsong Dou for reporting this.
-    
-    Change-Id: I6aa140ceefa98389ae17958f89ca76e0c76f95b8
+    For Eigen and for CXSparse we now explicitly compute the normal
+    equations using their respective matrix-matrix product routines and solve.
+    Change-Id: Ifbd8ed78987cdf71640e66ed69500442526a23d4
 
-commit 7e43460d42e20be1ba13121655dbbfd0d1c751ae
-Author: Martin Baeuml <baeuml@gmail.com>
-Date:   Mon Sep 8 16:49:06 2014 +0200
+commit d0b6cf657d6ef0dd739e958af9a5768f2eecfd35
+Author: Keir Mierle <mierle@gmail.com>
+Date:   Fri Sep 4 18:43:41 2015 -0700
 
-    Fix a few typos in the documentation.
+    Fix incorrect detect structure test
     
-    Change-Id: I541db56b2b81ae758e233ce850d78c3cbb4b6fa3
+    Change-Id: I7062f3639147c40b57947790d3b18331a39a366b
 
-commit 1aef66eeae7042902655a11b0d6a1a32900abb7b
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Sun Sep 7 21:18:44 2014 -0700
+commit 0e8264cc47661651a11e2dd8570c210082963545
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sat Aug 22 16:23:05 2015 +0100
 
-    Remove errant space.
+    Add increased inline threshold (iff Clang) to exported Ceres target.
     
-    Change-Id: Iedc06960417a9b938d57f623b4beb87a98e3d081
+    - When compiled with Clang, Ceres and all of the examples are compiled
+      with an increased inlining-threshold, as the default value can result
+      in poor Eigen performance.
+    - Previously, client code using Ceres would typically not use an
+      increased inlining-threshold (unless the user has specifically added
+      it themselves).  However, increasing the inlining threshold can result
+      in significant performance improvements in auto-diffed CostFunctions.
+    - This patch adds the inlining-threshold flags to the interface flags
+      for the Ceres CMake target s/t any client code using Ceres (via
+      CMake), and compiled with Clang, will now be compiled with the same
+      increased inlining threshold as used by Ceres itself.
+    
+    Change-Id: I31e8f1abfda140d22e85bb48aa57f028a68a415e
 
-commit 89080ab153a33008782759187fa8e9af7d2f83f1
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Sat Sep 6 21:13:48 2014 -0700
+commit a1b3fce9e0a4141b973f6b4dd9b08c4c13052d52
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Mon Aug 31 14:14:56 2015 +0100
 
-    Add LocalParameterization::MultiplyByJacobian.
-    
-    This is needed to efficiently support LocalParameterization objects
-    in GradientProblemSolver.
+    Add optional export of Ceres build directory to new features list.
     
-    Change-Id: Ic7b715b8be694b099dc95d6707a67474297533e6
+    Change-Id: I6f1e42b41957ae9cc98fd9dcd1969ef64c4cd96f
 
-commit d76da16f49d419ae3664ca1bdc2286c1ea78ebed
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Sun Sep 7 18:42:49 2014 -0700
+commit e46777d8df068866ef80902401a03e29348d11ae
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Mon Aug 31 12:41:54 2015 +0100
 
-    Move some routines to solver_utils.h/cc
-    
-    This moves a couple of routines from solver.cc into solver_utils.h/cc
-    so that they can also be used by the upcoming GradientProblemSolver.
+    Credit reporters of buildsystem bugs in version history.
     
-    Change-Id: I627b32ad3dc639422aacde78a8e391459d947e99
+    Change-Id: I16fe7973534cd556d97215e84268ae0b8ec4e11a
 
-commit cbf03ac292a0c0e9e6b7fcc1b08b67e95965922f
+commit 01548282cb620e5e3ac79a63a391cd0afd5433e4
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Sat Sep 6 21:07:08 2014 -0700
+Date:   Sun Aug 30 22:29:27 2015 -0700
 
-    Make LineSearchMinimizer consistent with TrustRegionMinimizer.
+    Update the version history.
     
-    Change the logic for how IterationSummary objects are added to
-    Summary::iterations to match the one in TrustRegionMinimizer.
-    
-    Change-Id: I57851ad8294e58f83b9115cca9c24695d86ee92a
+    Change-Id: I29873bed31675e0108f1a44f53f7bc68976b7f98
 
-commit f04c32319751e1efd610acd3699bca0a6dd6c6d1
+commit 2701429f770fce69ed0c77523fa43d7bc20ac6dc
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Sat Sep 6 21:05:41 2014 -0700
+Date:   Sun Aug 30 21:33:57 2015 -0700
 
-    Fix some obsolete documentation in CostFunction::Evaluate
+    Use Eigen::Dynamic instead of ceres::DYNAMIC in numeric_diff.h
     
-    Change-Id: I1d7ee5c596fbf6a4d886dce5b989c8eb18af2dce
+    Change-Id: Iccb0284a8fb4c2160748dfae24bcd595f1d4cb5c
 
-commit 9263547c02a1807532b159c217e7acd124d3db10
-Author: Johannes Schönberger <hannesschoenberger@gmail.com>
-Date:   Sat Sep 6 17:26:15 2014 -0400
+commit 4f049db7c2a3ee8cf9910c6eac96be6a28a5999c
+Author: Tal Ben-Nun <tbennun@gmail.com>
+Date:   Wed May 13 15:43:51 2015 +0300
 
-    Fix CG solver options for ITERATIVE_SCHUR, which did not copy min_num_iterations
+    Adaptive numeric differentiation using Ridders' method.
     
-    Change-Id: If31bc53b49ec20426fd438b79b8fa1f69d11e861
-
-commit b41f048256d1a8184cbe874b5a96dffa7fa4630d
-Author: Martin Baeuml <baeuml@gmail.com>
-Date:   Fri Sep 5 15:03:32 2014 +0200
-
-    Remove obsolete include of numeric_diff_functor.h.
+    This method numerically computes function derivatives in different
+    scales, extrapolating between intermediate results to conserve function
+    evaluations. Adaptive differentiation is essential to produce accurate
+    results for functions with noisy derivatives.
     
-    numeric_diff_functor.h was removed and does not exist anymore.
+    Full changelist:
+    -Created a new type of NumericDiffMethod (RIDDERS).
+    -Implemented EvaluateRiddersJacobianColumn in NumericDiff.
+    -Created unit tests with f(x) = x^2 + [random noise] and
+     f(x) = exp(x).
     
-    Change-Id: I07bf04bf81142551e867b95b83a0653e11cad54c
+    Change-Id: I2d6e924d7ff686650272f29a8c981351e6f72091
 
-commit b7fb6056a717cc3c372cfb7115c527ee8bc05ddb
+commit 070bba4b43b4b7449628bf456a10452fd2b34d28
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Sep 3 11:19:02 2014 -0700
+Date:   Tue Aug 25 13:37:33 2015 -0700
 
-    Remove NumericDiffFunctor.
+    Lint fixes from William Rucklidge
     
-    Its API was broken, and its implementation was an unnecessary
-    layer of abstraction over CostFunctionToFunctor.
-    
-    Change-Id: I18fc261fc6a3620b51a9eeb4dde0af03d753af69
+    Change-Id: I719e8852859c970091df842e59c44e02e2c65827
 
-commit 175fa8ff09049110a8509409f60cee5fd52cdbe6
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Tue Sep 2 06:49:08 2014 -0700
+commit 887a20ca7f02a1504e35f7cabbdfb2e0842a0b0b
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Wed Aug 12 21:41:43 2015 +0100
 
-    CostFunctionToFunctor allows dynamic number of residuals.
+    Build position independent code when compiling Ceres statically.
     
-    The code itself was perfectly capable of handling residuals, but there
-    was an overly strict runtime check that had to be removed.
+    - Previously, when Ceres was built as a static library we did not
+      compile position independent code.  This means that the resulting
+      static library could not be linked against shared libraries, but
+      could be used by executables.
+    - To enable the use of a static Ceres library by other shared libraries
+      as reported in [1], the static library must be generated from
+      position independent code (except on Windows, where PIC does not
+      apply).
     
-    Thanks to Domink Reitzle for reporting this.
+    [1] https://github.com/Itseez/opencv_contrib/pull/290#issuecomment-130389471
     
-    Change-Id: I6a6d000a7c5203dd5945a61b4caeda1b8aeb09c9
+    Change-Id: I99388f1784ece688f91b162d009578c5c97ddaf6
 
-commit 70ace0d5a5601901288974fcf27919754260cf0e
-Author: Johannes Schönberger <hannesschoenberger@gmail.com>
-Date:   Sat Aug 30 15:52:34 2014 -0400
-
-    Fix max. linear solver iterations in ConjugateGradientsSolver
-    
-    Change-Id: Ice0cef46441dbc1c121eeb42113667a46c96936f
-
-commit c5d8d0680250f5eb554577d30d28fc805b03fab9
+commit 860bba588b981a5718f6b73e7e840e5b8757fe65
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Fri Aug 29 20:31:19 2014 -0700
+Date:   Tue Aug 25 09:43:21 2015 -0700
 
-    Fix a unused function error with Eigen version 3.2.1 or less.
+    Fix a bug in DetectStructure
     
-    Thanks to Johannes Schoenberger  for reporting this.
+    The logic for determing static/dynamic f-block size in
+    DetectStructure was broken in a corner case, where the very first
+    row block which was used to initialize the f_block_size contained
+    more than one f blocks of varying sizes. The way the if block
+    was structured, no iteration was performed on the remaining
+    f-blocks and the loop failed to detect that the f-block size
+    was actually changing.
     
-    Change-Id: Ie17d28f2a68734a978a8c95007724bc4055de43a
-
-commit 0e1cc2a55488e4cf381833baaa3531c02ce9d69e
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Fri Aug 29 09:16:56 2014 -0700
-
-    Fix the build on Eigen version 3.2.1 and older.
+    If in the remaining row blocks, there were no row blocks
+    with varying f-block sizes, the function will erroneously
+    return a static f-block size.
+    
+    Thanks to Johannes Schonberger for providing a reproduction for this
+    rather tricky corner case.
     
-    Change-Id: I18f5cb5d42113737d7b8f78a67acee28bd5b3e08
+    Change-Id: Ib442a041d8b7efd29f9653be6a11a69d0eccd1ec
 
-commit 5f96c62b56222f27e606f2246a8a16b6942af8d1
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Aug 28 23:06:17 2014 -0700
+commit b0cbc0f0b0a22f01724b7b647a4a94db959cc4e4
+Author: Johannes Schönberger <hannesschoenberger@gmail.com>
+Date:   Thu Aug 20 14:21:30 2015 -0400
 
-    Add Block AMD ordering for SPARSE_SCHUR + EIGEN_SPARSE.
-    
-    Ordering routines for the Schur complement when using EIGEN_SPARSE.
-    Also integration into SchurComplementSolver.
-    
-    Part of this CL is also a refactoring of the block jacobian matrix
-    construction.
+    Reduce memory footprint of SubsetParameterization
     
-    Change-Id: I11d665cc7d4867c64190e6fed1118f4d2e13d59b
+    Change-Id: If113cb4696d5aef3e50eed01fba7a3d4143b7ec8
 
-commit 7344626c04d19ca1dc4871c377c4422c744b1bca
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Aug 28 22:03:09 2014 -0700
+commit ad2a99777786101411a971e59576ca533a297013
+Author: Sergey Sharybin <sergey.vfx@gmail.com>
+Date:   Sat Aug 22 11:18:45 2015 +0200
 
-    Let EIGEN_SPARSE + SPARSE_NORMAL_CHOLESKY use block AMD.
+    Fix for reoder program unit test when built without suitesparse
     
-    Modify SparseNormalCholeskySolver to use a pre-ordered Jacobian
-    matrix.
+    This commit fixes failure of reorder_program_test when Ceres is built without
+    any suitesparse.
     
-    Change-Id: Ib4d725d7a2d7bb94ea76dbb3a9b172784dbc8ea0
+    Change-Id: Ia23ae8dfd20c482cb9cd1301f17edf9a34df3235
 
-commit 9f7032369ea4e432f0fb507cb6d2209741ee6946
+commit 4bf3868beca9c17615f72ec03730cddb3676acaa
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Aug 28 21:46:43 2014 -0700
+Date:   Sun Aug 9 15:24:45 2015 -0700
 
-    Block AMD for SparseNormalCholesky + EIGEN_SPARSE.
+    Fix a bug in the Schur eliminator
     
-    This is just the reordering routine. The integration with
-    SparseNormalCholesky shall happen in a subsequent CL.
+    The schur eliminator treats rows with e blocks and row with
+    no e blocks separately. The template specialization logic only
+    applies to the rows with e blocks.
     
-    Change-Id: I39ddc32aa66b11c368faf75404850fa0ae0d2b3a
-
-commit b9331cd4077100d645be22a912d5743eeda72878
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Aug 28 14:42:27 2014 -0700
-
-    Cleanup reorder_program.cc
+    So, in cases where the rows with e-blocks have a fixed size f-block
+    but the rows without e-blocks have f-blocks of varying sizes,
+    DetectStructure will return a static f-block size, but we need to be
+    careful that we do not blindly use that static f-block size everywhere.
     
-    Program::SetParameterOffsetsAndIndex() was being called willy nilly.
-    Now the invariant is that any function that actually reorders the
-    program, updates the offsets and indices.
+    This patch fixes a bug where such care was not being taken, where
+    it was assumed that the static f-block size could be assumed for all
+    f-block sizes.
     
-    Also the logic around handling EIGEN_SPARSE has been simplified in
-    anticipation of the block AMD code that is forthcoming.
+    A new test is added, which triggers an exception in debug mode. In
+    release mode this error does not present itself, due to a peculiarity
+    of the way Eigen works.
     
-    Last but not the least, num_eliminate_blocks, which is a rather
-    cryptic name to begin with has been replaced by the more meaningful
-    size_of_first_elimination_group.
+    Thanks to Werner Trobin for reporting this bug.
     
-    Change-Id: I77e684f699a93b53e76aa406d64f40f8704df813
+    Change-Id: I8ae7aabf8eed8c3f9cf74b6c74d632ba44f82581
 
-commit 79491a3f4a3939a3cce4644da7a998b7782b963a
+commit 1635ce726078f00264b89d7fb6e76fd1c2796e59
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Aug 28 13:57:50 2014 -0700
+Date:   Wed Aug 19 00:26:02 2015 -0700
 
-    Solver::FullReport now reports build config.
+    Fix a bug in the reordering code.
     
-    The header of Summary::FullReport now looks like
+    When the user provides an ordering which starts at a non-zero group id,
+    or has gaps in the groups, then CAMD, the algorithm used to reorder
+    the program can crash or return garbage results.
     
-    Solver Summary (v 1.10.0-suitesparse-cxsparse-lapack-no_openmp)
+    The solution is to map the ordering into grouping constraints, and then
+    to re-number the groups to be contiguous using a call to
+    MapValuesToContiguousRange. This was already done for CAMD based
+    ordering for Schur type solvers, but was not done for SPARSE_NORMAL_CHOLESKY.
     
-                                         Original                  Reduced
-    Parameter blocks                        22122                    22122
-    Parameters                              66462                    66462
-    Residual blocks                         83718                    83718
-    Residual                               167436                   167436
+    Thanks to Bernhard Zeisl for not only reporting the bug but also
+    providing a reproduction.
     
-    Change-Id: Id1b81bbf90ba412d19e2dd3687eeb9d372b72c1b
+    Change-Id: I5cfae222d701dfdb8e1bda7f0b4670a30417aa89
 
-commit 48068c753e91d77f6c96ef2d529a27ef8ee3947c
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Aug 28 13:03:40 2014 -0700
+commit 4c3f8987e7f0c51fd367cf6d43d7eb879e79589f
+Author: Simon Rutishauser <simon.rutishauser@pix4d.com>
+Date:   Thu Aug 13 11:10:44 2015 +0200
 
-    Lint cleanup from William Rucklidge.
+    Add missing CERES_EXPORT to ComposedLoss
     
-    Change-Id: Ie0e0aa58440be7a4f67dcd633dbb6f1bb0c051a8
+    Change-Id: Id7db388d41bf53e6e5704039040c9d2c6bf4c29c
 
-commit 6a51b135e6298e8ba44a58cc2b54a170ab61a82f
+commit 1a740cc787b85b883a0703403a99fe49662acb79
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Aug 28 10:48:29 2014 -0700
+Date:   Tue Aug 11 18:08:05 2015 -0700
 
-    Fix solver_test.cc
+    Add the option to use numeric differentiation to nist and more_garbow_hillstrom
     
-    When Eigen is not installed, Solver::IsValid was not detecting
-    it correctly.
-    
-    Change-Id: Id285a84d829a9e20bc5de663adfca66ac31e08f3
+    Change-Id: If0a5caef90b524dcf5e2567c5b681987f5459401
 
-commit 62a8d64453ee41dae56710a4eead3fadf2fe1a4e
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Aug 27 22:54:00 2014 -0700
+commit ea667ede5c038d6bf3d1c9ec3dbdc5072d1beec6
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sun Aug 9 16:56:13 2015 +0100
 
-    Expand check for lack of a sparse linear algebra library.
-    
-    The LinearSolver factory was creating a NULL linear solver
-    if only Eigen's sparse linear algebra backend was available.
+    Fix EIGENSPARSE option help s/t it displays in CMake ncurses GUI.
     
-    Thanks to Michael Samples and Domink Reitzle for reporting this.
+    - Shorten description for EIGENSPARSE to a single line, as otherwise
+      it is not correctly displayed in the ncurses CMake GUI.
+    - Made explicit in description that this results in an LGPL licensed
+      version of Ceres (this is also made clear in the CMake log output if
+      EIGENSPARSE is enabled).
     
-    Change-Id: I35e3a6c0fd0da2a31934adb5dfe4cad29577cc73
+    Change-Id: I11678a9cbc7a817133c22128da01055a3cb8a26d
 
-commit 12eb389b4ec4113a2260c1a192a1d3f8d1b6a2d3
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Aug 27 22:18:33 2014 -0700
+commit a14ec27fb28ab2e8d7f1c9d88e41101dc6c0aab5
+Author: Richard Stebbing <richie.stebbing@gmail.com>
+Date:   Fri Aug 7 08:42:03 2015 -0700
 
-    Fix Eigen Row/ColMajor bug in NumericDiffCostFunction.
+    Fix SparseNormalCholeskySolver with dynamic sparsity.
     
-    If the parameter block size is 1, asking Eigen to create
-    a row-major matrix triggers a compile time error. Previously
-    we were handling the case where the number of rows in the
-    jacobian block was known statically, but the problem is present
-    when the nummber of rows is dynamic.
+    The previous implementation incorrectly cached the outer product matrix
+    pattern even when `dynamic_sparsity = true`.
     
-    This CL fixes this problem.
+    Change-Id: I1e58315a9b44f2f457d07c56b203ab2668bfb8a2
+
+commit 3dd7fced44ff00197fa9fcb1f2081d12be728062
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sun Aug 9 16:38:50 2015 +0100
+
+    Remove legacy dependency detection macros.
     
-    Thanks to Dominik Reitzle for reporting this.
+    - Before the new CMake buildsystem in 1.8, Ceres used non-standard
+      HINTS variables for dependencies.  For backwards compatibility CMake
+      macros were added to translate these legacy variables into the new
+      (standard) variables.
+    - As it has now been multiple releases since the legacy variables
+      were used and they no longer appear in any of the documentation
+      support for them has now expired.
     
-    Change-Id: I99c3eec3558e66ebf4efa51c4dee8ce292ffe0c1
+    Change-Id: I2cc72927ed711142ba7943df334ee008181f86a2
 
-commit 6c25185bb1643d8d0f3d8e1a7b82a058156aa869
+commit 8b32e258ccce1eed2a50bb002add16cad13aff1e
 Author: Alex Stewart <alexs.mac@gmail.com>
-Date:   Thu Aug 28 16:07:51 2014 +0100
+Date:   Sun Aug 9 15:42:39 2015 +0100
 
-    Fix crash in Covariance if # threads > 1 requested without OpenMP.
+    Fix failed if() condition expansion if gflags is not found.
     
-    - Previously if options.num_threads > 1 was given to Covariance compiled
-      without OpenMP, a CHECK() would be triggered in program_evalutor.
+    - If a CMake-ified version of gflags is not detected, then
+      gflags_LIBRARIES is not set and the TARGET condition within a
+      multiconditional if() statement prevents configuration.
     
-    Change-Id: Iaade4f5ed5326b0c59a7014c750c41ee026e1124
+    Change-Id: Ia92e97523d7a1478ab36539726b9540d7cfee5d0
 
-commit 6f89d850fb4ace0104abccf467c4fe37ad378b79
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Aug 27 11:51:50 2014 -0700
+commit cc8d47aabb9d63ba4588ba7295058a6191c2df83
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sun Aug 9 15:18:42 2015 +0100
 
-    Further build breakage fixes.
+    Update all CMake to lowercase function name style.
     
-    1. Allow the minimum number of linear solver iterations to be zero.
-    2. Fix conjugate gradients solver's iteration loop to be sane again.
+    - Updated to new CMake style where function names are all lowercase,
+      this will be backwards compatible as CMake function names are
+      case insensitive.
+    - Updated using Emacs' M-x unscreamify-cmake-buffer.
     
-    Change-Id: I8594815fec940c2b30e28eb58ec5d8baacf13dae
+    Change-Id: If7219816f560270e59212813aeb021353a64a0e2
 
-commit dd596d0f0d6d08951efc2c11a639b546db2080c6
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Wed Aug 27 11:26:50 2014 -0700
+commit 1f106904c1f47460c35ac03258d6506bb2d60838
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sun Aug 9 14:55:02 2015 +0100
 
-    Fix the broken build.
+    Update minimum iOS version to 7.0 for shared_ptr/unordered_map.
+    
+    - In order to correctly detect shared_ptr (& unordered_map)
+      the iOS version must be >= 7.0 (Xcode 5.0+).  This only affects the
+      SIMULATOR(64) platform builds, as the OS (device) build uses the
+      latest SDK which is now likely 8.0+.
     
-    Change-Id: I083cf1cca1bf4cca956193022d450364e73f833a
+    Change-Id: Iefec8f03408b8cdc7a495f442ebba081f800adb0
 
-commit d906afae22b05b9b9a9a2657924f4c0bf1a9b5ea
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Mon Aug 25 22:32:38 2014 -0700
+commit 16ecd40523a408e7705c9fdb0e159cef2007b8ab
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sat Aug 8 17:32:31 2015 +0100
 
-    A number of bug fixes.
+    Fix bug in gflags' <= 2.1.2 exported CMake configuration.
     
-    1. Fix a build breakage in graph_test.
-    2. Respect Solver::Options::min_num_linear_solver_iterations in
-       conjugate_gradients_solver.cc
+    - gflags <= 2.1.2 has a bug in its exported gflags-config.cmake:
+      https://github.com/gflags/gflags/issues/110 whereby it sets
+      gflags_LIBRARIES to a non-existent 'gflags' target.
+    - This causes linker errors if gflags is installed in a non-standard
+      location (as otherwise CMake resolves gflags to -lgflags which
+      links if gflags is installed somewhere on the current path).
+    - We now check for this case, and search for the correct gflags imported
+      target and update gflags_LIBRARIES to reference it if found, otherwise
+      proceed on to the original manual search to try to find gflags.
     
-    Thanks to Johannes Schönberger for reporting these.
-    
-    Change-Id: Ib32e3929bf5d92dd576ae5b53d4d88797095136e
+    Change-Id: Iceccc3ee53c7c2010e41cc45255f966e7b13d526
 
-commit dab955928c6d0942d6acc5b5f1c4c11260d0767d
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Sun Aug 17 13:14:50 2014 -0700
+commit 56be8de007dfd65ed5a31c795eb4a08ad765f411
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Thu Jun 25 21:31:00 2015 +0100
 
-    Add an unweighted graph.
-    
-    Rename Graph -> WeightedGraph.
-    Add a new Graph class, which is cheaper to construct and
-    work with if the weights are not needed.
+    Add docs for new CXX11 option & mask option for Windows.
     
-    This cuts down the cost of building the Hessian graph
-    significantly.
+    - The CXX11 option has no effect on Windows, as there, any new C++11
+      features are enabled by default, as such to avoid confusion we only
+      present the option for non-Windows.
     
-    Change-Id: Id0cfc81dd2c0bb5ff8f63a1b55aa133c53c0c869
+    Change-Id: I38925ae3bb8c16682d404468ba95c611a519b9b9
 
-commit a0c282adbd268c2ad82551fab31fe1cf8d0c4282
+commit cf863b6415ac4dbf3626e70adeac1ac0f3d87ee5
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Sun Aug 24 22:19:03 2014 -0700
+Date:   Thu Aug 6 14:52:18 2015 -0700
 
-    Add EIGEN_STRONG_INLINE annotation to jet.h
+    Remove the spec file needed for generating RPMs.
     
-    This improves performance when using MSVC on Windows. On GCC
-    there will be no effect.
+    Now that ceres is part of RawHide, there is no need to carry
+    this spec file with the ceres distribution.
     
-    Change-Id: I555a81ff6823c2855d64773073f75af50c48d716
+    Change-Id: Icc400b9874ba05ba05b353e2658f1de94c72299e
 
-commit 20de0a7793c574e964350a623446136889f74632
-Author: Björn Piltz <bjornpiltz@gmail.com>
-Date:   Mon Aug 25 17:05:54 2014 +0200
+commit 560940fa277a469c1ab34f1aa303ff1af9c3cacf
+Author: Sameer Agarwal <sameeragarwal@google.com>
+Date:   Sat Jul 11 22:21:31 2015 -0700
 
-    Fixed Malformed regex
+    A refactor of the cubic interpolation code
     
-    I got the following error with MSVC:
-    Syntax error at index 9 in simple regular expression "NumGroups()": '(' is unsupported.
+    1. Push the boundary handling logic into the underlying array
+    object. This has two very significant impacts:
     
-    Change-Id: Id1952831d81d3eb5d73bbed8c311914c4c8ab51f
+    a. The interpolation code becomes extremely simple to write
+    and to test.
+    
+    b. The user has more flexibility in implementing how out of bounds
+    values are handled. We provide one default implementation.
+    
+    Change-Id: Ic2f6cf9257ce7110c62e492688e5a6c8be1e7df2
 
-commit ccf8aea988269841d84d746e52164d5056c67a10
-Author: Björn Piltz <bjornpiltz@gmail.com>
-Date:   Mon Aug 25 16:16:01 2014 +0200
+commit dfdf19e111c2b0e6daeb6007728ec2f784106d49
+Author: Sameer Agarwal <sameeragarwal@google.com>
+Date:   Wed Aug 5 15:20:57 2015 -0700
 
-    Fixed MSVC error C2124: divide or mod by zero
-    
-    Alternatively, if quiet_NaN is not available on all platforms a workaround would be:
-        volatile double zero = 0.0;
-        double x = 1.0/zero;
-    The 'volatile' is needed to shut up "warning C4723: potential divide by 0".
+    Lint cleanup from Jim Roseborough
     
-    Change-Id: If2bbdab8540595aa2e0079e1eb6b6fed6d4a6ef7
+    Change-Id: Id6845c85644d40e635ed196ca74fc51a387aade4
 
-commit 8de27be218d42b282d7f15867733ad07058b0887
+commit 7444f23ae245476a7ac8421cc2f88d6947fd3e5f
 Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Tue Aug 19 08:22:40 2014 -0700
+Date:   Mon Aug 3 12:22:44 2015 -0700
 
-    Fix a bug in TrustRegionPreprocessor
+    Fix a typo in small_blas.h
     
-    TrustRegionPreprocessor was not setting Minimizer::Options::is_constrained.
-    This meant that the line search for bounds constraints was not being
-    invoked for bounds constrained problems.
+    The reason this rather serious looking typo has not
+    caused any problems uptil now is because NUM_ROW_B is
+    computed but never actually used.
     
-    And some minor lint cleanup.
+    Thanks to Werner Trobin for pointing this out.
     
-    Change-Id: I18852cfaf1b33fd90b7d8c196f2063c128126658
+    Change-Id: Id2b4d9326ec21baec8a85423e3270aefbafb611e
 
-commit 1745dd615b3897a3ef9896acfdba67eee1739bf4
-Author: Sameer Agarwal <sameeragarwal@google.com>
-Date:   Thu Jun 5 21:30:13 2014 -0700
+commit 5a48b92123b30a437f031eb24b0deaadc8f60d26
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sat Jul 4 17:59:52 2015 +0100
 
-    Refactor SolverImpl.
-    
-    Replace SolverImpl with
+    Export Ceres build directory into local CMake package registry.
     
-     a. A minimizer specific preprocessor class.
-     b. A generic Solve function inside solver.cc
-     c. Presummarize and Postsummarize functions to handle
-        updates to the summary object.
+    - Optionally use CMake's export() functionality to export the Ceres
+      build directory as a package into the local CMake package registry.
+    - This enables the detection & use of Ceres from CMake *without*
+      requiring that Ceres be installed.
     
-    The existing SolverImpl class was a mixture of the above three
-    things and was increasingly complicated code to follow. This change,
-    breaks it into its three separate constituents, with the aims of
-    better separation of concerns and thus better testability and
-    reliability.
+    Change-Id: Ib5a7588446f490e1b405878475b6b1dd13accd1f
+
+commit d9790e77894ea99d38137d359d6118315b2d1601
+Author: Sameer Agarwal <sameeragarwal@google.com>
+Date:   Sun Jul 12 19:39:47 2015 -0700
+
+    Add ProductParameterization
     
-    The call to Solver::Solve() now consists of
+    Often a parameter block is the Cartesian product of a number of
+    manifolds. For example, a rigid transformation SE(3) = SO(3) x R^3
+    In such cases, where you have the local parameterization
+    of the individual manifolds available,
+    ProductParameterization can be used to construct a local
+    parameterization of the cartesian product.
     
-    1. Presummarize - summarize the given state of the problem and solver
-       options.
-    2. Preprocess - Setup everything that is needed to call the minimizer.
-       This includes, removing redundant parameter and residual blocks,
-       setting up the reordering for the linear solver, creating the
-       linear solver, evaluator, inner iteration minimizer etc.
-    3. Minimize.
-    4. Post summarize - summarize the result of the preprocessing and the
-       solve.
+    Change-Id: I4b5bcbd2407a38739c7725b129789db5c3d65a20
+
+commit 7b4fb69dad49eaefb5d2d47ef0d76f48ad7fef73
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Sun Jun 28 21:43:46 2015 +0100
+
+    Cleanup FindGflags & use installed gflags CMake config if present.
+    
+    - Split out gflags namespace detection methods:
+      check_cxx_source_compiles() & regex, into separate functions.
+    - Use installed/exported gflags CMake configuration (present for
+      versions >= 2.1) if available, unless user expresses a preference not
+      to, or specifies search directories, in which case fall back to manual
+      search for components.
+    -- Prefer installed gflags CMake configurations over exported gflags
+       build directories on all OSs.
+    - Remove custom version of check_cxx_source_compiles() that attempted
+      to force the build type of the test project.  This only worked for
+      NMake on Windows, not MSVC as msbuild ignored our attempts to force
+      the build type.  Now we always use the regex method on Windows if
+      we cannot find an installed gflags CMake configuration which works
+      even on MSVC by bypassing msbuild.
+    - Add default search paths for gflags on Windows.
+    
+    Change-Id: I083b267d97a7a5838a1314f3d41a61ae48d5a2d7
+
+commit b3063c047906d4a44503dc0187fdcbbfcdda5f38
+Author: Alex Stewart <alexs.mac@gmail.com>
+Date:   Wed Jul 15 20:56:56 2015 +0100
+
+    Add default glog install location on Windows to search paths.
     
-    Change-Id: I80f35cfc9f2cbf78f1df4aceace27075779d8a3a
+    Change-Id: I083d368be48986e6780c11460f5a07b2f3b6c900
index f53d54ba94b9a2b3684939441ec2da20e050db1c..7b46083f38628472e007e72d203e8daf42b6c274 100644 (file)
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/env python
 
 # NOTE: This file is automatically generated by bundle.sh script
 #       If you're doing changes in this file, please update template
index 0becc87dd4faed2d9e478d1f6f8d188056b7e0ce..0418356c6f497d0db022453c34f5c167024f4c86 100755 (executable)
@@ -129,7 +129,7 @@ set(INC
 )
 
 set(INC_SYS
-       ${EIGEN3_INCLUDE_DIRS}
+       \${EIGEN3_INCLUDE_DIRS}
 )
 
 set(SRC
index c9d2c16e86588148f48a76cf9d32632ac509b9c0..1cf034ded5ffcdb52be079c16e947ef63275775d 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 
 // Default (empty) configuration options for Ceres.
 //
-// IMPORTANT: Most users of Ceres will not use this file, when compiling Ceres
-//            with CMake, CMake will configure a new config.h with the currently
-//            selected Ceres compile options and copy it into the source
-//            directory before compilation.  However, for some users of Ceres
-//            who compile without CMake, this file ensures that Ceres will
-//            compile, with the user either specifying manually the Ceres
-//            compile options, or passing them directly through the compiler.
+// IMPORTANT: Most users of Ceres will not use this file, when
+//            compiling Ceres with CMake, CMake will configure a new
+//            config.h with the currently selected Ceres compile
+//            options in <BUILD_DIR>/config, which will be added to
+//            the include path for compilation, and installed with the
+//            public Ceres headers.  However, for some users of Ceres
+//            who compile without CMake (Android), this file ensures
+//            that Ceres will compile, with the user either specifying
+//            manually the Ceres compile options, or passing them
+//            directly through the compiler.
 
 #ifndef CERES_PUBLIC_INTERNAL_CONFIG_H_
 #define CERES_PUBLIC_INTERNAL_CONFIG_H_
index d1bd69672c86a3da13c3eda90527ebdd48fb0545..976200b6229459cc751eaa31a4e1c254e91bc04c 100644 (file)
@@ -157,8 +157,6 @@ internal/ceres/graph_algorithms.h
 internal/ceres/graph.h
 internal/ceres/implicit_schur_complement.cc
 internal/ceres/implicit_schur_complement.h
-internal/ceres/incomplete_lq_factorization.cc
-internal/ceres/incomplete_lq_factorization.h
 internal/ceres/integral_types.h
 internal/ceres/iterative_schur_complement_solver.cc
 internal/ceres/iterative_schur_complement_solver.h
index 7c0fa79ad0b5e47e0b915ffb538778c17cf7d702..e7893e4828e0244842958ccd2ef731b6d78127ff 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index c100d4825d26287d66bcb37598b0d3f6f36ce062..27397e20d3b320a9b83dc92fa4c5cc07e2a04635 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -33,9 +33,9 @@
 #ifndef CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_
 #define CERES_PUBLIC_AUTODIFF_LOCAL_PARAMETERIZATION_H_
 
+#include "ceres/local_parameterization.h"
 #include "ceres/internal/autodiff.h"
 #include "ceres/internal/scoped_ptr.h"
-#include "ceres/local_parameterization.h"
 
 namespace ceres {
 
index 71f41fd226b7f41b9c05eac9f6575ffb265ca3b5..df7c9b6d671e85217e1bdcc2879cf5d721a18af8 100644 (file)
@@ -1,6 +1,6 @@
 /* Ceres Solver - A fast non-linear least squares minimizer
- * Copyright 2013 Google Inc. All rights reserved.
- * http://code.google.com/p/ceres-solver/
+ * Copyright 2015 Google Inc. All rights reserved.
+ * http://ceres-solver.org/
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
index 7c8981e29945a03fe7441a426fe94a6d7ba3ad1e..64ffb99798a1f4e466d4a156947483443ca41bdc 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 3f0087c781566368fdf4e1d14b460d9f3beb84b0..29597d935cbba61edb15f3ffb99cd901438a0f93 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -78,7 +78,7 @@ class CERES_EXPORT ConditionedCostFunction : public CostFunction {
   // functions, or not, depending on the ownership parameter. Conditioners
   // may be NULL, in which case the corresponding residual is not modified.
   ConditionedCostFunction(CostFunction* wrapped_cost_function,
-                          const vector<CostFunction*>& conditioners,
+                          const std::vector<CostFunction*>& conditioners,
                           Ownership ownership);
   virtual ~ConditionedCostFunction();
 
@@ -88,7 +88,7 @@ class CERES_EXPORT ConditionedCostFunction : public CostFunction {
 
  private:
   internal::scoped_ptr<CostFunction> wrapped_cost_function_;
-  vector<CostFunction*> conditioners_;
+  std::vector<CostFunction*> conditioners_;
   Ownership ownership_;
 };
 
index fe8fc07d2ce3d461ca5a7c70e03d04c03d673273..f051a897c0d917d2b4e45ca3e9b142c4cb2354fa 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -115,7 +115,7 @@ class CERES_EXPORT CostFunction {
                         double* residuals,
                         double** jacobians) const = 0;
 
-  const vector<int32>& parameter_block_sizes() const {
+  const std::vector<int32>& parameter_block_sizes() const {
     return parameter_block_sizes_;
   }
 
@@ -124,7 +124,7 @@ class CERES_EXPORT CostFunction {
   }
 
  protected:
-  vector<int32>* mutable_parameter_block_sizes() {
+  std::vector<int32>* mutable_parameter_block_sizes() {
     return &parameter_block_sizes_;
   }
 
@@ -135,7 +135,7 @@ class CERES_EXPORT CostFunction {
  private:
   // Cost function signature metadata: number of inputs & their sizes,
   // number of outputs (residuals).
-  vector<int32> parameter_block_sizes_;
+  std::vector<int32> parameter_block_sizes_;
   int num_residuals_;
   CERES_DISALLOW_COPY_AND_ASSIGN(CostFunction);
 };
index b4a516e0ab1f4b596e04e3655f1d991324ff5671..6c67ac0f9376e7530c218fb0469032403612132d 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -29,7 +29,7 @@
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 //
 // CostFunctionToFunctor is an adapter class that allows users to use
-// CostFunction objects in templated functors which are to be used for
+// SizedCostFunction objects in templated functors which are to be used for
 // automatic differentiation.  This allows the user to seamlessly mix
 // analytic, numeric and automatic differentiation.
 //
@@ -37,7 +37,7 @@
 //
 //  class IntrinsicProjection : public SizedCostFunction<2, 5, 3> {
 //    public:
-//      IntrinsicProjection(const double* observations);
+//      IntrinsicProjection(const double* observation);
 //      virtual bool Evaluate(double const* const* parameters,
 //                            double* residuals,
 //                            double** jacobians) const;
 // Then we can now do the following,
 //
 // struct CameraProjection {
-//   CameraProjection(double* observation) {
-//     intrinsic_projection_.reset(
-//         new CostFunctionToFunctor<2, 5, 3>(
-//             new IntrinsicProjection(observation_)));
+//   CameraProjection(const double* observation)
+//       : intrinsic_projection_(new IntrinsicProjection(observation)) {
 //   }
 //   template <typename T>
 //   bool operator()(const T* rotation,
 //     // Note that we call intrinsic_projection_, just like it was
 //     // any other templated functor.
 //
-//     return (*intrinsic_projection_)(intrinsics, transformed_point, residual);
+//     return intrinsic_projection_(intrinsics, transformed_point, residual);
 //   }
 //
 //  private:
-//   scoped_ptr<CostFunctionToFunctor<2,5,3> > intrinsic_projection_;
+//   CostFunctionToFunctor<2,5,3> intrinsic_projection_;
 // };
 
 #ifndef CERES_PUBLIC_COST_FUNCTION_TO_FUNCTOR_H_
@@ -93,6 +91,7 @@
 #include <vector>
 
 #include "ceres/cost_function.h"
+#include "ceres/dynamic_cost_function_to_functor.h"
 #include "ceres/internal/fixed_array.h"
 #include "ceres/internal/port.h"
 #include "ceres/internal/scoped_ptr.h"
@@ -104,28 +103,29 @@ template <int kNumResiduals,
           int N5 = 0, int N6 = 0, int N7 = 0, int N8 = 0, int N9 = 0>
 class CostFunctionToFunctor {
  public:
+  // Takes ownership of cost_function.
   explicit CostFunctionToFunctor(CostFunction* cost_function)
-  : cost_function_(cost_function) {
+      : cost_functor_(cost_function) {
     CHECK_NOTNULL(cost_function);
     CHECK(kNumResiduals > 0 || kNumResiduals == DYNAMIC);
 
     // This block breaks the 80 column rule to keep it somewhat readable.
     CHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
           ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))
+          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                                    // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                               // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||                          // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||                     // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||                // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||           // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||      // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))   // NOLINT
         << "Zero block cannot precede a non-zero block. Block sizes are "
         << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", "
         << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", "
         << N8 << ", " << N9;
 
-    const vector<int32>& parameter_block_sizes =
+    const std::vector<int32>& parameter_block_sizes =
         cost_function->parameter_block_sizes();
     const int num_parameter_blocks =
         (N0 > 0) + (N1 > 0) + (N2 > 0) + (N3 > 0) + (N4 > 0) +
@@ -160,7 +160,7 @@ class CostFunctionToFunctor {
     CHECK_EQ(N8, 0);
     CHECK_EQ(N9, 0);
 
-    return cost_function_->Evaluate(&x0, residuals, NULL);
+    return cost_functor_(&x0, residuals);
   }
 
   bool operator()(const double* x0,
@@ -179,7 +179,7 @@ class CostFunctionToFunctor {
     internal::FixedArray<const double*> parameter_blocks(2);
     parameter_blocks[0] = x0;
     parameter_blocks[1] = x1;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -200,7 +200,7 @@ class CostFunctionToFunctor {
     parameter_blocks[0] = x0;
     parameter_blocks[1] = x1;
     parameter_blocks[2] = x2;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -223,7 +223,7 @@ class CostFunctionToFunctor {
     parameter_blocks[1] = x1;
     parameter_blocks[2] = x2;
     parameter_blocks[3] = x3;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -248,7 +248,7 @@ class CostFunctionToFunctor {
     parameter_blocks[2] = x2;
     parameter_blocks[3] = x3;
     parameter_blocks[4] = x4;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -275,7 +275,7 @@ class CostFunctionToFunctor {
     parameter_blocks[3] = x3;
     parameter_blocks[4] = x4;
     parameter_blocks[5] = x5;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -304,7 +304,7 @@ class CostFunctionToFunctor {
     parameter_blocks[4] = x4;
     parameter_blocks[5] = x5;
     parameter_blocks[6] = x6;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -335,7 +335,7 @@ class CostFunctionToFunctor {
     parameter_blocks[5] = x5;
     parameter_blocks[6] = x6;
     parameter_blocks[7] = x7;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -368,7 +368,7 @@ class CostFunctionToFunctor {
     parameter_blocks[6] = x6;
     parameter_blocks[7] = x7;
     parameter_blocks[8] = x8;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   bool operator()(const double* x0,
@@ -403,7 +403,7 @@ class CostFunctionToFunctor {
     parameter_blocks[7] = x7;
     parameter_blocks[8] = x8;
     parameter_blocks[9] = x9;
-    return cost_function_->Evaluate(parameter_blocks.get(), residuals, NULL);
+    return cost_functor_(parameter_blocks.get(), residuals);
   }
 
   template <typename JetT>
@@ -418,7 +418,7 @@ class CostFunctionToFunctor {
     CHECK_EQ(N7, 0);
     CHECK_EQ(N8, 0);
     CHECK_EQ(N9, 0);
-    return EvaluateWithJets(&x0, residuals);
+    return cost_functor_(&x0, residuals);
   }
 
   template <typename JetT>
@@ -438,7 +438,7 @@ class CostFunctionToFunctor {
     internal::FixedArray<const JetT*> jets(2);
     jets[0] = x0;
     jets[1] = x1;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -460,7 +460,7 @@ class CostFunctionToFunctor {
     jets[0] = x0;
     jets[1] = x1;
     jets[2] = x2;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -484,7 +484,7 @@ class CostFunctionToFunctor {
     jets[1] = x1;
     jets[2] = x2;
     jets[3] = x3;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -510,7 +510,7 @@ class CostFunctionToFunctor {
     jets[2] = x2;
     jets[3] = x3;
     jets[4] = x4;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -538,7 +538,7 @@ class CostFunctionToFunctor {
     jets[3] = x3;
     jets[4] = x4;
     jets[5] = x5;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -568,7 +568,7 @@ class CostFunctionToFunctor {
     jets[4] = x4;
     jets[5] = x5;
     jets[6] = x6;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -600,7 +600,7 @@ class CostFunctionToFunctor {
     jets[5] = x5;
     jets[6] = x6;
     jets[7] = x7;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -634,7 +634,7 @@ class CostFunctionToFunctor {
     jets[6] = x6;
     jets[7] = x7;
     jets[8] = x8;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
   template <typename JetT>
@@ -670,79 +670,11 @@ class CostFunctionToFunctor {
     jets[7] = x7;
     jets[8] = x8;
     jets[9] = x9;
-    return EvaluateWithJets(jets.get(), residuals);
+    return cost_functor_(jets.get(), residuals);
   }
 
  private:
-  template <typename JetT>
-  bool EvaluateWithJets(const JetT** inputs, JetT* output) const {
-    const int kNumParameters =  N0 + N1 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9;
-    const vector<int32>& parameter_block_sizes =
-        cost_function_->parameter_block_sizes();
-    const int num_parameter_blocks = parameter_block_sizes.size();
-    const int num_residuals = cost_function_->num_residuals();
-
-    internal::FixedArray<double> parameters(kNumParameters);
-    internal::FixedArray<double*> parameter_blocks(num_parameter_blocks);
-    internal::FixedArray<double> jacobians(num_residuals * kNumParameters);
-    internal::FixedArray<double*> jacobian_blocks(num_parameter_blocks);
-    internal::FixedArray<double> residuals(num_residuals);
-
-    // Build a set of arrays to get the residuals and jacobians from
-    // the CostFunction wrapped by this functor.
-    double* parameter_ptr = parameters.get();
-    double* jacobian_ptr = jacobians.get();
-    for (int i = 0; i < num_parameter_blocks; ++i) {
-      parameter_blocks[i] = parameter_ptr;
-      jacobian_blocks[i] = jacobian_ptr;
-      for (int j = 0; j < parameter_block_sizes[i]; ++j) {
-        *parameter_ptr++ = inputs[i][j].a;
-      }
-      jacobian_ptr += num_residuals * parameter_block_sizes[i];
-    }
-
-    if (!cost_function_->Evaluate(parameter_blocks.get(),
-                                  residuals.get(),
-                                  jacobian_blocks.get())) {
-      return false;
-    }
-
-    // Now that we have the incoming Jets, which are carrying the
-    // partial derivatives of each of the inputs w.r.t to some other
-    // underlying parameters. The derivative of the outputs of the
-    // cost function w.r.t to the same underlying parameters can now
-    // be computed by applying the chain rule.
-    //
-    //  d output[i]               d output[i]   d input[j]
-    //  --------------  = sum_j   ----------- * ------------
-    //  d parameter[k]            d input[j]    d parameter[k]
-    //
-    // d input[j]
-    // --------------  = inputs[j], so
-    // d parameter[k]
-    //
-    //  outputJet[i]  = sum_k jacobian[i][k] * inputJet[k]
-    //
-    // The following loop, iterates over the residuals, computing one
-    // output jet at a time.
-    for (int i = 0; i < num_residuals; ++i) {
-      output[i].a = residuals[i];
-      output[i].v.setZero();
-
-      for (int j = 0; j < num_parameter_blocks; ++j) {
-        const int32 block_size = parameter_block_sizes[j];
-        for (int k = 0; k < parameter_block_sizes[j]; ++k) {
-          output[i].v +=
-              jacobian_blocks[j][i * block_size + k] * inputs[j][k].v;
-        }
-      }
-    }
-
-    return true;
-  }
-
- private:
-  internal::scoped_ptr<CostFunction> cost_function_;
+  DynamicCostFunctionToFunctor cost_functor_;
 };
 
 }  // namespace ceres
index 35fde4de05ddba17e3a5b2084fd4d3dcd79589b3..dd20dc36ba125bc59131cbcb6461af2a654b4c5d 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -183,7 +183,7 @@ class CovarianceImpl;
 //  Covariance::Options options;
 //  Covariance covariance(options);
 //
-//  vector<pair<const double*, const double*> > covariance_blocks;
+//  std::vector<std::pair<const double*, const double*> > covariance_blocks;
 //  covariance_blocks.push_back(make_pair(x, x));
 //  covariance_blocks.push_back(make_pair(y, y));
 //  covariance_blocks.push_back(make_pair(x, y));
@@ -353,10 +353,11 @@ class CERES_EXPORT Covariance {
   // Covariance::Options for more on the conditions under which this
   // function returns false.
   bool Compute(
-      const vector<pair<const double*, const double*> >& covariance_blocks,
+      const std::vector<std::pair<const double*,
+                                  const double*> >& covariance_blocks,
       Problem* problem);
 
-  // Return the block of the covariance matrix corresponding to
+  // Return the block of the cross-covariance matrix corresponding to
   // parameter_block1 and parameter_block2.
   //
   // Compute must be called before the first call to
@@ -373,6 +374,26 @@ class CERES_EXPORT Covariance {
                           const double* parameter_block2,
                           double* covariance_block) const;
 
+  // Return the block of the cross-covariance matrix corresponding to
+  // parameter_block1 and parameter_block2.
+  // Returns cross-covariance in the tangent space if a local
+  // parameterization is associated with either parameter block;
+  // else returns cross-covariance in the ambient space.
+  //
+  // Compute must be called before the first call to
+  // GetCovarianceBlock and the pair <parameter_block1,
+  // parameter_block2> OR the pair <parameter_block2,
+  // parameter_block1> must have been present in the vector
+  // covariance_blocks when Compute was called. Otherwise
+  // GetCovarianceBlock will return false.
+  //
+  // covariance_block must point to a memory location that can store a
+  // parameter_block1_local_size x parameter_block2_local_size matrix. The
+  // returned covariance will be a row-major matrix.
+  bool GetCovarianceBlockInTangentSpace(const double* parameter_block1,
+                                        const double* parameter_block2,
+                                        double* covariance_block) const;
+
  private:
   internal::scoped_ptr<internal::CovarianceImpl> impl_;
 };
index d2d62894194df8058c54f793ae844c89ca5fab71..23687c4670e2e0e0d4e085b8c9a9ee8a5553b3bb 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -74,9 +74,9 @@ struct CERES_EXPORT CRSMatrix {
   //  cols   = [ 1,  3,  1,  2,  3,  0,  1]
   //  values = [10,  4,  2, -3,  2,  1,  2]
 
-  vector<int> cols;
-  vector<int> rows;
-  vector<double> values;
+  std::vector<int> cols;
+  std::vector<int> rows;
+  std::vector<double> values;
 };
 
 }  // namespace ceres
index f9342cdbab93131ab3fd89bece70481320b3136d..e6d26111f1867eca7020eda7e8243e7068c4dea5 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -120,18 +120,18 @@ class DynamicAutoDiffCostFunction : public CostFunction {
                                                0);
 
     // Allocate scratch space for the strided evaluation.
-    vector<Jet<double, Stride> > input_jets(num_parameters);
-    vector<Jet<double, Stride> > output_jets(num_residuals());
+    std::vector<Jet<double, Stride> > input_jets(num_parameters);
+    std::vector<Jet<double, Stride> > output_jets(num_residuals());
 
     // Make the parameter pack that is sent to the functor (reused).
-    vector<Jet<double, Stride>* > jet_parameters(num_parameter_blocks,
+    std::vector<Jet<double, Stride>* > jet_parameters(num_parameter_blocks,
         static_cast<Jet<double, Stride>* >(NULL));
     int num_active_parameters = 0;
 
     // To handle constant parameters between non-constant parameter blocks, the
     // start position --- a raw parameter index --- of each contiguous block of
     // non-constant parameters is recorded in start_derivative_section.
-    vector<int> start_derivative_section;
+    std::vector<int> start_derivative_section;
     bool in_derivative_section = false;
     int parameter_cursor = 0;
 
diff --git a/extern/libmv/third_party/ceres/include/ceres/dynamic_cost_function_to_functor.h b/extern/libmv/third_party/ceres/include/ceres/dynamic_cost_function_to_functor.h
new file mode 100644 (file)
index 0000000..9339a50
--- /dev/null
@@ -0,0 +1,190 @@
+// Ceres Solver - A fast non-linear least squares minimizer
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors may be
+//   used to endorse or promote products derived from this software without
+//   specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: sameeragarwal@google.com (Sameer Agarwal)
+//         dgossow@google.com (David Gossow)
+//
+// DynamicCostFunctionToFunctor allows users to use CostFunction
+// objects in templated functors which are to be used for automatic
+// differentiation. It works similar to CostFunctionToFunctor, with the
+// difference that it allows you to wrap a cost function with dynamic numbers
+// of parameters and residuals.
+//
+// For example, let us assume that
+//
+//  class IntrinsicProjection : public CostFunction {
+//    public:
+//      IntrinsicProjection(const double* observation);
+//      virtual bool Evaluate(double const* const* parameters,
+//                            double* residuals,
+//                            double** jacobians) const;
+//  };
+//
+// is a cost function that implements the projection of a point in its
+// local coordinate system onto its image plane and subtracts it from
+// the observed point projection. It can compute its residual and
+// either via analytic or numerical differentiation can compute its
+// jacobians. The intrinsics are passed in as parameters[0] and the point as
+// parameters[1].
+//
+// Now we would like to compose the action of this CostFunction with
+// the action of camera extrinsics, i.e., rotation and
+// translation. Say we have a templated function
+//
+//   template<typename T>
+//   void RotateAndTranslatePoint(double const* const* parameters,
+//                                double* residuals);
+//
+// Then we can now do the following,
+//
+// struct CameraProjection {
+//   CameraProjection(const double* observation)
+//       : intrinsic_projection_.(new IntrinsicProjection(observation)) {
+//   }
+//   template <typename T>
+//   bool operator()(T const* const* parameters,
+//                   T* residual) const {
+//     const T* rotation = parameters[0];
+//     const T* translation = parameters[1];
+//     const T* intrinsics = parameters[2];
+//     const T* point = parameters[3];
+//     T transformed_point[3];
+//     RotateAndTranslatePoint(rotation, translation, point, transformed_point);
+//
+//     // Note that we call intrinsic_projection_, just like it was
+//     // any other templated functor.
+//     const T* projection_parameters[2];
+//     projection_parameters[0] = intrinsics;
+//     projection_parameters[1] = transformed_point;
+//     return intrinsic_projection_(projection_parameters, residual);
+//   }
+//
+//  private:
+//   DynamicCostFunctionToFunctor intrinsic_projection_;
+// };
+
+#ifndef CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_
+#define CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_
+
+#include <numeric>
+#include <vector>
+
+#include "ceres/cost_function.h"
+#include "ceres/internal/fixed_array.h"
+#include "ceres/internal/port.h"
+#include "ceres/internal/scoped_ptr.h"
+
+namespace ceres {
+
+class DynamicCostFunctionToFunctor {
+ public:
+  // Takes ownership of cost_function.
+  explicit DynamicCostFunctionToFunctor(CostFunction* cost_function)
+      : cost_function_(cost_function) {
+    CHECK_NOTNULL(cost_function);
+  }
+
+  bool operator()(double const* const* parameters, double* residuals) const {
+    return cost_function_->Evaluate(parameters, residuals, NULL);
+  }
+
+  template <typename JetT>
+  bool operator()(JetT const* const* inputs, JetT* output) const {
+    const std::vector<int32>& parameter_block_sizes =
+        cost_function_->parameter_block_sizes();
+    const int num_parameter_blocks = parameter_block_sizes.size();
+    const int num_residuals = cost_function_->num_residuals();
+    const int num_parameters = std::accumulate(parameter_block_sizes.begin(),
+                                               parameter_block_sizes.end(), 0);
+
+    internal::FixedArray<double> parameters(num_parameters);
+    internal::FixedArray<double*> parameter_blocks(num_parameter_blocks);
+    internal::FixedArray<double> jacobians(num_residuals * num_parameters);
+    internal::FixedArray<double*> jacobian_blocks(num_parameter_blocks);
+    internal::FixedArray<double> residuals(num_residuals);
+
+    // Build a set of arrays to get the residuals and jacobians from
+    // the CostFunction wrapped by this functor.
+    double* parameter_ptr = parameters.get();
+    double* jacobian_ptr = jacobians.get();
+    for (int i = 0; i < num_parameter_blocks; ++i) {
+      parameter_blocks[i] = parameter_ptr;
+      jacobian_blocks[i] = jacobian_ptr;
+      for (int j = 0; j < parameter_block_sizes[i]; ++j) {
+        *parameter_ptr++ = inputs[i][j].a;
+      }
+      jacobian_ptr += num_residuals * parameter_block_sizes[i];
+    }
+
+    if (!cost_function_->Evaluate(parameter_blocks.get(),
+                                  residuals.get(),
+                                  jacobian_blocks.get())) {
+      return false;
+    }
+
+    // Now that we have the incoming Jets, which are carrying the
+    // partial derivatives of each of the inputs w.r.t to some other
+    // underlying parameters. The derivative of the outputs of the
+    // cost function w.r.t to the same underlying parameters can now
+    // be computed by applying the chain rule.
+    //
+    //  d output[i]               d output[i]   d input[j]
+    //  --------------  = sum_j   ----------- * ------------
+    //  d parameter[k]            d input[j]    d parameter[k]
+    //
+    // d input[j]
+    // --------------  = inputs[j], so
+    // d parameter[k]
+    //
+    //  outputJet[i]  = sum_k jacobian[i][k] * inputJet[k]
+    //
+    // The following loop, iterates over the residuals, computing one
+    // output jet at a time.
+    for (int i = 0; i < num_residuals; ++i) {
+      output[i].a = residuals[i];
+      output[i].v.setZero();
+
+      for (int j = 0; j < num_parameter_blocks; ++j) {
+        const int32 block_size = parameter_block_sizes[j];
+        for (int k = 0; k < parameter_block_sizes[j]; ++k) {
+          output[i].v +=
+              jacobian_blocks[j][i * block_size + k] * inputs[j][k].v;
+        }
+      }
+    }
+
+    return true;
+  }
+
+ private:
+  internal::scoped_ptr<CostFunction> cost_function_;
+};
+
+}  // namespace ceres
+
+#endif  // CERES_PUBLIC_DYNAMIC_COST_FUNCTION_TO_FUNCTOR_H_
index 2b6e8260286585b3a60d8b2ea1d883d7e497380b..c852d57a3fcc123d2b26d532616c1f76b9ef37fd 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -29,6 +29,7 @@
 // Author: mierle@gmail.com (Keir Mierle)
 //         sameeragarwal@google.com (Sameer Agarwal)
 //         thadh@gmail.com (Thad Hughes)
+//         tbennun@gmail.com (Tal Ben-Nun)
 //
 // This numeric diff implementation differs from the one found in
 // numeric_diff_cost_function.h by supporting numericdiff on cost
@@ -41,7 +42,6 @@
 // numeric diff; the expected interface for the cost functors is:
 //
 //   struct MyCostFunctor {
-//     template<typename T>
 //     bool operator()(double const* const* parameters, double* residuals) const {
 //       // Use parameters[i] to access the i'th parameter block.
 //     }
 #include "ceres/internal/scoped_ptr.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/numeric_diff.h"
+#include "ceres/numeric_diff_options.h"
 #include "glog/logging.h"
 
 namespace ceres {
 
-template <typename CostFunctor, NumericDiffMethod method = CENTRAL>
+template <typename CostFunctor, NumericDiffMethodType method = CENTRAL>
 class DynamicNumericDiffCostFunction : public CostFunction {
  public:
-  explicit DynamicNumericDiffCostFunction(const CostFunctor* functor,
-                                          Ownership ownership = TAKE_OWNERSHIP,
-                                          double relative_step_size = 1e-6)
+  explicit DynamicNumericDiffCostFunction(
+      const CostFunctor* functor,
+      Ownership ownership = TAKE_OWNERSHIP,
+      const NumericDiffOptions& options = NumericDiffOptions())
       : functor_(functor),
         ownership_(ownership),
-        relative_step_size_(relative_step_size) {
+        options_(options) {
+  }
+
+  // Deprecated. New users should avoid using this constructor. Instead, use the
+  // constructor with NumericDiffOptions.
+  DynamicNumericDiffCostFunction(
+      const CostFunctor* functor,
+      Ownership ownership,
+      double relative_step_size)
+      : functor_(functor),
+        ownership_(ownership),
+        options_() {
+    LOG(WARNING) << "This constructor is deprecated and will be removed in "
+                    "a future version. Please use the NumericDiffOptions "
+                    "constructor instead.";
+
+    options_.relative_step_size = relative_step_size;
   }
 
   virtual ~DynamicNumericDiffCostFunction() {
@@ -100,11 +118,12 @@ class DynamicNumericDiffCostFunction : public CostFunction {
   virtual bool Evaluate(double const* const* parameters,
                         double* residuals,
                         double** jacobians) const {
+    using internal::NumericDiff;
     CHECK_GT(num_residuals(), 0)
         << "You must call DynamicNumericDiffCostFunction::SetNumResiduals() "
         << "before DynamicNumericDiffCostFunction::Evaluate().";
 
-    const vector<int32>& block_sizes = parameter_block_sizes();
+    const std::vector<int32>& block_sizes = parameter_block_sizes();
     CHECK(!block_sizes.empty())
         << "You must call DynamicNumericDiffCostFunction::AddParameterBlock() "
         << "before DynamicNumericDiffCostFunction::Evaluate().";
@@ -116,8 +135,8 @@ class DynamicNumericDiffCostFunction : public CostFunction {
 
     // Create local space for a copy of the parameters which will get mutated.
     int parameters_size = accumulate(block_sizes.begin(), block_sizes.end(), 0);
-    vector<double> parameters_copy(parameters_size);
-    vector<double*> parameters_references_copy(block_sizes.size());
+    std::vector<double> parameters_copy(parameters_size);
+    std::vector<double*> parameters_references_copy(block_sizes.size());
     parameters_references_copy[0] = &parameters_copy[0];
     for (int block = 1; block < block_sizes.size(); ++block) {
       parameters_references_copy[block] = parameters_references_copy[block - 1]
@@ -133,12 +152,18 @@ class DynamicNumericDiffCostFunction : public CostFunction {
 
     for (int block = 0; block < block_sizes.size(); ++block) {
       if (jacobians[block] != NULL &&
-          !EvaluateJacobianForParameterBlock(block_sizes[block],
-                                             block,
-                                             relative_step_size_,
+          !NumericDiff<CostFunctor, method, DYNAMIC,
+                       DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC,
+                       DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC, DYNAMIC,
+                       DYNAMIC, DYNAMIC>::EvaluateJacobianForParameterBlock(
+                                             functor_.get(),
                                              residuals,
+                                             options_,
+                                             this->num_residuals(),
+                                             block,
+                                             block_sizes[block],
                                              &parameters_references_copy[0],
-                                             jacobians)) {
+                                             jacobians[block])) {
         return false;
       }
     }
@@ -146,91 +171,6 @@ class DynamicNumericDiffCostFunction : public CostFunction {
   }
 
  private:
-  bool EvaluateJacobianForParameterBlock(const int parameter_block_size,
-                                         const int parameter_block,
-                                         const double relative_step_size,
-                                         double const* residuals_at_eval_point,
-                                         double** parameters,
-                                         double** jacobians) const {
-    using Eigen::Map;
-    using Eigen::Matrix;
-    using Eigen::Dynamic;
-    using Eigen::RowMajor;
-
-    typedef Matrix<double, Dynamic, 1> ResidualVector;
-    typedef Matrix<double, Dynamic, 1> ParameterVector;
-    typedef Matrix<double, Dynamic, Dynamic, RowMajor> JacobianMatrix;
-
-    int num_residuals = this->num_residuals();
-
-    Map<JacobianMatrix> parameter_jacobian(jacobians[parameter_block],
-                                           num_residuals,
-                                           parameter_block_size);
-
-    // Mutate one element at a time and then restore.
-    Map<ParameterVector> x_plus_delta(parameters[parameter_block],
-                                      parameter_block_size);
-    ParameterVector x(x_plus_delta);
-    ParameterVector step_size = x.array().abs() * relative_step_size;
-
-    // To handle cases where a paremeter is exactly zero, instead use
-    // the mean step_size for the other dimensions.
-    double fallback_step_size = step_size.sum() / step_size.rows();
-    if (fallback_step_size == 0.0) {
-      // If all the parameters are zero, there's no good answer. Use the given
-      // relative step_size as absolute step_size and hope for the best.
-      fallback_step_size = relative_step_size;
-    }
-
-    // For each parameter in the parameter block, use finite
-    // differences to compute the derivative for that parameter.
-    for (int j = 0; j < parameter_block_size; ++j) {
-      if (step_size(j) == 0.0) {
-        // The parameter is exactly zero, so compromise and use the
-        // mean step_size from the other parameters. This can break in
-        // many cases, but it's hard to pick a good number without
-        // problem specific knowledge.
-        step_size(j) = fallback_step_size;
-      }
-      x_plus_delta(j) = x(j) + step_size(j);
-
-      ResidualVector residuals(num_residuals);
-      if (!EvaluateCostFunctor(parameters, &residuals[0])) {
-        // Something went wrong; bail.
-        return false;
-      }
-
-      // Compute this column of the jacobian in 3 steps:
-      // 1. Store residuals for the forward part.
-      // 2. Subtract residuals for the backward (or 0) part.
-      // 3. Divide out the run.
-      parameter_jacobian.col(j).matrix() = residuals;
-
-      double one_over_h = 1 / step_size(j);
-      if (method == CENTRAL) {
-        // Compute the function on the other side of x(j).
-        x_plus_delta(j) = x(j) - step_size(j);
-
-        if (!EvaluateCostFunctor(parameters, &residuals[0])) {
-          // Something went wrong; bail.
-          return false;
-        }
-
-        parameter_jacobian.col(j) -= residuals;
-        one_over_h /= 2;
-      } else {
-        // Forward difference only; reuse existing residuals evaluation.
-        parameter_jacobian.col(j) -=
-            Map<const ResidualVector>(residuals_at_eval_point, num_residuals);
-      }
-      x_plus_delta(j) = x(j);  // Restore x_plus_delta.
-
-      // Divide out the run to get slope.
-      parameter_jacobian.col(j) *= one_over_h;
-    }
-    return true;
-  }
-
   bool EvaluateCostFunctor(double const* const* parameters,
                            double* residuals) const {
     return EvaluateCostFunctorImpl(functor_.get(),
@@ -257,7 +197,7 @@ class DynamicNumericDiffCostFunction : public CostFunction {
 
   internal::scoped_ptr<const CostFunctor> functor_;
   Ownership ownership_;
-  const double relative_step_size_;
+  NumericDiffOptions options_;
 };
 
 }  // namespace ceres
index da8a4d086b8ed70da58d7d11118926d3381aa1b4..bc2dc90026cdb4cb7be633ac22e3f164bde58c34 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -50,26 +50,9 @@ namespace ceres {
 inline bool IsFinite  (double x) { return _finite(x) != 0;                   }
 inline bool IsInfinite(double x) { return _finite(x) == 0 && _isnan(x) == 0; }
 inline bool IsNaN     (double x) { return _isnan(x) != 0;                    }
-inline bool IsNormal  (double x) {
-  int classification = _fpclass(x);
-  return classification == _FPCLASS_NN ||
-         classification == _FPCLASS_PN;
-}
-
-#elif defined(ANDROID) && defined(_STLPORT_VERSION)
-
-// On Android, when using the STLPort, the C++ isnan and isnormal functions
-// are defined as macros.
-inline bool IsNaN     (double x) { return isnan(x);    }
-inline bool IsNormal  (double x) { return isnormal(x); }
-// On Android NDK r6, when using STLPort, the isinf and isfinite functions are
-// not available, so reimplement them.
-inline bool IsInfinite(double x) {
-  return x ==  std::numeric_limits<double>::infinity() ||
-         x == -std::numeric_limits<double>::infinity();
-}
-inline bool IsFinite(double x) {
-  return !isnan(x) && !IsInfinite(x);
+inline bool IsNormal  (double x) {  // NOLINT
+  const int classification = _fpclass(x);
+  return (classification == _FPCLASS_NN || classification == _FPCLASS_PN);
 }
 
 # else
index 79ebae5f13e106cea5dbf30af7b0ab382dcf1b8d..28304159b449b931d2781ce2fb0fdc74d4f55ba1 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -78,10 +78,10 @@ class GradientChecker {
     // block.
 
     // Derivatives as computed by the cost function.
-    vector<Matrix> term_jacobians;
+    std::vector<Matrix> term_jacobians;
 
     // Derivatives as computed by finite differencing.
-    vector<Matrix> finite_difference_jacobians;
+    std::vector<Matrix> finite_difference_jacobians;
 
     // Infinity-norm of term_jacobians - finite_difference_jacobians.
     double error_jacobians;
@@ -119,7 +119,7 @@ class GradientChecker {
     // Do a consistency check between the term and the template parameters.
     CHECK_EQ(M, term->num_residuals());
     const int num_residuals = M;
-    const vector<int32>& block_sizes = term->parameter_block_sizes();
+    const std::vector<int32>& block_sizes = term->parameter_block_sizes();
     const int num_blocks = block_sizes.size();
 
     CHECK_LE(num_blocks, 5) << "Unable to test functions that take more "
index 55a8be1df09d2f9bfa657f0ded217a152af3ee06..1226a4cd8950af78fb6d2328bfccd8f5d5d53459 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index db706f7dbaf385bfb597ce188df7a296fc232460..a7d0121ea0c1b2decbae41b15ea077bfc41a41f3 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -81,7 +81,7 @@ class CERES_EXPORT GradientProblemSolver {
     // Returns true if the options struct has a valid
     // configuration. Returns false otherwise, and fills in *error
     // with a message describing the problem.
-    bool IsValid(string* error) const;
+    bool IsValid(std::string* error) const;
 
     // Minimizer options ----------------------------------------
     LineSearchDirectionType line_search_direction_type;
@@ -261,7 +261,7 @@ class CERES_EXPORT GradientProblemSolver {
     // executed, then set update_state_every_iteration to true.
     //
     // The solver does NOT take ownership of these pointers.
-    vector<IterationCallback*> callbacks;
+    std::vector<IterationCallback*> callbacks;
   };
 
   struct CERES_EXPORT Summary {
@@ -269,11 +269,11 @@ class CERES_EXPORT GradientProblemSolver {
 
     // A brief one line description of the state of the solver after
     // termination.
-    string BriefReport() const;
+    std::string BriefReport() const;
 
     // A full multiline description of the state of the solver after
     // termination.
-    string FullReport() const;
+    std::string FullReport() const;
 
     bool IsSolutionUsable() const;
 
@@ -281,7 +281,7 @@ class CERES_EXPORT GradientProblemSolver {
     TerminationType termination_type;
 
     // Reason why the solver terminated.
-    string message;
+    std::string message;
 
     // Cost of the problem (value of the objective function) before
     // the optimization.
@@ -292,7 +292,7 @@ class CERES_EXPORT GradientProblemSolver {
     double final_cost;
 
     // IterationSummary for each minimizer iteration in order.
-    vector<IterationSummary> iterations;
+    std::vector<IterationSummary> iterations;
 
     // Sum total of all time spent inside Ceres when Solve is called.
     double total_time_in_seconds;
@@ -303,6 +303,10 @@ class CERES_EXPORT GradientProblemSolver {
     // Time (in seconds) spent evaluating the gradient.
     double gradient_evaluation_time_in_seconds;
 
+    // Time (in seconds) spent minimizing the interpolating polynomial
+    // to compute the next candidate step size as part of a line search.
+    double line_search_polynomial_minimization_time_in_seconds;
+
     // Number of parameters in the probem.
     int num_parameters;
 
index 3a96625e3fdaac7e59473532c1b7070399a10cca..136152a36cdc2e01454961b80c72587465af4045 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -214,15 +214,15 @@ struct AutoDiff {
     // This block breaks the 80 column rule to keep it somewhat readable.
     DCHECK_GT(num_outputs, 0);
     DCHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||
-          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))
+           ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
+           ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                                   // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                              // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||                         // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||                    // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||               // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||          // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||     // NOLINT
+           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))  // NOLINT
         << "Zero block cannot precede a non-zero block. Block sizes are "
         << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", "
         << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", "
index 78924de134609c79f8d2e54f7610968ec19e0e98..094124f715911e591de7a98ed5f3a905d1d9544e 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 85df54b8f9967f3b977b7e09abae134aaa6a06e5..7138804ace471270864ad38bae177ff30cc3796d 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 694070b228c732f2dba7a0ce205ca48a50c8581a..387298c58d06866aa2368b0b2acdc3b5fdfef53e 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 1ed55be6e0332b5e6f1c6e613c2edbb6e57b1706..bebb965e25b4131707a1f0f54a19b22624d9aadf 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 7ea723d2a8385a2d745998c7dd41b1591aa1de7e..0d7633cef835edb2ffaed81e886f058f492745b4 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 3b264b45af3442827677392e2b18969e71caea01..11e8275b1d3019059c6559d7ef0d846257447989 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -28,8 +28,9 @@
 //
 // Author: sameeragarwal@google.com (Sameer Agarwal)
 //         mierle@gmail.com (Keir Mierle)
+//         tbennun@gmail.com (Tal Ben-Nun)
 //
-// Finite differencing routine used by NumericDiffCostFunction.
+// Finite differencing routines used by NumericDiffCostFunction.
 
 #ifndef CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_
 #define CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_
 #include <cstring>
 
 #include "Eigen/Dense"
+#include "Eigen/StdVector"
 #include "ceres/cost_function.h"
+#include "ceres/internal/fixed_array.h"
 #include "ceres/internal/scoped_ptr.h"
 #include "ceres/internal/variadic_evaluate.h"
+#include "ceres/numeric_diff_options.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
 
@@ -78,7 +82,7 @@ bool EvaluateImpl(const CostFunctor* functor,
 // specializations for member functions. The alternative is to repeat the main
 // class for differing numbers of parameters, which is also unfortunate.
 template <typename CostFunctor,
-          NumericDiffMethod kMethod,
+          NumericDiffMethodType kMethod,
           int kNumResiduals,
           int N0, int N1, int N2, int N3, int N4,
           int N5, int N6, int N7, int N8, int N9,
@@ -88,9 +92,11 @@ struct NumericDiff {
   // Mutates parameters but must restore them before return.
   static bool EvaluateJacobianForParameterBlock(
       const CostFunctor* functor,
-      double const* residuals_at_eval_point,
-      const double relative_step_size,
+      const double* residuals_at_eval_point,
+      const NumericDiffOptions& options,
       int num_residuals,
+      int parameter_block_index,
+      int parameter_block_size,
       double **parameters,
       double *jacobian) {
     using Eigen::Map;
@@ -98,8 +104,14 @@ struct NumericDiff {
     using Eigen::RowMajor;
     using Eigen::ColMajor;
 
-    const int NUM_RESIDUALS =
+    const int num_residuals_internal =
         (kNumResiduals != ceres::DYNAMIC ? kNumResiduals : num_residuals);
+    const int parameter_block_index_internal =
+        (kParameterBlock != ceres::DYNAMIC ? kParameterBlock :
+                                             parameter_block_index);
+    const int parameter_block_size_internal =
+        (kParameterBlockSize != ceres::DYNAMIC ? kParameterBlockSize :
+                                                 parameter_block_size);
 
     typedef Matrix<double, kNumResiduals, 1> ResidualVector;
     typedef Matrix<double, kParameterBlockSize, 1> ParameterVector;
@@ -115,73 +127,288 @@ struct NumericDiff {
         JacobianMatrix;
 
     Map<JacobianMatrix> parameter_jacobian(jacobian,
-                                           NUM_RESIDUALS,
-                                           kParameterBlockSize);
+                                           num_residuals_internal,
+                                           parameter_block_size_internal);
 
-    // Mutate 1 element at a time and then restore.
-    Map<ParameterVector> x_plus_delta(parameters[kParameterBlock],
-                                      kParameterBlockSize);
+    Map<ParameterVector> x_plus_delta(
+        parameters[parameter_block_index_internal],
+        parameter_block_size_internal);
     ParameterVector x(x_plus_delta);
-    ParameterVector step_size = x.array().abs() * relative_step_size;
+    ParameterVector step_size = x.array().abs() *
+        ((kMethod == RIDDERS) ? options.ridders_relative_initial_step_size :
+        options.relative_step_size);
+
+    // It is not a good idea to make the step size arbitrarily
+    // small. This will lead to problems with round off and numerical
+    // instability when dividing by the step size. The general
+    // recommendation is to not go down below sqrt(epsilon).
+    double min_step_size = std::sqrt(std::numeric_limits<double>::epsilon());
 
-    // To handle cases where a parameter is exactly zero, instead use
-    // the mean step_size for the other dimensions. If all the
-    // parameters are zero, there's no good answer. Take
-    // relative_step_size as a guess and hope for the best.
-    const double fallback_step_size =
-        (step_size.sum() == 0)
-        ? relative_step_size
-        : step_size.sum() / step_size.rows();
+    // For Ridders' method, the initial step size is required to be large,
+    // thus ridders_relative_initial_step_size is used.
+    if (kMethod == RIDDERS) {
+      min_step_size = std::max(min_step_size,
+                               options.ridders_relative_initial_step_size);
+    }
 
     // For each parameter in the parameter block, use finite differences to
     // compute the derivative for that parameter.
+    FixedArray<double> temp_residual_array(num_residuals_internal);
+    FixedArray<double> residual_array(num_residuals_internal);
+    Map<ResidualVector> residuals(residual_array.get(),
+                                  num_residuals_internal);
+
+    for (int j = 0; j < parameter_block_size_internal; ++j) {
+      const double delta = std::max(min_step_size, step_size(j));
+
+      if (kMethod == RIDDERS) {
+        if (!EvaluateRiddersJacobianColumn(functor, j, delta,
+                                           options,
+                                           num_residuals_internal,
+                                           parameter_block_size_internal,
+                                           x.data(),
+                                           residuals_at_eval_point,
+                                           parameters,
+                                           x_plus_delta.data(),
+                                           temp_residual_array.get(),
+                                           residual_array.get())) {
+          return false;
+        }
+      } else {
+        if (!EvaluateJacobianColumn(functor, j, delta,
+                                    num_residuals_internal,
+                                    parameter_block_size_internal,
+                                    x.data(),
+                                    residuals_at_eval_point,
+                                    parameters,
+                                    x_plus_delta.data(),
+                                    temp_residual_array.get(),
+                                    residual_array.get())) {
+          return false;
+        }
+      }
 
-    ResidualVector residuals(NUM_RESIDUALS);
-    for (int j = 0; j < kParameterBlockSize; ++j) {
-      const double delta =
-          (step_size(j) == 0.0) ? fallback_step_size : step_size(j);
+      parameter_jacobian.col(j).matrix() = residuals;
+    }
+    return true;
+  }
 
-      x_plus_delta(j) = x(j) + delta;
+  static bool EvaluateJacobianColumn(const CostFunctor* functor,
+                                     int parameter_index,
+                                     double delta,
+                                     int num_residuals,
+                                     int parameter_block_size,
+                                     const double* x_ptr,
+                                     const double* residuals_at_eval_point,
+                                     double** parameters,
+                                     double* x_plus_delta_ptr,
+                                     double* temp_residuals_ptr,
+                                     double* residuals_ptr) {
+    using Eigen::Map;
+    using Eigen::Matrix;
+
+    typedef Matrix<double, kNumResiduals, 1> ResidualVector;
+    typedef Matrix<double, kParameterBlockSize, 1> ParameterVector;
+
+    Map<const ParameterVector> x(x_ptr, parameter_block_size);
+    Map<ParameterVector> x_plus_delta(x_plus_delta_ptr,
+                                      parameter_block_size);
+
+    Map<ResidualVector> residuals(residuals_ptr, num_residuals);
+    Map<ResidualVector> temp_residuals(temp_residuals_ptr, num_residuals);
+
+    // Mutate 1 element at a time and then restore.
+    x_plus_delta(parameter_index) = x(parameter_index) + delta;
+
+    if (!EvaluateImpl<CostFunctor, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>(
+            functor, parameters, residuals.data(), functor)) {
+      return false;
+    }
+
+    // Compute this column of the jacobian in 3 steps:
+    // 1. Store residuals for the forward part.
+    // 2. Subtract residuals for the backward (or 0) part.
+    // 3. Divide out the run.
+    double one_over_delta = 1.0 / delta;
+    if (kMethod == CENTRAL || kMethod == RIDDERS) {
+      // Compute the function on the other side of x(parameter_index).
+      x_plus_delta(parameter_index) = x(parameter_index) - delta;
 
       if (!EvaluateImpl<CostFunctor, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>(
-              functor, parameters, residuals.data(), functor)) {
+              functor, parameters, temp_residuals.data(), functor)) {
         return false;
       }
 
-      // Compute this column of the jacobian in 3 steps:
-      // 1. Store residuals for the forward part.
-      // 2. Subtract residuals for the backward (or 0) part.
-      // 3. Divide out the run.
-      parameter_jacobian.col(j) = residuals;
+      residuals -= temp_residuals;
+      one_over_delta /= 2;
+    } else {
+      // Forward difference only; reuse existing residuals evaluation.
+      residuals -=
+          Map<const ResidualVector>(residuals_at_eval_point,
+                                    num_residuals);
+    }
 
-      double one_over_delta = 1.0 / delta;
-      if (kMethod == CENTRAL) {
-        // Compute the function on the other side of x(j).
-        x_plus_delta(j) = x(j) - delta;
+    // Restore x_plus_delta.
+    x_plus_delta(parameter_index) = x(parameter_index);
 
-        if (!EvaluateImpl<CostFunctor, N0, N1, N2, N3, N4, N5, N6, N7, N8, N9>(
-                functor, parameters, residuals.data(), functor)) {
-          return false;
+    // Divide out the run to get slope.
+    residuals *= one_over_delta;
+
+    return true;
+  }
+
+  // This numeric difference implementation uses adaptive differentiation
+  // on the parameters to obtain the Jacobian matrix. The adaptive algorithm
+  // is based on Ridders' method for adaptive differentiation, which creates
+  // a Romberg tableau from varying step sizes and extrapolates the
+  // intermediate results to obtain the current computational error.
+  //
+  // References:
+  // C.J.F. Ridders, Accurate computation of F'(x) and F'(x) F"(x), Advances
+  // in Engineering Software (1978), Volume 4, Issue 2, April 1982,
+  // Pages 75-76, ISSN 0141-1195,
+  // http://dx.doi.org/10.1016/S0141-1195(82)80057-0.
+  static bool EvaluateRiddersJacobianColumn(
+      const CostFunctor* functor,
+      int parameter_index,
+      double delta,
+      const NumericDiffOptions& options,
+      int num_residuals,
+      int parameter_block_size,
+      const double* x_ptr,
+      const double* residuals_at_eval_point,
+      double** parameters,
+      double* x_plus_delta_ptr,
+      double* temp_residuals_ptr,
+      double* residuals_ptr) {
+    using Eigen::Map;
+    using Eigen::Matrix;
+    using Eigen::aligned_allocator;
+
+    typedef Matrix<double, kNumResiduals, 1> ResidualVector;
+    typedef Matrix<double, kNumResiduals, Eigen::Dynamic> ResidualCandidateMatrix;
+    typedef Matrix<double, kParameterBlockSize, 1> ParameterVector;
+
+    Map<const ParameterVector> x(x_ptr, parameter_block_size);
+    Map<ParameterVector> x_plus_delta(x_plus_delta_ptr,
+                                      parameter_block_size);
+
+    Map<ResidualVector> residuals(residuals_ptr, num_residuals);
+    Map<ResidualVector> temp_residuals(temp_residuals_ptr, num_residuals);
+
+    // In order for the algorithm to converge, the step size should be
+    // initialized to a value that is large enough to produce a significant
+    // change in the function.
+    // As the derivative is estimated, the step size decreases.
+    // By default, the step sizes are chosen so that the middle column
+    // of the Romberg tableau uses the input delta.
+    double current_step_size = delta *
+        pow(options.ridders_step_shrink_factor,
+            options.max_num_ridders_extrapolations / 2);
+
+    // Double-buffering temporary differential candidate vectors
+    // from previous step size.
+    ResidualCandidateMatrix stepsize_candidates_a(
+        num_residuals,
+        options.max_num_ridders_extrapolations);
+    ResidualCandidateMatrix stepsize_candidates_b(
+        num_residuals,
+        options.max_num_ridders_extrapolations);
+    ResidualCandidateMatrix* current_candidates = &stepsize_candidates_a;
+    ResidualCandidateMatrix* previous_candidates = &stepsize_candidates_b;
+
+    // Represents the computational error of the derivative. This variable is
+    // initially set to a large value, and is set to the difference between
+    // current and previous finite difference extrapolations.
+    // norm_error is supposed to decrease as the finite difference tableau
+    // generation progresses, serving both as an estimate for differentiation
+    // error and as a measure of differentiation numerical stability.
+    double norm_error = std::numeric_limits<double>::max();
+
+    // Loop over decreasing step sizes until:
+    //  1. Error is smaller than a given value (ridders_epsilon),
+    //  2. Maximal order of extrapolation reached, or
+    //  3. Extrapolation becomes numerically unstable.
+    for (int i = 0; i < options.max_num_ridders_extrapolations; ++i) {
+      // Compute the numerical derivative at this step size.
+      if (!EvaluateJacobianColumn(functor, parameter_index, current_step_size,
+                                  num_residuals,
+                                  parameter_block_size,
+                                  x.data(),
+                                  residuals_at_eval_point,
+                                  parameters,
+                                  x_plus_delta.data(),
+                                  temp_residuals.data(),
+                                  current_candidates->col(0).data())) {
+        // Something went wrong; bail.
+        return false;
+      }
+
+      // Store initial results.
+      if (i == 0) {
+        residuals = current_candidates->col(0);
+      }
+
+      // Shrink differentiation step size.
+      current_step_size /= options.ridders_step_shrink_factor;
+
+      // Extrapolation factor for Richardson acceleration method (see below).
+      double richardson_factor = options.ridders_step_shrink_factor *
+          options.ridders_step_shrink_factor;
+      for (int k = 1; k <= i; ++k) {
+        // Extrapolate the various orders of finite differences using
+        // the Richardson acceleration method.
+        current_candidates->col(k) =
+            (richardson_factor * current_candidates->col(k - 1) -
+             previous_candidates->col(k - 1)) / (richardson_factor - 1.0);
+
+        richardson_factor *= options.ridders_step_shrink_factor *
+            options.ridders_step_shrink_factor;
+
+        // Compute the difference between the previous value and the current.
+        double candidate_error = std::max(
+            (current_candidates->col(k) -
+             current_candidates->col(k - 1)).norm(),
+            (current_candidates->col(k) -
+             previous_candidates->col(k - 1)).norm());
+
+        // If the error has decreased, update results.
+        if (candidate_error <= norm_error) {
+          norm_error = candidate_error;
+          residuals = current_candidates->col(k);
+
+          // If the error is small enough, stop.
+          if (norm_error < options.ridders_epsilon) {
+            break;
+          }
         }
+      }
 
-        parameter_jacobian.col(j) -= residuals;
-        one_over_delta /= 2;
-      } else {
-        // Forward difference only; reuse existing residuals evaluation.
-        parameter_jacobian.col(j) -=
-            Map<const ResidualVector>(residuals_at_eval_point, NUM_RESIDUALS);
+      // After breaking out of the inner loop, declare convergence.
+      if (norm_error < options.ridders_epsilon) {
+        break;
+      }
+
+      // Check to see if the current gradient estimate is numerically unstable.
+      // If so, bail out and return the last stable result.
+      if (i > 0) {
+        double tableau_error = (current_candidates->col(i) -
+            previous_candidates->col(i - 1)).norm();
+
+        // Compare current error to the chosen candidate's error.
+        if (tableau_error >= 2 * norm_error) {
+          break;
+        }
       }
-      x_plus_delta(j) = x(j);  // Restore x_plus_delta.
 
-      // Divide out the run to get slope.
-      parameter_jacobian.col(j) *= one_over_delta;
+      std::swap(current_candidates, previous_candidates);
     }
     return true;
   }
 };
 
 template <typename CostFunctor,
-          NumericDiffMethod kMethod,
+          NumericDiffMethodType kMethod,
           int kNumResiduals,
           int N0, int N1, int N2, int N3, int N4,
           int N5, int N6, int N7, int N8, int N9,
@@ -192,11 +419,22 @@ struct NumericDiff<CostFunctor, kMethod, kNumResiduals,
   // Mutates parameters but must restore them before return.
   static bool EvaluateJacobianForParameterBlock(
       const CostFunctor* functor,
-      double const* residuals_at_eval_point,
-      const double relative_step_size,
+      const double* residuals_at_eval_point,
+      const NumericDiffOptions& options,
       const int num_residuals,
+      const int parameter_block_index,
+      const int parameter_block_size,
       double **parameters,
       double *jacobian) {
+    // Silence unused parameter compiler warnings.
+    (void)functor;
+    (void)residuals_at_eval_point;
+    (void)options;
+    (void)num_residuals;
+    (void)parameter_block_index;
+    (void)parameter_block_size;
+    (void)parameters;
+    (void)jacobian;
     LOG(FATAL) << "Control should never reach here.";
     return true;
   }
index e38eb713aa8d810747e87c249469e846bb657c1c..e57049dde4b70079bcadd1176a9a91d3114f612e 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -34,8 +34,6 @@
 // This file needs to compile as c code.
 #ifdef __cplusplus
 
-#include <string>
-
 #include "ceres/internal/config.h"
 
 #if defined(CERES_TR1_MEMORY_HEADER)
 
 namespace ceres {
 
-// It is unfortunate that this import of the entire standard namespace is
-// necessary. The reasons are historical and won't be explained here, but
-// suffice to say it is not a mistake and can't be removed without breaking
-// things outside of the Ceres optimization package.
-using namespace std;
-
-// This is necessary to properly handle the case that there is a different
-// "string" implementation in the global namespace.
-using std::string;
-
 #if defined(CERES_TR1_SHARED_PTR)
 using std::tr1::shared_ptr;
 #else
index 1f477d8d2ace13ff01e6ee7f565d13bf1deaecad..7e410259d641c44f3cafd0c63eaa99306a171964 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 5dfb551243cfb571b5556b1c621726592fc1a97a..fa0ac25a031c36737e70727773619fddf74002a5 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 9a473d5b25c320fff85186f4b9752abefce23da8..b3515b96d18174d044e7d83acee6493ef8758991 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -35,6 +35,7 @@
 #include <stddef.h>
 
 #include "ceres/jet.h"
+#include "ceres/types.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/fixed_array.h"
 #include "glog/logging.h"
@@ -176,6 +177,17 @@ struct VariadicEvaluate<Functor, T, N0, 0, 0, 0, 0, 0, 0, 0, 0, 0> {
   }
 };
 
+// Template instantiation for dynamically-sized functors.
+template<typename Functor, typename T>
+struct VariadicEvaluate<Functor, T, ceres::DYNAMIC, ceres::DYNAMIC,
+                        ceres::DYNAMIC, ceres::DYNAMIC, ceres::DYNAMIC,
+                        ceres::DYNAMIC, ceres::DYNAMIC, ceres::DYNAMIC,
+                        ceres::DYNAMIC, ceres::DYNAMIC> {
+  static bool Call(const Functor& functor, T const *const *input, T* output) {
+    return functor(input, output);
+  }
+};
+
 }  // namespace internal
 }  // namespace ceres
 
index 237ada6e0c9996b5aced519f4dcf06620885c9f5..6bab00439c586f6ede29b4f8e7d5a0249586c4da 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 74ce1e9dd53ce8c7ba1167b29be062d35543c31c..a21fd7adb901faf13e5a3d8d492bbfb9c9b0603a 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //   Jet<double, 2> y(1);  // Pick the 1st dual number for y.
 //   Jet<double, 2> z = f(x, y);
 //
-//   LOG(INFO) << "df/dx = " << z.a[0]
-//             << "df/dy = " << z.a[1];
+//   LOG(INFO) << "df/dx = " << z.v[0]
+//             << "df/dy = " << z.v[1];
 //
 // Most users should not use Jet objects directly; a wrapper around Jet objects,
 // which makes computing the derivative, gradient, or jacobian of templated
@@ -482,6 +482,41 @@ Jet<T, N> tanh(const Jet<T, N>& f) {
   return Jet<T, N>(tanh_a, tmp * f.v);
 }
 
+// Bessel functions of the first kind with integer order equal to 0, 1, n.
+inline double BesselJ0(double x) { return j0(x); }
+inline double BesselJ1(double x) { return j1(x); }
+inline double BesselJn(int n, double x) { return jn(n, x); }
+
+// For the formulae of the derivatives of the Bessel functions see the book:
+// Olver, Lozier, Boisvert, Clark, NIST Handbook of Mathematical Functions,
+// Cambridge University Press 2010.
+//
+// Formulae are also available at http://dlmf.nist.gov
+
+// See formula http://dlmf.nist.gov/10.6#E3
+// j0(a + h) ~= j0(a) - j1(a) h
+template <typename T, int N> inline
+Jet<T, N> BesselJ0(const Jet<T, N>& f) {
+  return Jet<T, N>(BesselJ0(f.a),
+                   -BesselJ1(f.a) * f.v);
+}
+
+// See formula http://dlmf.nist.gov/10.6#E1
+// j1(a + h) ~= j1(a) + 0.5 ( j0(a) - j2(a) ) h
+template <typename T, int N> inline
+Jet<T, N> BesselJ1(const Jet<T, N>& f) {
+  return Jet<T, N>(BesselJ1(f.a),
+                   T(0.5) * (BesselJ0(f.a) - BesselJn(2, f.a)) * f.v);
+}
+
+// See formula http://dlmf.nist.gov/10.6#E1
+// j_n(a + h) ~= j_n(a) + 0.5 ( j_{n-1}(a) - j_{n+1}(a) ) h
+template <typename T, int N> inline
+Jet<T, N> BesselJn(int n, const Jet<T, N>& f) {
+  return Jet<T, N>(BesselJn(n, f.a),
+                   T(0.5) * (BesselJn(n - 1, f.a) - BesselJn(n + 1, f.a)) * f.v);
+}
+
 // Jet Classification. It is not clear what the appropriate semantics are for
 // these classifications. This picks that IsFinite and isnormal are "all"
 // operations, i.e. all elements of the jet must be finite for the jet itself
@@ -573,22 +608,101 @@ Jet<T, N> pow(const Jet<T, N>& f, double g) {
 }
 
 // pow -- base is a constant, exponent is a differentiable function.
-// (a)^(p+dp) ~= a^p + a^p log(a) dp
+// We have various special cases, see the comment for pow(Jet, Jet) for
+// analysis:
+//
+// 1. For f > 0 we have: (f)^(g + dg) ~= f^g + f^g log(f) dg
+//
+// 2. For f == 0 and g > 0 we have: (f)^(g + dg) ~= f^g
+//
+// 3. For f < 0 and integer g we have: (f)^(g + dg) ~= f^g but if dg
+// != 0, the derivatives are not defined and we return NaN.
+
 template <typename T, int N> inline
 Jet<T, N> pow(double f, const Jet<T, N>& g) {
+  if (f == 0 && g.a > 0) {
+    // Handle case 2.
+    return Jet<T, N>(T(0.0));
+  }
+  if (f < 0 && g.a == floor(g.a)) {
+    // Handle case 3.
+    Jet<T, N> ret(pow(f, g.a));
+    for (int i = 0; i < N; i++) {
+      if (g.v[i] != T(0.0)) {
+        // Return a NaN when g.v != 0.
+        ret.v[i] = std::numeric_limits<T>::quiet_NaN();
+      }
+    }
+    return ret;
+  }
+  // Handle case 1.
   T const tmp = pow(f, g.a);
   return Jet<T, N>(tmp, log(f) * tmp * g.v);
 }
 
+// pow -- both base and exponent are differentiable functions. This has a
+// variety of special cases that require careful handling.
+//
+// 1. For f > 0:
+//    (f + df)^(g + dg) ~= f^g + f^(g - 1) * (g * df + f * log(f) * dg)
+//    The numerical evaluation of f * log(f) for f > 0 is well behaved, even for
+//    extremely small values (e.g. 1e-99).
+//
+// 2. For f == 0 and g > 1: (f + df)^(g + dg) ~= 0
+//    This cases is needed because log(0) can not be evaluated in the f > 0
+//    expression. However the function f*log(f) is well behaved around f == 0
+//    and its limit as f-->0 is zero.
+//
+// 3. For f == 0 and g == 1: (f + df)^(g + dg) ~= 0 + df
+//
+// 4. For f == 0 and 0 < g < 1: The value is finite but the derivatives are not.
+//
+// 5. For f == 0 and g < 0: The value and derivatives of f^g are not finite.
+//
+// 6. For f == 0 and g == 0: The C standard incorrectly defines 0^0 to be 1
+//    "because there are applications that can exploit this definition". We
+//    (arbitrarily) decree that derivatives here will be nonfinite, since that
+//    is consistent with the behavior for f == 0, g < 0 and 0 < g < 1.
+//    Practically any definition could have been justified because mathematical
+//    consistency has been lost at this point.
+//
+// 7. For f < 0, g integer, dg == 0: (f + df)^(g + dg) ~= f^g + g * f^(g - 1) df
+//    This is equivalent to the case where f is a differentiable function and g
+//    is a constant (to first order).
+//
+// 8. For f < 0, g integer, dg != 0: The value is finite but the derivatives are
+//    not, because any change in the value of g moves us away from the point
+//    with a real-valued answer into the region with complex-valued answers.
+//
+// 9. For f < 0, g noninteger: The value and derivatives of f^g are not finite.
 
-// pow -- both base and exponent are differentiable functions.
-// (a+da)^(b+db) ~= a^b + b * a^(b-1) da + a^b log(a) * db
 template <typename T, int N> inline
 Jet<T, N> pow(const Jet<T, N>& f, const Jet<T, N>& g) {
+  if (f.a == 0 && g.a >= 1) {
+    // Handle cases 2 and 3.
+    if (g.a > 1) {
+      return Jet<T, N>(T(0.0));
+    }
+    return f;
+  }
+  if (f.a < 0 && g.a == floor(g.a)) {
+    // Handle cases 7 and 8.
+    T const tmp = g.a * pow(f.a, g.a - T(1.0));
+    Jet<T, N> ret(pow(f.a, g.a), tmp * f.v);
+    for (int i = 0; i < N; i++) {
+      if (g.v[i] != T(0.0)) {
+        // Return a NaN when g.v != 0.
+        ret.v[i] = std::numeric_limits<T>::quiet_NaN();
+      }
+    }
+    return ret;
+  }
+  // Handle the remaining cases. For cases 4,5,6,9 we allow the log() function
+  // to generate -HUGE_VAL or NaN, since those cases result in a nonfinite
+  // derivative.
   T const tmp1 = pow(f.a, g.a);
   T const tmp2 = g.a * pow(f.a, g.a - T(1.0));
   T const tmp3 = tmp1 * log(f.a);
-
   return Jet<T, N>(tmp1, tmp2 * f.v + tmp3 * g.v);
 }
 
index 656c4d466625314c5f94c55a9d3894f2d94bc682..67633de309f283d6b6e6a2c619bc2f8b69fc6eef 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -34,6 +34,7 @@
 
 #include <vector>
 #include "ceres/internal/port.h"
+#include "ceres/internal/scoped_ptr.h"
 #include "ceres/internal/disable_warnings.h"
 
 namespace ceres {
@@ -173,7 +174,7 @@ class CERES_EXPORT IdentityParameterization : public LocalParameterization {
 class CERES_EXPORT SubsetParameterization : public LocalParameterization {
  public:
   explicit SubsetParameterization(int size,
-                                  const vector<int>& constant_parameters);
+                                  const std::vector<int>& constant_parameters);
   virtual ~SubsetParameterization() {}
   virtual bool Plus(const double* x,
                     const double* delta,
@@ -191,7 +192,7 @@ class CERES_EXPORT SubsetParameterization : public LocalParameterization {
 
  private:
   const int local_size_;
-  vector<int> constancy_mask_;
+  std::vector<char> constancy_mask_;
 };
 
 // Plus(x, delta) = [cos(|delta|), sin(|delta|) delta / |delta|] * x
@@ -210,6 +211,89 @@ class CERES_EXPORT QuaternionParameterization : public LocalParameterization {
   virtual int LocalSize() const { return 3; }
 };
 
+
+// This provides a parameterization for homogeneous vectors which are commonly
+// used in Structure for Motion problems.  One example where they are used is
+// in representing points whose triangulation is ill-conditioned. Here
+// it is advantageous to use an over-parameterization since homogeneous vectors
+// can represent points at infinity.
+//
+// The plus operator is defined as
+// Plus(x, delta) =
+//    [sin(0.5 * |delta|) * delta / |delta|, cos(0.5 * |delta|)] * x
+// with * defined as an operator which applies the update orthogonal to x to
+// remain on the sphere. We assume that the last element of x is the scalar
+// component. The size of the homogeneous vector is required to be greater than
+// 1.
+class CERES_EXPORT HomogeneousVectorParameterization :
+      public LocalParameterization {
+ public:
+  explicit HomogeneousVectorParameterization(int size);
+  virtual ~HomogeneousVectorParameterization() {}
+  virtual bool Plus(const double* x,
+                    const double* delta,
+                    double* x_plus_delta) const;
+  virtual bool ComputeJacobian(const double* x,
+                               double* jacobian) const;
+  virtual int GlobalSize() const { return size_; }
+  virtual int LocalSize() const { return size_ - 1; }
+
+ private:
+  const int size_;
+};
+
+// Construct a local parameterization by taking the Cartesian product
+// of a number of other local parameterizations. This is useful, when
+// a parameter block is the cartesian product of two or more
+// manifolds. For example the parameters of a camera consist of a
+// rotation and a translation, i.e., SO(3) x R^3.
+//
+// Currently this class supports taking the cartesian product of up to
+// four local parameterizations.
+//
+// Example usage:
+//
+// ProductParameterization product_param(new QuaterionionParameterization(),
+//                                       new IdentityParameterization(3));
+//
+// is the local parameterization for a rigid transformation, where the
+// rotation is represented using a quaternion.
+class CERES_EXPORT ProductParameterization : public LocalParameterization {
+ public:
+  //
+  // NOTE: All the constructors take ownership of the input local
+  // parameterizations.
+  //
+  ProductParameterization(LocalParameterization* local_param1,
+                          LocalParameterization* local_param2);
+
+  ProductParameterization(LocalParameterization* local_param1,
+                          LocalParameterization* local_param2,
+                          LocalParameterization* local_param3);
+
+  ProductParameterization(LocalParameterization* local_param1,
+                          LocalParameterization* local_param2,
+                          LocalParameterization* local_param3,
+                          LocalParameterization* local_param4);
+
+  virtual ~ProductParameterization();
+  virtual bool Plus(const double* x,
+                    const double* delta,
+                    double* x_plus_delta) const;
+  virtual bool ComputeJacobian(const double* x,
+                               double* jacobian) const;
+  virtual int GlobalSize() const { return global_size_; }
+  virtual int LocalSize() const { return local_size_; }
+
+ private:
+  void Init();
+
+  std::vector<LocalParameterization*> local_params_;
+  int local_size_;
+  int global_size_;
+  int buffer_size_;
+};
+
 }  // namespace ceres
 
 #include "ceres/internal/reenable_warnings.h"
index 2c585009990d9e556e92ea0e9d326a4777b1995c..0512c1351430e6c59c441de70224b20bc4231539 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -274,10 +274,28 @@ class CERES_EXPORT TolerantLoss : public LossFunction {
   const double a_, b_, c_;
 };
 
+// This is the Tukey biweight loss function which aggressively
+// attempts to suppress large errors.
+//
+// The term is computed as:
+//
+//   rho(s) = a^2 / 6 * (1 - (1 - s / a^2)^3 )   for s <= a^2,
+//   rho(s) = a^2 / 6                            for s >  a^2.
+//
+// At s = 0: rho = [0, 0.5, -1 / a^2]
+class CERES_EXPORT TukeyLoss : public ceres::LossFunction {
+ public:
+  explicit TukeyLoss(double a) : a_squared_(a * a) { }
+  virtual void Evaluate(double, double*) const;
+
+ private:
+  const double a_squared_;
+};
+
 // Composition of two loss functions.  The error is the result of first
 // evaluating g followed by f to yield the composition f(g(s)).
 // The loss functions must not be NULL.
-class ComposedLoss : public LossFunction {
+class CERES_EXPORT ComposedLoss : public LossFunction {
  public:
   explicit ComposedLoss(const LossFunction* f, Ownership ownership_f,
                         const LossFunction* g, Ownership ownership_g);
@@ -340,6 +358,9 @@ class CERES_EXPORT ScaledLoss : public LossFunction {
 // whose scale can be mutated after an optimization problem has been
 // constructed.
 //
+// Since we treat the a NULL Loss function as the Identity loss
+// function, rho = NULL is a valid input.
+//
 // Example usage
 //
 //  Problem problem;
@@ -376,8 +397,14 @@ class CERES_EXPORT LossFunctionWrapper : public LossFunction {
   }
 
   virtual void Evaluate(double sq_norm, double out[3]) const {
-    CHECK_NOTNULL(rho_.get());
-    rho_->Evaluate(sq_norm, out);
+    if (rho_.get() == NULL) {
+      out[0] = sq_norm;
+      out[1] = 1.0;
+      out[2] = 0.0;
+    }
+    else {
+      rho_->Evaluate(sq_norm, out);
+    }
   }
 
   void Reset(LossFunction* rho, Ownership ownership) {
@@ -396,6 +423,6 @@ class CERES_EXPORT LossFunctionWrapper : public LossFunction {
 
 }  // namespace ceres
 
-#include "ceres/internal/disable_warnings.h"
+#include "ceres/internal/reenable_warnings.h"
 
 #endif  // CERES_PUBLIC_LOSS_FUNCTION_H_
index df6650545309dc9211d35b60c1574c07fd1ed0bf..cd98b4c846b429c1b8ab3eab3a7619a6d6f9f75e 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index de6b74ad552881ebbf8ab29d9d700e94448f29e2..fa96078df0274e6a59611884fb0759b0e8cbf79b 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //
 // ALTERNATE INTERFACE
 //
-// For a variety of reason, including compatibility with legacy code,
+// For a variety of reasons, including compatibility with legacy code,
 // NumericDiffCostFunction can also take CostFunction objects as
 // input. The following describes how.
 //
 #include "ceres/cost_function.h"
 #include "ceres/internal/numeric_diff.h"
 #include "ceres/internal/scoped_ptr.h"
+#include "ceres/numeric_diff_options.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/types.h"
 #include "glog/logging.h"
 namespace ceres {
 
 template <typename CostFunctor,
-          NumericDiffMethod method = CENTRAL,
+          NumericDiffMethodType method = CENTRAL,
           int kNumResiduals = 0,  // Number of residuals, or ceres::DYNAMIC
           int N0 = 0,   // Number of parameters in block 0.
           int N1 = 0,   // Number of parameters in block 1.
@@ -189,19 +190,43 @@ class NumericDiffCostFunction
                                N0, N1, N2, N3, N4,
                                N5, N6, N7, N8, N9> {
  public:
+  NumericDiffCostFunction(
+      CostFunctor* functor,
+      Ownership ownership = TAKE_OWNERSHIP,
+      int num_residuals = kNumResiduals,
+      const NumericDiffOptions& options = NumericDiffOptions())
+      : functor_(functor),
+        ownership_(ownership),
+        options_(options) {
+    if (kNumResiduals == DYNAMIC) {
+      SizedCostFunction<kNumResiduals,
+                        N0, N1, N2, N3, N4,
+                        N5, N6, N7, N8, N9>
+          ::set_num_residuals(num_residuals);
+    }
+  }
+
+  // Deprecated. New users should avoid using this constructor. Instead, use the
+  // constructor with NumericDiffOptions.
   NumericDiffCostFunction(CostFunctor* functor,
-                          Ownership ownership = TAKE_OWNERSHIP,
-                          int num_residuals = kNumResiduals,
-                          const double relative_step_size = 1e-6)
+                          Ownership ownership,
+                          int num_residuals,
+                          const double relative_step_size)
       :functor_(functor),
        ownership_(ownership),
-       relative_step_size_(relative_step_size) {
+       options_() {
+    LOG(WARNING) << "This constructor is deprecated and will be removed in "
+                    "a future version. Please use the NumericDiffOptions "
+                    "constructor instead.";
+
     if (kNumResiduals == DYNAMIC) {
       SizedCostFunction<kNumResiduals,
                         N0, N1, N2, N3, N4,
                         N5, N6, N7, N8, N9>
           ::set_num_residuals(num_residuals);
     }
+
+    options_.relative_step_size = relative_step_size;
   }
 
   ~NumericDiffCostFunction() {
@@ -250,25 +275,25 @@ class NumericDiffCostFunction
     if (N8) parameters_reference_copy[8] = parameters_reference_copy[7] + N7;
     if (N9) parameters_reference_copy[9] = parameters_reference_copy[8] + N8;
 
-#define COPY_PARAMETER_BLOCK(block)                                     \
+#define CERES_COPY_PARAMETER_BLOCK(block)                               \
   if (N ## block) memcpy(parameters_reference_copy[block],              \
                          parameters[block],                             \
                          sizeof(double) * N ## block);  // NOLINT
 
-    COPY_PARAMETER_BLOCK(0);
-    COPY_PARAMETER_BLOCK(1);
-    COPY_PARAMETER_BLOCK(2);
-    COPY_PARAMETER_BLOCK(3);
-    COPY_PARAMETER_BLOCK(4);
-    COPY_PARAMETER_BLOCK(5);
-    COPY_PARAMETER_BLOCK(6);
-    COPY_PARAMETER_BLOCK(7);
-    COPY_PARAMETER_BLOCK(8);
-    COPY_PARAMETER_BLOCK(9);
+    CERES_COPY_PARAMETER_BLOCK(0);
+    CERES_COPY_PARAMETER_BLOCK(1);
+    CERES_COPY_PARAMETER_BLOCK(2);
+    CERES_COPY_PARAMETER_BLOCK(3);
+    CERES_COPY_PARAMETER_BLOCK(4);
+    CERES_COPY_PARAMETER_BLOCK(5);
+    CERES_COPY_PARAMETER_BLOCK(6);
+    CERES_COPY_PARAMETER_BLOCK(7);
+    CERES_COPY_PARAMETER_BLOCK(8);
+    CERES_COPY_PARAMETER_BLOCK(9);
 
-#undef COPY_PARAMETER_BLOCK
+#undef CERES_COPY_PARAMETER_BLOCK
 
-#define EVALUATE_JACOBIAN_FOR_BLOCK(block)                              \
+#define CERES_EVALUATE_JACOBIAN_FOR_BLOCK(block)                        \
     if (N ## block && jacobians[block] != NULL) {                       \
       if (!NumericDiff<CostFunctor,                                     \
                        method,                                          \
@@ -278,28 +303,30 @@ class NumericDiffCostFunction
                        N ## block >::EvaluateJacobianForParameterBlock( \
                            functor_.get(),                              \
                            residuals,                                   \
-                           relative_step_size_,                         \
+                           options_,                                    \
                           SizedCostFunction<kNumResiduals,              \
                            N0, N1, N2, N3, N4,                          \
                            N5, N6, N7, N8, N9>::num_residuals(),        \
+                           block,                                       \
+                           N ## block,                                  \
                            parameters_reference_copy.get(),             \
                            jacobians[block])) {                         \
         return false;                                                   \
       }                                                                 \
     }
 
-    EVALUATE_JACOBIAN_FOR_BLOCK(0);
-    EVALUATE_JACOBIAN_FOR_BLOCK(1);
-    EVALUATE_JACOBIAN_FOR_BLOCK(2);
-    EVALUATE_JACOBIAN_FOR_BLOCK(3);
-    EVALUATE_JACOBIAN_FOR_BLOCK(4);
-    EVALUATE_JACOBIAN_FOR_BLOCK(5);
-    EVALUATE_JACOBIAN_FOR_BLOCK(6);
-    EVALUATE_JACOBIAN_FOR_BLOCK(7);
-    EVALUATE_JACOBIAN_FOR_BLOCK(8);
-    EVALUATE_JACOBIAN_FOR_BLOCK(9);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(0);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(1);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(2);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(3);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(4);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(5);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(6);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(7);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(8);
+    CERES_EVALUATE_JACOBIAN_FOR_BLOCK(9);
 
-#undef EVALUATE_JACOBIAN_FOR_BLOCK
+#undef CERES_EVALUATE_JACOBIAN_FOR_BLOCK
 
     return true;
   }
@@ -307,7 +334,7 @@ class NumericDiffCostFunction
  private:
   internal::scoped_ptr<CostFunctor> functor_;
   Ownership ownership_;
-  const double relative_step_size_;
+  NumericDiffOptions options_;
 };
 
 }  // namespace ceres
diff --git a/extern/libmv/third_party/ceres/include/ceres/numeric_diff_options.h b/extern/libmv/third_party/ceres/include/ceres/numeric_diff_options.h
new file mode 100644 (file)
index 0000000..119c8a8
--- /dev/null
@@ -0,0 +1,79 @@
+// Ceres Solver - A fast non-linear least squares minimizer
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors may be
+//   used to endorse or promote products derived from this software without
+//   specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: tbennun@gmail.com (Tal Ben-Nun)
+//
+
+#ifndef CERES_PUBLIC_NUMERIC_DIFF_OPTIONS_H_
+#define CERES_PUBLIC_NUMERIC_DIFF_OPTIONS_H_
+
+namespace ceres {
+
+// Options pertaining to numeric differentiation (e.g., convergence criteria,
+// step sizes).
+struct CERES_EXPORT NumericDiffOptions {
+  NumericDiffOptions() {
+    relative_step_size = 1e-6;
+    ridders_relative_initial_step_size = 1e-2;
+    max_num_ridders_extrapolations = 10;
+    ridders_epsilon = 1e-12;
+    ridders_step_shrink_factor = 2.0;
+  }
+
+  // Numeric differentiation step size (multiplied by parameter block's
+  // order of magnitude). If parameters are close to zero, the step size
+  // is set to sqrt(machine_epsilon).
+  double relative_step_size;
+
+  // Initial step size for Ridders adaptive numeric differentiation (multiplied
+  // by parameter block's order of magnitude).
+  // If parameters are close to zero, Ridders' method sets the step size
+  // directly to this value. This parameter is separate from
+  // "relative_step_size" in order to set a different default value.
+  //
+  // Note: For Ridders' method to converge, the step size should be initialized
+  // to a value that is large enough to produce a significant change in the
+  // function. As the derivative is estimated, the step size decreases.
+  double ridders_relative_initial_step_size;
+
+  // Maximal number of adaptive extrapolations (sampling) in Ridders' method.
+  int max_num_ridders_extrapolations;
+
+  // Convergence criterion on extrapolation error for Ridders adaptive
+  // differentiation. The available error estimation methods are defined in
+  // NumericDiffErrorType and set in the "ridders_error_method" field.
+  double ridders_epsilon;
+
+  // The factor in which to shrink the step size with each extrapolation in
+  // Ridders' method.
+  double ridders_step_shrink_factor;
+};
+
+}  // namespace ceres
+
+#endif  // CERES_PUBLIC_NUMERIC_DIFF_OPTIONS_H_
index c316d712e97638211a4a31233fba83a56509b927..aa1bd3a7da1f3a0ab241a0f8b757c70531af1b7a 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -63,7 +63,8 @@ class OrderedGroups {
       return false;
     }
 
-    typename map<T, int>::const_iterator it = element_to_group_.find(element);
+    typename std::map<T, int>::const_iterator it =
+        element_to_group_.find(element);
     if (it != element_to_group_.end()) {
       if (it->second == group) {
         // Element is already in the right group, nothing to do.
@@ -107,7 +108,7 @@ class OrderedGroups {
 
   // Bulk remove elements. The return value indicates the number of
   // elements successfully removed.
-  int Remove(const vector<T>& elements) {
+  int Remove(const std::vector<T>& elements) {
     if (NumElements() == 0 || elements.size() == 0) {
       return 0;
     }
@@ -121,14 +122,18 @@ class OrderedGroups {
 
   // Reverse the order of the groups in place.
   void Reverse() {
-    typename map<int, set<T> >::reverse_iterator it =
+    if (NumGroups() == 0) {
+      return;
+    }
+
+    typename std::map<int, std::set<T> >::reverse_iterator it =
         group_to_elements_.rbegin();
-    map<int, set<T> > new_group_to_elements;
+    std::map<int, std::set<T> > new_group_to_elements;
     new_group_to_elements[it->first] = it->second;
 
     int new_group_id = it->first + 1;
     for (++it; it != group_to_elements_.rend(); ++it) {
-      for (typename set<T>::const_iterator element_it = it->second.begin();
+      for (typename std::set<T>::const_iterator element_it = it->second.begin();
            element_it != it->second.end();
            ++element_it) {
         element_to_group_[*element_it] = new_group_id;
@@ -143,7 +148,8 @@ class OrderedGroups {
   // Return the group id for the element. If the element is not a
   // member of any group, return -1.
   int GroupId(const T element) const {
-    typename map<T, int>::const_iterator it = element_to_group_.find(element);
+    typename std::map<T, int>::const_iterator it =
+        element_to_group_.find(element);
     if (it == element_to_group_.end()) {
       return -1;
     }
@@ -151,14 +157,15 @@ class OrderedGroups {
   }
 
   bool IsMember(const T element) const {
-    typename map<T, int>::const_iterator it = element_to_group_.find(element);
+    typename std::map<T, int>::const_iterator it =
+        element_to_group_.find(element);
     return (it != element_to_group_.end());
   }
 
   // This function always succeeds, i.e., implicitly there exists a
   // group for every integer.
   int GroupSize(const int group) const {
-    typename map<int, set<T> >::const_iterator it =
+    typename std::map<int, std::set<T> >::const_iterator it =
         group_to_elements_.find(group);
     return (it ==  group_to_elements_.end()) ? 0 : it->second.size();
   }
@@ -180,17 +187,17 @@ class OrderedGroups {
     return group_to_elements_.begin()->first;
   }
 
-  const map<int, set<T> >& group_to_elements() const {
+  const std::map<int, std::set<T> >& group_to_elements() const {
     return group_to_elements_;
   }
 
-  const map<T, int>& element_to_group() const {
+  const std::map<T, int>& element_to_group() const {
     return element_to_group_;
   }
 
  private:
-  map<int, set<T> > group_to_elements_;
-  map<T, int> element_to_group_;
+  std::map<int, std::set<T> > group_to_elements_;
+  std::map<T, int> element_to_group_;
 };
 
 // Typedef for the most commonly used version of OrderedGroups.
index f75ede3a5c67cb47f6ffa03e53315b93c845c545..409274c62c26b3747901a1628fc962f332a1877c 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -211,9 +211,10 @@ class CERES_EXPORT Problem {
   //   problem.AddResidualBlock(new MyUnaryCostFunction(...), NULL, x1);
   //   problem.AddResidualBlock(new MyBinaryCostFunction(...), NULL, x2, x1);
   //
-  ResidualBlockId AddResidualBlock(CostFunction* cost_function,
-                                   LossFunction* loss_function,
-                                   const vector<double*>& parameter_blocks);
+  ResidualBlockId AddResidualBlock(
+      CostFunction* cost_function,
+      LossFunction* loss_function,
+      const std::vector<double*>& parameter_blocks);
 
   // Convenience methods for adding residuals with a small number of
   // parameters. This is the common case. Instead of specifying the
@@ -356,17 +357,17 @@ class CERES_EXPORT Problem {
   // Fills the passed parameter_blocks vector with pointers to the
   // parameter blocks currently in the problem. After this call,
   // parameter_block.size() == NumParameterBlocks.
-  void GetParameterBlocks(vector<double*>* parameter_blocks) const;
+  void GetParameterBlocks(std::vector<double*>* parameter_blocks) const;
 
   // Fills the passed residual_blocks vector with pointers to the
   // residual blocks currently in the problem. After this call,
   // residual_blocks.size() == NumResidualBlocks.
-  void GetResidualBlocks(vector<ResidualBlockId>* residual_blocks) const;
+  void GetResidualBlocks(std::vector<ResidualBlockId>* residual_blocks) const;
 
   // Get all the parameter blocks that depend on the given residual block.
   void GetParameterBlocksForResidualBlock(
       const ResidualBlockId residual_block,
-      vector<double*>* parameter_blocks) const;
+      std::vector<double*>* parameter_blocks) const;
 
   // Get the CostFunction for the given residual block.
   const CostFunction* GetCostFunctionForResidualBlock(
@@ -385,7 +386,7 @@ class CERES_EXPORT Problem {
   // block will incur a scan of the entire Problem object.
   void GetResidualBlocksForParameterBlock(
       const double* values,
-      vector<ResidualBlockId>* residual_blocks) const;
+      std::vector<ResidualBlockId>* residual_blocks) const;
 
   // Options struct to control Problem::Evaluate.
   struct EvaluateOptions {
@@ -408,18 +409,17 @@ class CERES_EXPORT Problem {
     // used to add parameter blocks to the Problem. These parameter
     // block should NOT point to new memory locations. Bad things will
     // happen otherwise.
-    vector<double*> parameter_blocks;
+    std::vector<double*> parameter_blocks;
 
     // The set of residual blocks to evaluate. This vector determines
     // the order in which the residuals occur, and how the rows of the
     // jacobian are ordered. If residual_blocks is empty, then it is
-    // assumed to be equal to the vector containing all the residual
-    // blocks. If this vector is empty, then it is assumed to be equal
-    // to a vector containing ALL the residual blocks. Generally
-    // speaking the residual blocks will occur in the order in which
-    // they were added to the problem. But, this may change if the
-    // user removes any residual blocks from the problem.
-    vector<ResidualBlockId> residual_blocks;
+    // assumed to be equal to the vector containing ALL the residual
+    // blocks. Generally speaking the residual blocks will occur in
+    // the order in which they were added to the problem. But, this
+    // may change if the user removes any residual blocks from the
+    // problem.
+    std::vector<ResidualBlockId> residual_blocks;
 
     // Even though the residual blocks in the problem may contain loss
     // functions, setting apply_loss_function to false will turn off
@@ -463,8 +463,8 @@ class CERES_EXPORT Problem {
   // columns in the jacobian).
   bool Evaluate(const EvaluateOptions& options,
                 double* cost,
-                vector<double>* residuals,
-                vector<double>* gradient,
+                std::vector<double>* residuals,
+                std::vector<double>* gradient,
                 CRSMatrix* jacobian);
 
  private:
index e3dbfe84a5adf0146a10ce7da337a8cfa23d57f1..e9496d772e4443c3980309c9e97f901aacd96b21 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -47,6 +47,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <limits>
 #include "glog/logging.h"
 
 namespace ceres {
@@ -94,6 +95,17 @@ void AngleAxisToQuaternion(const T* angle_axis, T* quaternion);
 template<typename T>
 void QuaternionToAngleAxis(const T* quaternion, T* angle_axis);
 
+// Conversions between 3x3 rotation matrix (in column major order) and
+// quaternion rotation representations.  Templated for use with
+// autodifferentiation.
+template <typename T>
+void RotationMatrixToQuaternion(const T* R, T* quaternion);
+
+template <typename T, int row_stride, int col_stride>
+void RotationMatrixToQuaternion(
+    const MatrixAdapter<const T, row_stride, col_stride>& R,
+    T* quaternion);
+
 // Conversions between 3x3 rotation matrix (in column major order) and
 // axis-angle rotation representations.  Templated for use with
 // autodifferentiation.
@@ -141,11 +153,11 @@ void EulerAnglesToRotationMatrix(
 // the cross-product matrix of [a b c]. Together with the property that
 // R(q1 * q2) = R(q1) * R(q2) this uniquely defines the mapping from q to R.
 //
-// The rotation matrix is row-major.
-//
 // No normalization of the quaternion is performed, i.e.
 // R = ||q||^2 * Q, where Q is an orthonormal matrix
 // such that det(Q) = 1 and Q*Q' = I
+//
+// WARNING: The rotation matrix is ROW MAJOR
 template <typename T> inline
 void QuaternionToScaledRotation(const T q[4], T R[3 * 3]);
 
@@ -156,6 +168,8 @@ void QuaternionToScaledRotation(
 
 // Same as above except that the rotation matrix is normalized by the
 // Frobenius norm, so that R * R' = I (and det(R) = 1).
+//
+// WARNING: The rotation matrix is ROW MAJOR
 template <typename T> inline
 void QuaternionToRotation(const T q[4], T R[3 * 3]);
 
@@ -294,6 +308,46 @@ inline void QuaternionToAngleAxis(const T* quaternion, T* angle_axis) {
   }
 }
 
+template <typename T>
+void RotationMatrixToQuaternion(const T* R, T* angle_axis) {
+  RotationMatrixToQuaternion(ColumnMajorAdapter3x3(R), angle_axis);
+}
+
+// This algorithm comes from "Quaternion Calculus and Fast Animation",
+// Ken Shoemake, 1987 SIGGRAPH course notes
+template <typename T, int row_stride, int col_stride>
+void RotationMatrixToQuaternion(
+    const MatrixAdapter<const T, row_stride, col_stride>& R,
+    T* quaternion) {
+  const T trace = R(0, 0) + R(1, 1) + R(2, 2);
+  if (trace >= 0.0) {
+    T t = sqrt(trace + T(1.0));
+    quaternion[0] = T(0.5) * t;
+    t = T(0.5) / t;
+    quaternion[1] = (R(2, 1) - R(1, 2)) * t;
+    quaternion[2] = (R(0, 2) - R(2, 0)) * t;
+    quaternion[3] = (R(1, 0) - R(0, 1)) * t;
+  } else {
+    int i = 0;
+    if (R(1, 1) > R(0, 0)) {
+      i = 1;
+    }
+
+    if (R(2, 2) > R(i, i)) {
+      i = 2;
+    }
+
+    const int j = (i + 1) % 3;
+    const int k = (j + 1) % 3;
+    T t = sqrt(R(i, i) - R(j, j) - R(k, k) + T(1.0));
+    quaternion[i + 1] = T(0.5) * t;
+    t = T(0.5) / t;
+    quaternion[0] = (R(k, j) - R(j, k)) * t;
+    quaternion[j + 1] = (R(j, i) + R(i, j)) * t;
+    quaternion[k + 1] = (R(k, i) + R(i, k)) * t;
+  }
+}
+
 // The conversion of a rotation matrix to the angle-axis form is
 // numerically problematic when then rotation angle is close to zero
 // or to Pi. The following implementation detects when these two cases
@@ -308,80 +362,10 @@ template <typename T, int row_stride, int col_stride>
 void RotationMatrixToAngleAxis(
     const MatrixAdapter<const T, row_stride, col_stride>& R,
     T* angle_axis) {
-  // x = k * 2 * sin(theta), where k is the axis of rotation.
-  angle_axis[0] = R(2, 1) - R(1, 2);
-  angle_axis[1] = R(0, 2) - R(2, 0);
-  angle_axis[2] = R(1, 0) - R(0, 1);
-
-  static const T kOne = T(1.0);
-  static const T kTwo = T(2.0);
-
-  // Since the right hand side may give numbers just above 1.0 or
-  // below -1.0 leading to atan misbehaving, we threshold.
-  T costheta = std::min(std::max((R(0, 0) + R(1, 1) + R(2, 2) - kOne) / kTwo,
-                                 T(-1.0)),
-                        kOne);
-
-  // sqrt is guaranteed to give non-negative results, so we only
-  // threshold above.
-  T sintheta = std::min(sqrt(angle_axis[0] * angle_axis[0] +
-                             angle_axis[1] * angle_axis[1] +
-                             angle_axis[2] * angle_axis[2]) / kTwo,
-                        kOne);
-
-  // Use the arctan2 to get the right sign on theta
-  const T theta = atan2(sintheta, costheta);
-
-  // Case 1: sin(theta) is large enough, so dividing by it is not a
-  // problem. We do not use abs here, because while jets.h imports
-  // std::abs into the namespace, here in this file, abs resolves to
-  // the int version of the function, which returns zero always.
-  //
-  // We use a threshold much larger then the machine epsilon, because
-  // if sin(theta) is small, not only do we risk overflow but even if
-  // that does not occur, just dividing by a small number will result
-  // in numerical garbage. So we play it safe.
-  static const double kThreshold = 1e-12;
-  if ((sintheta > kThreshold) || (sintheta < -kThreshold)) {
-    const T r = theta / (kTwo * sintheta);
-    for (int i = 0; i < 3; ++i) {
-      angle_axis[i] *= r;
-    }
-    return;
-  }
-
-  // Case 2: theta ~ 0, means sin(theta) ~ theta to a good
-  // approximation.
-  if (costheta > 0.0) {
-    const T kHalf = T(0.5);
-    for (int i = 0; i < 3; ++i) {
-      angle_axis[i] *= kHalf;
-    }
-    return;
-  }
-
-  // Case 3: theta ~ pi, this is the hard case. Since theta is large,
-  // and sin(theta) is small. Dividing by theta by sin(theta) will
-  // either give an overflow or worse still numerically meaningless
-  // results. Thus we use an alternate more complicated formula
-  // here.
-
-  // Since cos(theta) is negative, division by (1-cos(theta)) cannot
-  // overflow.
-  const T inv_one_minus_costheta = kOne / (kOne - costheta);
-
-  // We now compute the absolute value of coordinates of the axis
-  // vector using the diagonal entries of R. To resolve the sign of
-  // these entries, we compare the sign of angle_axis[i]*sin(theta)
-  // with the sign of sin(theta). If they are the same, then
-  // angle_axis[i] should be positive, otherwise negative.
-  for (int i = 0; i < 3; ++i) {
-    angle_axis[i] = theta * sqrt((R(i, i) - costheta) * inv_one_minus_costheta);
-    if (((sintheta < 0.0) && (angle_axis[i] > 0.0)) ||
-        ((sintheta > 0.0) && (angle_axis[i] < 0.0))) {
-      angle_axis[i] = -angle_axis[i];
-    }
-  }
+  T quaternion[4];
+  RotationMatrixToQuaternion(R, quaternion);
+  QuaternionToAngleAxis(quaternion, angle_axis);
+  return;
 }
 
 template <typename T>
index 4f98d4eb95c10bb7eb041c3f5c291d0f53f17bd3..b10421e81be14ad87860c2d57368c94d31d2df47 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -55,15 +55,15 @@ class SizedCostFunction : public CostFunction {
 
     // This block breaks the 80 column rule to keep it somewhat readable.
     CHECK((!N1 && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||
-           ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))
+          ((N1 > 0) && !N2 && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||
+          ((N1 > 0) && (N2 > 0) && !N3 && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                                   // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && !N4 && !N5 && !N6 && !N7 && !N8 && !N9) ||                              // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && !N5 && !N6 && !N7 && !N8 && !N9) ||                         // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && !N6 && !N7 && !N8 && !N9) ||                    // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && !N7 && !N8 && !N9) ||               // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && !N8 && !N9) ||          // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && !N9) ||     // NOLINT
+          ((N1 > 0) && (N2 > 0) && (N3 > 0) && (N4 > 0) && (N5 > 0) && (N6 > 0) && (N7 > 0) && (N8 > 0) && (N9 > 0)))  // NOLINT
         << "Zero block cannot precede a non-zero block. Block sizes are "
         << "(ignore trailing 0s): " << N0 << ", " << N1 << ", " << N2 << ", "
         << N3 << ", " << N4 << ", " << N5 << ", " << N6 << ", " << N7 << ", "
@@ -71,19 +71,19 @@ class SizedCostFunction : public CostFunction {
 
     set_num_residuals(kNumResiduals);
 
-#define ADD_PARAMETER_BLOCK(N) \
+#define CERES_ADD_PARAMETER_BLOCK(N) \
     if (N) mutable_parameter_block_sizes()->push_back(N);
-    ADD_PARAMETER_BLOCK(N0);
-    ADD_PARAMETER_BLOCK(N1);
-    ADD_PARAMETER_BLOCK(N2);
-    ADD_PARAMETER_BLOCK(N3);
-    ADD_PARAMETER_BLOCK(N4);
-    ADD_PARAMETER_BLOCK(N5);
-    ADD_PARAMETER_BLOCK(N6);
-    ADD_PARAMETER_BLOCK(N7);
-    ADD_PARAMETER_BLOCK(N8);
-    ADD_PARAMETER_BLOCK(N9);
-#undef ADD_PARAMETER_BLOCK
+    CERES_ADD_PARAMETER_BLOCK(N0);
+    CERES_ADD_PARAMETER_BLOCK(N1);
+    CERES_ADD_PARAMETER_BLOCK(N2);
+    CERES_ADD_PARAMETER_BLOCK(N3);
+    CERES_ADD_PARAMETER_BLOCK(N4);
+    CERES_ADD_PARAMETER_BLOCK(N5);
+    CERES_ADD_PARAMETER_BLOCK(N6);
+    CERES_ADD_PARAMETER_BLOCK(N7);
+    CERES_ADD_PARAMETER_BLOCK(N8);
+    CERES_ADD_PARAMETER_BLOCK(N9);
+#undef CERES_ADD_PARAMETER_BLOCK
   }
 
   virtual ~SizedCostFunction() { }
index a5efa2a39151924e96162d991c77d59c45883d66..318cf48cb837ecf567e416e7cae9a3c21da97fdf 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -92,7 +92,7 @@ class CERES_EXPORT Solver {
       gradient_tolerance = 1e-10;
       parameter_tolerance = 1e-8;
 
-#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && !defined(CERES_ENABLE_LGPL_CODE)
+#if defined(CERES_NO_SUITESPARSE) && defined(CERES_NO_CXSPARSE) && !defined(CERES_ENABLE_LGPL_CODE)  // NOLINT
       linear_solver_type = DENSE_QR;
 #else
       linear_solver_type = SPARSE_NORMAL_CHOLESKY;
@@ -104,7 +104,8 @@ class CERES_EXPORT Solver {
 
       // Choose a default sparse linear algebra library in the order:
       //
-      //   SUITE_SPARSE > CX_SPARSE > EIGEN_SPARSE
+      //   SUITE_SPARSE > CX_SPARSE > EIGEN_SPARSE > NO_SPARSE
+      sparse_linear_algebra_library_type = NO_SPARSE;
 #if !defined(CERES_NO_SUITESPARSE)
       sparse_linear_algebra_library_type = SUITE_SPARSE;
 #else
@@ -140,7 +141,7 @@ class CERES_EXPORT Solver {
     // Returns true if the options struct has a valid
     // configuration. Returns false otherwise, and fills in *error
     // with a message describing the problem.
-    bool IsValid(string* error) const;
+    bool IsValid(std::string* error) const;
 
     // Minimizer options ----------------------------------------
 
@@ -676,13 +677,13 @@ class CERES_EXPORT Solver {
     // List of iterations at which the minimizer should dump the trust
     // region problem. Useful for testing and benchmarking. If empty
     // (default), no problems are dumped.
-    vector<int> trust_region_minimizer_iterations_to_dump;
+    std::vector<int> trust_region_minimizer_iterations_to_dump;
 
     // Directory to which the problems should be written to. Should be
     // non-empty if trust_region_minimizer_iterations_to_dump is
     // non-empty and trust_region_problem_dump_format_type is not
     // CONSOLE.
-    string trust_region_problem_dump_directory;
+    std::string trust_region_problem_dump_directory;
     DumpFormatType trust_region_problem_dump_format_type;
 
     // Finite differences options ----------------------------------------------
@@ -746,7 +747,7 @@ class CERES_EXPORT Solver {
     // executed, then set update_state_every_iteration to true.
     //
     // The solver does NOT take ownership of these pointers.
-    vector<IterationCallback*> callbacks;
+    std::vector<IterationCallback*> callbacks;
   };
 
   struct CERES_EXPORT Summary {
@@ -754,11 +755,11 @@ class CERES_EXPORT Solver {
 
     // A brief one line description of the state of the solver after
     // termination.
-    string BriefReport() const;
+    std::string BriefReport() const;
 
     // A full multiline description of the state of the solver after
     // termination.
-    string FullReport() const;
+    std::string FullReport() const;
 
     bool IsSolutionUsable() const;
 
@@ -768,7 +769,7 @@ class CERES_EXPORT Solver {
     TerminationType termination_type;
 
     // Reason why the solver terminated.
-    string message;
+    std::string message;
 
     // Cost of the problem (value of the objective function) before
     // the optimization.
@@ -784,7 +785,7 @@ class CERES_EXPORT Solver {
     double fixed_cost;
 
     // IterationSummary for each minimizer iteration in order.
-    vector<IterationSummary> iterations;
+    std::vector<IterationSummary> iterations;
 
     // Number of minimizer iterations in which the step was
     // accepted. Unless use_non_monotonic_steps is true this is also
@@ -832,6 +833,26 @@ class CERES_EXPORT Solver {
     // Time (in seconds) spent doing inner iterations.
     double inner_iteration_time_in_seconds;
 
+    // Cumulative timing information for line searches performed as part of the
+    // solve.  Note that in addition to the case when the Line Search minimizer
+    // is used, the Trust Region minimizer also uses a line search when
+    // solving a constrained problem.
+
+    // Time (in seconds) spent evaluating the univariate cost function as part
+    // of a line search.
+    double line_search_cost_evaluation_time_in_seconds;
+
+    // Time (in seconds) spent evaluating the gradient of the univariate cost
+    // function as part of a line search.
+    double line_search_gradient_evaluation_time_in_seconds;
+
+    // Time (in seconds) spent minimizing the interpolating polynomial
+    // to compute the next candidate step size as part of a line search.
+    double line_search_polynomial_minimization_time_in_seconds;
+
+    // Total time (in seconds) spent performing line searches.
+    double line_search_total_time_in_seconds;
+
     // Number of parameter blocks in the problem.
     int num_parameter_blocks;
 
@@ -871,6 +892,9 @@ class CERES_EXPORT Solver {
     //  Number of residuals in the reduced problem.
     int num_residuals_reduced;
 
+    // Is the reduced problem bounds constrained.
+    bool is_constrained;
+
     //  Number of threads specified by the user for Jacobian and
     //  residual evaluation.
     int num_threads_given;
@@ -902,7 +926,7 @@ class CERES_EXPORT Solver {
 
     // Size of the elimination groups given by the user as hints to
     // the linear solver.
-    vector<int> linear_solver_ordering_given;
+    std::vector<int> linear_solver_ordering_given;
 
     // Size of the parameter groups used by the solver when ordering
     // the columns of the Jacobian.  This maybe different from
@@ -910,7 +934,7 @@ class CERES_EXPORT Solver {
     // linear_solver_ordering_given blank and asked for an automatic
     // ordering, or if the problem contains some constant or inactive
     // parameter blocks.
-    vector<int> linear_solver_ordering_used;
+    std::vector<int> linear_solver_ordering_used;
 
     // True if the user asked for inner iterations to be used as part
     // of the optimization.
@@ -924,7 +948,7 @@ class CERES_EXPORT Solver {
 
     // Size of the parameter groups given by the user for performing
     // inner iterations.
-    vector<int> inner_iteration_ordering_given;
+    std::vector<int> inner_iteration_ordering_given;
 
     // Size of the parameter groups given used by the solver for
     // performing inner iterations. This maybe different from
@@ -932,7 +956,7 @@ class CERES_EXPORT Solver {
     // inner_iteration_ordering_given blank and asked for an automatic
     // ordering, or if the problem contains some constant or inactive
     // parameter blocks.
-    vector<int> inner_iteration_ordering_used;
+    std::vector<int> inner_iteration_ordering_used;
 
     // Type of the preconditioner requested by the user.
     PreconditionerType preconditioner_type_given;
index a07c8933e649548308743482fd8459f630823733..2ea418036297b28fd44868ac38785775907c6032 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -157,7 +157,12 @@ enum SparseLinearAlgebraLibraryType {
 
   // Eigen's sparse linear algebra routines. In particular Ceres uses
   // the Simplicial LDLT routines.
-  EIGEN_SPARSE
+  EIGEN_SPARSE,
+
+  // No sparse linear solver should be used.  This does not necessarily
+  // imply that Ceres was built without any sparse library, although that
+  // is the likely use case, merely that one should not be used.
+  NO_SPARSE
 };
 
 enum DenseLinearAlgebraLibraryType {
@@ -392,9 +397,19 @@ enum DimensionType {
   DYNAMIC = -1
 };
 
-enum NumericDiffMethod {
+// The differentiation method used to compute numerical derivatives in
+// NumericDiffCostFunction and DynamicNumericDiffCostFunction.
+enum NumericDiffMethodType {
+  // Compute central finite difference: f'(x) ~ (f(x+h) - f(x-h)) / 2h.
   CENTRAL,
-  FORWARD
+
+  // Compute forward finite difference: f'(x) ~ (f(x+h) - f(x)) / h.
+  FORWARD,
+
+  // Adaptive numerical differentiation using Ridders' method. Provides more
+  // accurate and robust derivatives at the expense of additional cost
+  // function evaluations.
+  RIDDERS
 };
 
 enum LineSearchInterpolationType {
@@ -411,67 +426,73 @@ enum CovarianceAlgorithmType {
 
 CERES_EXPORT const char* LinearSolverTypeToString(
     LinearSolverType type);
-CERES_EXPORT bool StringToLinearSolverType(string value,
+CERES_EXPORT bool StringToLinearSolverType(std::string value,
                                            LinearSolverType* type);
 
 CERES_EXPORT const char* PreconditionerTypeToString(PreconditionerType type);
-CERES_EXPORT bool StringToPreconditionerType(string value,
+CERES_EXPORT bool StringToPreconditionerType(std::string value,
                                              PreconditionerType* type);
 
 CERES_EXPORT const char* VisibilityClusteringTypeToString(
     VisibilityClusteringType type);
-CERES_EXPORT bool StringToVisibilityClusteringType(string value,
+CERES_EXPORT bool StringToVisibilityClusteringType(std::string value,
                                       VisibilityClusteringType* type);
 
 CERES_EXPORT const char* SparseLinearAlgebraLibraryTypeToString(
     SparseLinearAlgebraLibraryType type);
 CERES_EXPORT bool StringToSparseLinearAlgebraLibraryType(
-    string value,
+    std::string value,
     SparseLinearAlgebraLibraryType* type);
 
 CERES_EXPORT const char* DenseLinearAlgebraLibraryTypeToString(
     DenseLinearAlgebraLibraryType type);
 CERES_EXPORT bool StringToDenseLinearAlgebraLibraryType(
-    string value,
+    std::string value,
     DenseLinearAlgebraLibraryType* type);
 
 CERES_EXPORT const char* TrustRegionStrategyTypeToString(
     TrustRegionStrategyType type);
-CERES_EXPORT bool StringToTrustRegionStrategyType(string value,
+CERES_EXPORT bool StringToTrustRegionStrategyType(std::string value,
                                      TrustRegionStrategyType* type);
 
 CERES_EXPORT const char* DoglegTypeToString(DoglegType type);
-CERES_EXPORT bool StringToDoglegType(string value, DoglegType* type);
+CERES_EXPORT bool StringToDoglegType(std::string value, DoglegType* type);
 
 CERES_EXPORT const char* MinimizerTypeToString(MinimizerType type);
-CERES_EXPORT bool StringToMinimizerType(string value, MinimizerType* type);
+CERES_EXPORT bool StringToMinimizerType(std::string value, MinimizerType* type);
 
 CERES_EXPORT const char* LineSearchDirectionTypeToString(
     LineSearchDirectionType type);
-CERES_EXPORT bool StringToLineSearchDirectionType(string value,
+CERES_EXPORT bool StringToLineSearchDirectionType(std::string value,
                                      LineSearchDirectionType* type);
 
 CERES_EXPORT const char* LineSearchTypeToString(LineSearchType type);
-CERES_EXPORT bool StringToLineSearchType(string value, LineSearchType* type);
+CERES_EXPORT bool StringToLineSearchType(std::string value, LineSearchType* type);
 
 CERES_EXPORT const char* NonlinearConjugateGradientTypeToString(
     NonlinearConjugateGradientType type);
 CERES_EXPORT bool StringToNonlinearConjugateGradientType(
-    string value,
+    std::string value,
     NonlinearConjugateGradientType* type);
 
 CERES_EXPORT const char* LineSearchInterpolationTypeToString(
     LineSearchInterpolationType type);
 CERES_EXPORT bool StringToLineSearchInterpolationType(
-    string value,
+    std::string value,
     LineSearchInterpolationType* type);
 
 CERES_EXPORT const char* CovarianceAlgorithmTypeToString(
     CovarianceAlgorithmType type);
 CERES_EXPORT bool StringToCovarianceAlgorithmType(
-    string value,
+    std::string value,
     CovarianceAlgorithmType* type);
 
+CERES_EXPORT const char* NumericDiffMethodTypeToString(
+    NumericDiffMethodType type);
+CERES_EXPORT bool StringToNumericDiffMethodType(
+    std::string value,
+    NumericDiffMethodType* type);
+
 CERES_EXPORT const char* TerminationTypeToString(TerminationType type);
 
 CERES_EXPORT bool IsSchurType(LinearSolverType type);
index 370b08af73e00492a4b3ebd4bd6aaca7973396fe..66505a515c966e1b558638c625b817212175d500 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -32,9 +32,8 @@
 #define CERES_PUBLIC_VERSION_H_
 
 #define CERES_VERSION_MAJOR 1
-#define CERES_VERSION_MINOR 10
+#define CERES_VERSION_MINOR 11
 #define CERES_VERSION_REVISION 0
-#define CERES_VERSION_ABI 1
 
 // Classic CPP stringifcation; the extra level of indirection allows the
 // preprocessor to expand the macro before being converted to a string.
index 205ddaf27c9d452d93ffe0834b6a0b099f518b05..7be3c78ce24b90c02b1075ca8a8f3967e63b1fc2 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -41,6 +41,8 @@
 namespace ceres {
 namespace internal {
 
+using std::string;
+
 // It is a near impossibility that user code generates this exact
 // value in normal operation, thus we will use it to fill arrays
 // before passing them to user code. If on return an element of the
@@ -71,7 +73,7 @@ int FindInvalidValue(const int size, const double* x) {
   }
 
   return size;
-};
+}
 
 void InvalidateArray(const int size, double* x) {
   if (x != NULL) {
index 7f56947066b62e7c6e1d04d1588479b67b1db59e..2d2ffca88091b39bd222ab37b6b6ccd3af934b1a 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -43,6 +43,7 @@
 #ifndef CERES_INTERNAL_ARRAY_UTILS_H_
 #define CERES_INTERNAL_ARRAY_UTILS_H_
 
+#include <string>
 #include "ceres/internal/port.h"
 
 namespace ceres {
@@ -63,7 +64,7 @@ int FindInvalidValue(const int size, const double* x);
 
 // Utility routine to print an array of doubles to a string. If the
 // array pointer is NULL, it is treated as an array of zeros.
-void AppendArrayToString(const int size, const double* x, string* result);
+void AppendArrayToString(const int size, const double* x, std::string* result);
 
 extern const double kImpossibleValue;
 
index b919e13c4a904cc3840ddbe965ba2d0c60aa6759..3ba63bbed5ad75ddee942f8dabb183027783c566 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -32,6 +32,7 @@
 #include "ceres/internal/port.h"
 #include "glog/logging.h"
 
+#ifndef CERES_NO_LAPACK
 extern "C" void dsyrk_(char* uplo,
                        char* trans,
                        int* n,
@@ -42,6 +43,7 @@ extern "C" void dsyrk_(char* uplo,
                        double* beta,
                        double* c,
                        int* ldc);
+#endif
 
 namespace ceres {
 namespace internal {
index 2ab666395b9437ce8ca4faaba5d3b9076ee3fc76..a43301c5d18ad17792a8db66ef4985cbb401e6e0 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 9edc4fa23bd8e69d0b4d99998ed49885a331214d..59c0d3ecc10555b9203b8f071d1710117b16598b 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 354acc031f4fc934197e3425142ee01c1bd95b20..4378689729fcafa15e649a3845506ccce53530a6 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 7f79a4f993d16cbea5a15c7ac57bc5ff1cf973da..22d4b351c51dc3953002d3ed08088c50870cb625 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -43,7 +43,7 @@ namespace internal {
 BlockJacobiPreconditioner::BlockJacobiPreconditioner(
     const BlockSparseMatrix& A) {
   const CompressedRowBlockStructure* bs = A.block_structure();
-  vector<int> blocks(bs->cols.size());
+  std::vector<int> blocks(bs->cols.size());
   for (int i = 0; i < blocks.size(); ++i) {
     blocks[i] = bs->cols[i].size;
   }
@@ -60,7 +60,7 @@ bool BlockJacobiPreconditioner::UpdateImpl(const BlockSparseMatrix& A,
   m_->SetZero();
   for (int i = 0; i < bs->rows.size(); ++i) {
     const int row_block_size = bs->rows[i].block.size;
-    const vector<Cell>& cells = bs->rows[i].cells;
+    const std::vector<Cell>& cells = bs->rows[i].cells;
     for (int j = 0; j < cells.size(); ++j) {
       const int block_id = cells[j].block_id;
       const int col_block_size = bs->cols[block_id].size;
index e23e0e2d24c159cb373442021cc983091761b7ef..140072958231da337caf6033030f6b7ba9ae1f0f 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index f90c350cc80a4813094d09336c87263e6c7a0bad..7a3fee4fbdf88297bfbcbaac09d6d7e78d5b8028 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -41,6 +41,9 @@
 
 namespace ceres {
 namespace internal {
+
+using std::vector;
+
 namespace {
 
 // Given the residual block ordering, build a lookup table to determine which
@@ -163,8 +166,7 @@ SparseMatrix* BlockJacobianWriter::CreateJacobian() const {
   }
 
   // Construct the cells in each row.
-  const vector<ResidualBlock*>& residual_blocks =
-      program_->residual_blocks();
+  const vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
   int row_block_position = 0;
   bs->rows.resize(residual_blocks.size());
   for (int i = 0; i < residual_blocks.size(); ++i) {
index 140c72111297191a92b406af6106d43d3a13e7e5..8e6f45130a4221634b167d77bcc771a2fa5d5610 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -115,10 +115,10 @@ class BlockJacobianWriter {
   //
   // which indicates that dr/dx is located at values_[0], and dr/dz is at
   // values_[12]. See BlockEvaluatePreparer::Prepare()'s comments about 'j'.
-  vector<int*> jacobian_layout_;
+  std::vector<int*> jacobian_layout_;
 
   // The pointers in jacobian_layout_ point directly into this vector.
-  vector<int> jacobian_layout_storage_;
+  std::vector<int> jacobian_layout_storage_;
 };
 
 }  // namespace internal
index e5822792fa1d65f307dd8512348d78b076b6066d..61748ef6f7fbc3e0838fadb043fe93634be06cd7 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -39,7 +39,7 @@ namespace ceres {
 namespace internal {
 
 BlockRandomAccessDenseMatrix::BlockRandomAccessDenseMatrix(
-    const vector<int>& blocks) {
+    const std::vector<int>& blocks) {
   const int num_blocks = blocks.size();
   block_layout_.resize(num_blocks, 0);
   num_rows_ = 0;
index d160fd960138f5ff4c17c7bda4fdfc0bed21a904..89689082561788a789533b7d9f44fb8064f670b7 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -56,7 +56,7 @@ class BlockRandomAccessDenseMatrix : public BlockRandomAccessMatrix {
  public:
   // blocks is a vector of block sizes. The resulting matrix has
   // blocks.size() * blocks.size() cells.
-  explicit BlockRandomAccessDenseMatrix(const vector<int>& blocks);
+  explicit BlockRandomAccessDenseMatrix(const std::vector<int>& blocks);
 
   // The destructor is not thread safe. It assumes that no one is
   // modifying any cells when the matrix is being destroyed.
@@ -85,7 +85,7 @@ class BlockRandomAccessDenseMatrix : public BlockRandomAccessMatrix {
 
  private:
   int num_rows_;
-  vector<int> block_layout_;
+  std::vector<int> block_layout_;
   scoped_array<double> values_;
   scoped_array<CellInfo> cell_infos_;
 
index b7ff33184cb61213b6c5acabfa990ffe9dd57221..052690d18be71de71b66f706df68ed157d4ef6b2 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -45,6 +45,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 // TODO(sameeragarwal): Drop the dependence on TripletSparseMatrix.
 
 BlockRandomAccessDiagonalMatrix::BlockRandomAccessDiagonalMatrix(
index ea9967817db0e89735a1e9f426779759201abfc7..07ffc9d4a0d0818f0a0cb851aca45157a87a097d 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -52,7 +52,7 @@ namespace internal {
 class BlockRandomAccessDiagonalMatrix : public BlockRandomAccessMatrix {
  public:
   // blocks is an array of block sizes.
-  explicit BlockRandomAccessDiagonalMatrix(const vector<int>& blocks);
+  explicit BlockRandomAccessDiagonalMatrix(const std::vector<int>& blocks);
 
   // The destructor is not thread safe. It assumes that no one is
   // modifying any cells when the matrix is being destroyed.
@@ -85,8 +85,8 @@ class BlockRandomAccessDiagonalMatrix : public BlockRandomAccessMatrix {
 
  private:
   // row/column block sizes.
-  const vector<int> blocks_;
-  vector<CellInfo*> layout_;
+  const std::vector<int> blocks_;
+  std::vector<CellInfo*> layout_;
 
   // The underlying matrix object which actually stores the cells.
   scoped_ptr<TripletSparseMatrix> tsm_;
index 58fe4a10de31b5d925ad6c60eb8afdadadb53cb6..347d765bbcae8c0722b2c25349fcb11f519d2328 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index b76cb78b16066f2d04b52f2053afbc6e07adb283..34c8bf5cd4d0dd3f8265db0e0c95f84ef56c03c3 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index c43a9b78feb700cc78c41d29764b286caca9186c..5432ec1064a17fe4dd56852881d7c7202fc33546 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 namespace ceres {
 namespace internal {
 
+using std::make_pair;
+using std::pair;
+using std::set;
+using std::vector;
+
 BlockRandomAccessSparseMatrix::BlockRandomAccessSparseMatrix(
     const vector<int>& blocks,
     const set<pair<int, int> >& block_pairs)
index 51b5d20cfe01c55eabcd779a506b736df3426ca5..2b3c7fdabae6266acfbb359f4db609dd0eea3a55 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -57,8 +57,9 @@ class BlockRandomAccessSparseMatrix : public BlockRandomAccessMatrix {
   // blocks is an array of block sizes. block_pairs is a set of
   // <row_block_id, col_block_id> pairs to identify the non-zero cells
   // of this matrix.
-  BlockRandomAccessSparseMatrix(const vector<int>& blocks,
-                                const set<pair<int, int> >& block_pairs);
+  BlockRandomAccessSparseMatrix(
+      const std::vector<int>& blocks,
+      const std::set<std::pair<int, int> >& block_pairs);
 
   // The destructor is not thread safe. It assumes that no one is
   // modifying any cells when the matrix is being destroyed.
@@ -103,8 +104,8 @@ class BlockRandomAccessSparseMatrix : public BlockRandomAccessMatrix {
   const int64 kMaxRowBlocks;
 
   // row/column block sizes.
-  const vector<int> blocks_;
-  vector<int> block_positions_;
+  const std::vector<int> blocks_;
+  std::vector<int> block_positions_;
 
   // A mapping from <row_block_id, col_block_id> to the position in
   // the values array of tsm_ where the block is stored.
@@ -114,7 +115,7 @@ class BlockRandomAccessSparseMatrix : public BlockRandomAccessMatrix {
   // In order traversal of contents of the matrix. This allows us to
   // implement a matrix-vector which is 20% faster than using the
   // iterator in the Layout object instead.
-  vector<pair<pair<int, int>, double*> > cell_values_;
+  std::vector<std::pair<std::pair<int, int>, double*> > cell_values_;
   // The underlying matrix object which actually stores the cells.
   scoped_ptr<TripletSparseMatrix> tsm_;
 
index a487262611436b16f8d7bc0a600d117fbac98a76..68d0780156c800a33001f4cdb31e5188fe90c272 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -42,6 +42,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 BlockSparseMatrix::~BlockSparseMatrix() {}
 
 BlockSparseMatrix::BlockSparseMatrix(
@@ -82,7 +84,7 @@ BlockSparseMatrix::BlockSparseMatrix(
 }
 
 void BlockSparseMatrix::SetZero() {
-  fill(values_.get(), values_.get() + num_nonzeros_, 0.0);
+  std::fill(values_.get(), values_.get() + num_nonzeros_, 0.0);
 }
 
 void BlockSparseMatrix::RightMultiply(const double* x,  double* y) const {
index e17d12a706ead54203e56e36cac9662ad15db316..2f9afb738f82399ee889bad7fe98c24eb8037efb 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 00c4ce2814b50afccb143ac09dd43945883fce4a..6479b60f700887f557eb694d18a1605c65de3b2a 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 656716ef022c653f0654a43c2576df219f24002d..6e7003addb6e7ac404a509ae6631c0834ed33eff 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -71,20 +71,20 @@ bool CellLessThan(const Cell& lhs, const Cell& rhs);
 
 struct CompressedList {
   Block block;
-  vector<Cell> cells;
+  std::vector<Cell> cells;
 };
 
 typedef CompressedList CompressedRow;
 typedef CompressedList CompressedColumn;
 
 struct CompressedRowBlockStructure {
-  vector<Block> cols;
-  vector<CompressedRow> rows;
+  std::vector<Block> cols;
+  std::vector<CompressedRow> rows;
 };
 
 struct CompressedColumnBlockStructure {
-  vector<Block> rows;
-  vector<CompressedColumn> cols;
+  std::vector<Block> rows;
+  std::vector<CompressedColumn> cols;
 };
 
 }  // namespace internal
index 1fd01c9f0bd54f7e6c6bacf536aba63839a2a3e2..ada8f3e00133f91e6b0f9886d77cb17816df381e 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2013 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 7d5ce2548e4069d1e18cb40dccf607d3717ab50b..50a0ec19924009a1a3d81851d6255642ada77e0d 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -37,6 +37,8 @@
 namespace ceres {
 namespace internal {
 
+using std::string;
+
 StateUpdatingCallback::StateUpdatingCallback(Program* program,
                                              double* parameters)
     : program_(program), parameters_(parameters) {}
@@ -78,27 +80,27 @@ CallbackReturnType LoggingCallback::operator()(
                           summary.cumulative_time_in_seconds);
   } else if (minimizer_type == TRUST_REGION) {
     if (summary.iteration == 0) {
-      output = "iter      cost      cost_change  |gradient|   |step|    tr_ratio  tr_radius  ls_iter  iter_time  total_time\n";
+      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";
+        "% 4d % 8e   % 3.2e   % 3.2e  % 3.2e  % 3.2e % 3.2e     % 4d   % 3.2e   % 3.2e";  // NOLINT
     output += StringPrintf(kReportRowFormat,
-                          summary.iteration,
-                          summary.cost,
-                          summary.cost_change,
-                          summary.gradient_max_norm,
-                          summary.step_norm,
-                          summary.relative_decrease,
-                          summary.trust_region_radius,
-                          summary.linear_solver_iterations,
-                          summary.iteration_time_in_seconds,
-                          summary.cumulative_time_in_seconds);
+                           summary.iteration,
+                           summary.cost,
+                           summary.cost_change,
+                           summary.gradient_max_norm,
+                           summary.step_norm,
+                           summary.relative_decrease,
+                           summary.trust_region_radius,
+                           summary.linear_solver_iterations,
+                           summary.iteration_time_in_seconds,
+                           summary.cumulative_time_in_seconds);
   } else {
     LOG(FATAL) << "Unknown minimizer type.";
   }
 
   if (log_to_stdout_) {
-    cout << output << endl;
+    std::cout << output << std::endl;
   } else {
     VLOG(1) << output;
   }
index 93704dfd6d1444ae193f134e2aeb48f0bfb565a7..33c66df5c113c9c06ae1b423798c5611296abc10 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2014 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 9bbab4b237718af78eb868755165b381453a324d..b655b1eccd33086746952c24f2546d95f8394eed 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -45,6 +45,8 @@
 namespace ceres {
 namespace internal {
 
+using std::vector;
+
 typedef HashMap<int, int> IntMap;
 typedef HashSet<int> IntSet;
 
index d3fa57258317bb23a335b2cbb4ccb22cea04912b..6b0b38a854d83b6674b829ca1af1ec20d56a3592 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
@@ -102,7 +102,7 @@ struct CanonicalViewsClusteringOptions;
 void ComputeCanonicalViewsClustering(
     const CanonicalViewsClusteringOptions& options,
     const WeightedGraph<int>& graph,
-    vector<int>* centers,
+    std::vector<int>* centers,
     HashMap<int, int>* membership);
 
 struct CanonicalViewsClusteringOptions {
index 99cf2186cc75284aa5ca4717bc96d7ff4f729613..f18fdea2d868408bc9e9bafa02e176e41345c6da 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index f32d8d95c196b995804e12757234d025b452601e..44c07cabd01ac54ace8c1cc3ad57ccf010418b1f 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index 88e61d9ed1b2a915664fa16b5c3def58b7364ec7..61fae758d5ba9b85c718a829f76aff9aa3813dd9 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
index c63484c628bfb291af7c95345478e67d4ab830a5..f7a1573692551f799f97f98481bdf9a0caf94261 100644 (file)
@@ -1,6 +1,6 @@
 // Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2012 Google Inc. All rights reserved.
-// http://code.google.com/p/ceres-solver/
+// Copyright 2015 Google Inc. All rights reserved.
+// http://ceres-solver.org/
 //
 // Redistribution and use in source and binary forms, with or without
 //